import org.lilie.services.eliot.securite.impl.Item
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.impl.Autorisation
-
-import org.lilie.services.eliot.securite.AccessManager
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.temps.exception.EliotTempsException
import org.lilie.services.eliot.temps.exception.AgendaIntrouvabeException
import org.lilie.services.eliot.temps.exception.AgendaCreationException
-import org.lilie.services.eliot.securite.Permission
import org.lilie.services.eliot.annuaire.AnnuaireService
import org.lilie.services.eliot.DistantAutoriteService
import org.lilie.services.eliot.AutoriteTypeEliot
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.etablissement.EtablissementService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
-
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.securite.permission.partageauto.AgendaPartageAutoService
import org.lilie.services.eliot.AutorisationService
import org.lilie.services.eliot.GormUtils
-import org.hibernate.FetchMode
/**
* Services des différents types d'agenda
public static final String ET = "Emploi du temps "
public static final String ETABLISSEMENT = " de l'établissement "
public static final String CS = "Calendrier scolaire "
- public static final int VALEUR_DROITS_ECRITURE_LECTURE =
- Permission.PEUT_CONSULTER_CONTENU + Permission.PEUT_MODIFIER_CONTENU
/**
* Crée un agenda personnel
- * @param nom : nom de l'agenda
- * @param description : description de l'agenda
- * @param securiteSession : session courante
- * @retrurn agenda: agenda crée
- * @throws EliotTempsException en cas
- * d'erreur lors de la création
*/
Agenda creerAgendaPersonnel(String nom,
String description,
- SecuriteSession securiteSession) {
+ SecuriteSession securiteSession
+ ) {
+
if (log.infoEnabled) {log.info("Création de l'agenda personnel $nom")}
+
Autorite proprietaire = (Autorite) securiteSession.defaultAutorite
- //création de l'Item
+
Item item = new Item(type: ItemService.ITEM_TYPE_AGENDA)
item.save()
- // crée l'autorisation et specifie que l'autorité est le propriétaire de l'item
+
autorisationService.creeAutorisation(
proprietaire,
item,
0
)
- // récupère le type d'agenda
TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
TypeAgendaEnum.STANDARD
)
- // création de l'agenda
+
Agenda agenda = internalCreerAgenda(nom,
description,
null,
/**
* Crée un agenda de type ETS
- * Attribut les droits en consultation et en modification
- * @param StructureEnseignement : structure d'enseignemant
- * @param forceCreation : flag indiquant si il faur forcer la création si l'agenda n'existe pas
- * @return agenda: agenda crée
- * @throws EliotTempsException en cas
- * d'erreur lors de la création
- *
*/
Agenda getAgendaEmploiDuTempsForStructure(StructureEnseignement structEnseignement,
boolean forceCreation = true
structEnseignement,
typeAgenda
)
- // si l'agenda n'existe pas et si la force créeation est à true, en crée un nouvel
+
if (!agenda && forceCreation) {
if (log.infoEnabled) {log.info "Création de l'agenda de la structure $structEnseignement"}
- //infos agenda
+
String nom = ET + structEnseignement.code
String description = nom + ETABLISSEMENT +
structEnseignement.etablissement.nomAffichage
- // création de l'item
+
Item item = new Item(type: ItemService.ITEM_TYPE_AGENDA)
item.save(failOnError: true)
- // autorité propriétaire (eliotTemps), création si il n'existe pas
+
Autorite autoriteTemps =
DefaultSecuriteSessionFactory.getAutoriteEliotForIdExterne(
AutoriteTypeEliot.IDEXTERNE_ELIOT_AUTORITE_TEMPS,
true
)
- // autorisation du propriétaire
+
autorisationService.creeAutorisation(
autoriteTemps,
item,
true,
0
)
- // création de l'agenda
+
agenda = internalCreerAgenda(
nom,
description,
null,
null
)
- // autorisations par défaut sur l'agenda
- agendaPartageAutoService.partageAgenda(agenda)
+ agendaPartageAutoService.partageAgenda(agenda)
}
return agenda
}
/**
- * Retourne l'agenda de type ETE pour un enseignant donné et un établissement donné
- * Attribut les droits en consultation et en modification
- * @param idExterneEnseignant : l'enseignant
- * @param idExterneEtablissement identifiant externe de l'établissement
- * @param forceCreation : flag indiquant si il faur forcer la création si l'agenda n'existe pas
- * @return agenda: agenda crée
- * @throws EliotTempsException en cas
- * d'erreur lors de la création
- *
+ * Crée ou retourne l'agenda d'un enseignant
+ * attribue les droits nécessaire en cas de la création
*/
- Agenda getAgendaEmploiDuTempsForEnseignantAndEtablissement(String idExterneEnseignant,
- String idExterneEtablissement,
+ Agenda getAgendaEmploiDuTempsForEnseignantAndEtablissement(String enseignantIdExterne,
+ String etablissementIdExterne,
Boolean forceCreation = true)
throws EliotTempsException {
- // infos sur l'autoriteEnseignant
Autorite autoriteEnseignant = distantAutoriteService.getAutoriteActeurForIdExterne(
- idExterneEnseignant,
+ enseignantIdExterne,
true
)
- // Etablissement
+
Etablissement etablissement =
etablissementService.findEtablissementByIdExterne(
- idExterneEtablissement
+ etablissementIdExterne
)
- // Création de type d'agenda
TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
TypeAgendaEnum.ETE
)
- // recherche de l'agenda
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 (!agenda && forceCreation) {
String nomAffichage = localPersonneService.getNomAffichage(autoriteEnseignant)
if (log.infoEnabled) {log.info "Création de l'agenda de l'enseignant " + nomAffichage}
- // infos agenda
String nom = ET + " " + nomAffichage + " ($etablissement.nomAffichage)"
String description = nom
- // création de l'Item
Item item = new Item(type: ItemService.ITEM_TYPE_AGENDA)
item.save(failOnError: true)
- // autorité propriétaire (eliotTemps), création si il n'existe pas
Autorite autoriteTemps =
DefaultSecuriteSessionFactory.getAutoriteEliotForIdExterne(
AutoriteTypeEliot.IDEXTERNE_ELIOT_AUTORITE_TEMPS,
true
)
- // autorisation du propriétaire
+
autorisationService.creeAutorisation(
autoriteTemps,
item,
true,
0
)
- // creation de l'agenda
+
agenda = internalCreerAgenda(
nom,
description,
etablissement,
autoriteEnseignant
)
- // autorisations par défaut sur l'agenda
+
agendaPartageAutoService.partageAgenda(agenda)
}
return agenda
}
/**
- * Retourne l'agenda scolaire de l'établissement
- * Attribut les droits en consultation et en modification
- * @param forceCreation : flag indiquant si il faur forcer la création si l'agenda n'existe pas
- * @return agenda agenda crée
- * @throws EliotTempsException en cas
- * d'erreur lors de la création
+ * Crée ou retourne l'agenda de l'établissement
+ * attribue les droits nécessaire en cas de la création
*/
public Agenda getAgendaScolaireForEtablissement(Etablissement etablissement,
- boolean forceCreation = true
- ) throws EliotTempsException {
- // Création de type d'agenda
+ boolean forceCreation = true) throws EliotTempsException {
+
TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
TypeAgendaEnum.CSE
)
etablissement,
typeAgenda
)
- // si l'agenda n'existe pas et si la force créeation est à true, en crée un nouvel
+
if (!agenda && forceCreation) {
- if (log.infoEnabled) {log.info "Création de l'agenda scolaire de l'établissement $etablissement.nomAffichage"}
- // infos établissement
+ if (log.infoEnabled) {
+ log.info "Création de l'agenda scolaire de l'établissement $etablissement.nomAffichage"
+ }
+
String nom = CS + etablissement.nomAffichage
String description = CS + etablissement.nomAffichage
- // création d'Item
+
Item item = new Item(type: ItemService.ITEM_TYPE_AGENDA)
item.save()
- // autorité propriétaire (eliotTemps), création si il n'existe pas
+
Autorite autoriteTemps =
DefaultSecuriteSessionFactory.getAutoriteEliotForIdExterne(
AutoriteTypeEliot.IDEXTERNE_ELIOT_AUTORITE_TEMPS,
true)
- // autorisation du propriétaire
+
autorisationService.creeAutorisation(
autoriteTemps,
item,
true,
0
)
- // creation de l'agenda
+
agenda = internalCreerAgenda(nom,
description,
preferencesUtilisateursAgendaService.getCouleur(),
etablissement,
null
)
- // autorisations par défaut sur l'agenda
+
agendaPartageAutoService.partageAgenda(agenda)
}
)
}
if (agenda) {
- if (log.infoEnabled) {log.info "Modification de l'agenda $agenda par $securiteSession.defaultAutorite"}
+ if (log.infoEnabled) {
+ log.info "Modification de l'agenda $agenda par $securiteSession.defaultAutorite"
+ }
+
if (proprietesAgenda.nom) {
agenda.nom = proprietesAgenda.nom
}
* Supprime les préférences des utilisateurs sur l'agenda (supp cascade)
* Supprime les événements fils de l'agenda (supp cascade)
* Détache les événements liés (ne les supprime pas)
- * @param identifiant : identifiant de l'agenda à supprimer
- * @param securiteSession : session courante
- * @throws EliotTempsException: l'agenda n'existe pas
- * @throws AutorisationException: l'utilisateur n'a pas
- * le droit de supprimer l'agenda
*/
void supprimerAgenda(Long identifiant, SecuriteSession securiteSession)
throws EliotTempsException, AutorisationException {
String getIdItemAgendaHql = """SELECT a.item.id FROM Agenda a
WHERE a.id = :agendaId"""
- Long itemAgendaId = Agenda.executeQuery(getIdItemAgendaHql, ['agendaId' : identifiant])[0]
+ Long itemAgendaId = Agenda.executeQuery(getIdItemAgendaHql, ['agendaId': identifiant])[0]
// supprimer les preference_utilisateur_agenda
String suppressionPrefsHql = """DELETE PreferencesUtilisateurAgenda p
String suppressionAutorisationsHql = """DELETE Autorisation aut
WHERE aut.item.id = :itemAgendaId"""
- Autorisation.executeUpdate(suppressionAutorisationsHql, ['itemAgendaId' : itemAgendaId])
+ Autorisation.executeUpdate(suppressionAutorisationsHql, ['itemAgendaId': itemAgendaId])
// Suppression de l'item correspondant à l'agenda supprimé
String suppressionItemAgendaHql = """DELETE Item it
}
}
- /**
- * Récupére la liste des agendasInfo par permission et type de la session
- * @param securiteSession session courante
- * @param proprietaire : si l'utilisateur doit être le propriétaire de l'agenda ou pas
- * @param forceCreationPreferences : flag indiquant si il faut forcer la création
- * des préférences si il n'existe pas
- * @return agendasInfoPermission agendas
- *
- */
- Collection<AgendaAgendaInfo> getAgendaInfoForActeur(TypeAgenda typeAgenda,
- int valeurPermissionExplicite,
- SecuriteSession securiteSession,
- Boolean proprietaire = null,
- Boolean forceCreationPreferences = true
- ) {
- // Récupère tous les agendas de type TypeAgenda et de valeur minimum de permission
- List<Agenda> agendasPermission = getAgendasByUserAndTypeAndPemission(
- typeAgenda,
- valeurPermissionExplicite,
- securiteSession,
- proprietaire
- ) as List
-
- // cette construction n'est pas efficace, mais comme cette methode est
- // utilisee seulement dans les testes, ce n'est pas grave
- List<AgendaAgendaInfo> agendasInfoPermission = []
- List<AgendaProprietaireInfo> apis = agendasPermission.collect { Agenda agenda ->
-
- new AgendaProprietaireInfo(
- agenda: agenda,
- agendaAppartientUtilisateurLoggue: Autorisation.createCriteria().get {
- item {
- eq('id', agenda.itemId)
- }
- autorite {
- eq('id', securiteSession.defaultAutorite.id)
- }
- eq('proprietaire', true)
- cache false
- } != null
- )
- }
-
- if (agendasPermission.size() > 0 && forceCreationPreferences) {
- agendasInfoPermission =
- interneAjouterPreferencesEtConstruireInfoToListeAgenda(apis,
- securiteSession)
- }
- return agendasInfoPermission
- }
-
- /**
- * Ajoute les préfernences par défaut pour un agenda, si elles existent pas
- * et contruit la liste des agendas info
- */
- private List<AgendaAgendaInfo> interneAjouterPreferencesEtConstruireInfoToListeAgenda(List<AgendaProprietaireInfo> agendaProprioInfos,
- SecuriteSession securiteSession
- ) {
-
- List<AgendaAgendaInfo> agendasInfo = []
-
- // récupère les preferences. Création en mode lasy
- Map agendaPreferences = preferencesUtilisateursAgendaService.
- getPreferencesUtilisateurAgenda(agendaProprioInfos*.agenda, securiteSession)
-
- agendaPreferences.each {Agenda agenda, PreferencesUtilisateurAgenda preference ->
-
- // construit l'agendaInfo
- AgendaAgendaInfo agendaInfo = getAgendaAgendaInfo(agendaProprioInfos.find {
- it.agenda.id == agenda.id
- },
- preference,
- securiteSession
- )
-
- agendasInfo.add(agendaInfo)
- }
-
- return agendasInfo
- }
-
- /**
- * Construit un agendaInfo
- * @param agendaProprietaireInfo agenda et ses infos
- * @param preferences : les preferences de l'utilisateur sur l'agenda
- * @param session : la session courante
- * @return agendaInfo : l'agenda information construit
- */
- AgendaAgendaInfo getAgendaAgendaInfo(AgendaProprietaireInfo agendaProprietaireInfo,
- PreferencesUtilisateurAgenda preferences,
- SecuriteSession securiteSession) {
- Agenda agenda = agendaProprietaireInfo.agenda
- List<Autorisation> agendaAutorisations = agendaProprietaireInfo.autorisations
-
- // Cree AccessManager avec les autorisations prechargees, si on les connait.
- // C'est pour eviter les requetes si on les connait deja
- AccessManager accessManager = null
- if (agendaProprietaireInfo.autorisations != null) {
- accessManager = new AccessManager(
- agenda.item,
- securiteSession,
- agendaAutorisations
- )
- } else {
- accessManager = new AccessManager(
- agenda.item,
- securiteSession
- )
- }
-
- AgendaAgendaInfo agendaInfo = new AgendaAgendaInfo(
- id: agenda.id,
- nom: agenda.nom,
- description: agenda.description,
- typeAgenda: agenda.typeAgenda,
- nomPersonnalise: preferences.nomPersonnalise,
- couleur: preferences.couleur,
- selectionne: false,
- proprietaire: agendaProprietaireInfo.agendaAppartientUtilisateurLoggue,
- peutSupprimer: accessManager.peutSupprimer(),
- peutCreerEvenement: accessManager.peutModifierLeContenu() &&
- !securiteSession.defaultAutorite.aUnAccesRetreint(),
- peutModifierProprietes: agendaProprietaireInfo.agendaAppartientUtilisateurLoggue,
- enCoursSuppression: agenda.isEnCoursDeSuppression() &&
- !agendaProprietaireInfo.agendaAppartientUtilisateurLoggue
- )
- return agendaInfo
- }
-
- /**
- * Construit un agendaInfo
- * @param preferences : les preferences de l'utilisateur sur l'agenda
- * @param session : la session courante
- * @return agendaInfo : l'agenda information construit
- */
- AgendaAgendaInfo getAgendaAgendaInfo(Agenda agenda,
- PreferencesUtilisateurAgenda preferences,
- SecuriteSession securiteSession) {
-
- AccessManager accessManager = new AccessManager(
- agenda.item,
- securiteSession
- )
- AgendaAgendaInfo agendaInfo = new AgendaAgendaInfo(
- id: agenda.id,
- nom: agenda.nom,
- description: agenda.description,
- typeAgenda: agenda.typeAgenda,
- nomPersonnalise: preferences.nomPersonnalise,
- couleur: preferences.couleur,
- selectionne: false,
- proprietaire: (agenda.getProprietaire().id ==
- securiteSession.defaultAutorite.id),
- peutSupprimer: accessManager.peutSupprimer(),
- peutCreerEvenement: accessManager.peutModifierLeContenu(),
- peutModifierProprietes: (agenda.getProprietaire().id ==
- securiteSession.defaultAutorite.id)
- )
- return agendaInfo
- }
-
-
-
List<Long> findAllAgendaIdEnseignantByEnseignant(SecuriteSession securiteSession) {
List<Long> defaultAgendasIdEnseignant = []
- // type de l'agenda, création si il n'existe pas
+
TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
TypeAgendaEnum.ETE
)
return (ids.size() > 0)
}
-
/**
* Crée un agenda
* @param nom : nom de l'agenda
structureEnseignement,
etablissement,
enseignant)
+
if (agendaExistant) {
return agendaExistant
- } else {
+ }
+ else {
Agenda agenda = new Agenda(
nom: nom,
description: description,
}
return agenda
}
-
- /**
- * Récupération des agendas de type Typeagenda, de valeur de supérieure ou égale
- * à la valeurPermissionsExplicite
- * dont la session a un droit minimum de consultation
- * @param securiteSession : la session de sécurité courante
- * @param agendaType : type d'agenda, null: quelque soit le type de l'agenda
- * @param proprietaire : si l'acteur doit être propriétaire ou pas
- * - null : propriétaire et non propriétaire
- * - true: propriétaire
- * - false: non propriétaire
- * @return la collection d'agenda
- */
- private Collection<Agenda> getAgendasByUserAndTypeAndPemission(TypeAgenda typeAgenda,
- int valeurPermissionExplicite,
- SecuriteSession securiteSession,
- Boolean proprietaire = null) {
- // liste des items d'agendas de valeur de permission supérieure ou égale
- Collection<Item> listItemsAgenda = getItemsAgendaForSession(
- securiteSession,
- valeurPermissionExplicite,
- proprietaire
- )
- Collection<Agenda> listAgendas = []
- List listIDItemsAgenda = []
-
- if (listItemsAgenda.size() > 0) {
- listIDItemsAgenda = listItemsAgenda*.id
-
- listAgendas = Agenda.withCriteria {
- and {
- 'in'("item.id", listIDItemsAgenda)
- if (typeAgenda) {
- eq("typeAgenda.id", typeAgenda.id)
- }
- }
- order "nom"
- }
- }
- return listAgendas
- }
-
- /**
- * Récupération de tous les Items de type agenda
- * sur lesquels la session a le droit minimum de la valeurPermossionsExplicite
- * @param securiteSession : la session de sécurité courante
- * @param valeurPermissionsExplicite : la valeur de la permission
- * @param proprietaire : si l'acteur doit être propriétaire ou pas
- * - null : propriétaire et non propriétaire
- * - true: propriétaire
- * - false: non propriétaire
- * @return la collection d'Item
- */
- private Collection<Item> getItemsAgendaForSession(SecuriteSession securiteSession,
- int valeurPermossionsExplicite,
- Boolean proprietaire = null) {
- Collection<Autorisation> autorisations = []
- autorisations = Autorisation.withCriteria {
- and {
- 'in'("autorite", securiteSession.getAutorites())
- if (proprietaire != null) {
- eq("proprietaire", proprietaire)
- }
-
- or {
- ge("valeurPermissionsExplicite",
- valeurPermossionsExplicite)
- eq("proprietaire", Boolean.TRUE)
- }
- item {
- eq("type", ItemService.ITEM_TYPE_AGENDA)
- }
- fetchMode('item', FetchMode.EAGER)
- }
- }
- return autorisations*.item
- }
}
\ No newline at end of file
+++ /dev/null
-package org.lilie.services.eliot.temps
-/**
- * Remonte des informations sur l'agenda
- * @author bahj
- */
-
-public class AgendaAgendaInfo {
- String id
- String nom
- String description
- TypeAgenda typeAgenda
- String nomPersonnalise
- String couleur
- Boolean selectionne
- Boolean proprietaire
- Boolean peutSupprimer
- Boolean peutCreerEvenement
- Boolean peutModifierProprietes
- Boolean enCoursSuppression
-}
\ No newline at end of file
assertNull preference
}
- /**
- * Cherche les agendas visibles pour la personne logguee.
- * @param typeAgenda type d'agenda a chercher
- * @return Liste d'AgendaAgendaInfo vidibles pour la personne logguee
- */
- private List<AgendaAgendaInfo> getAgendasVisibles(SecuriteSession securiteSession,
- TypeAgenda typeAgenda) {
- // récupère agenda perso pas propriétaire => partagé => 0
- return tempsAgendaService.
- getAgendaInfoForActeur(typeAgenda,
- Permission.PEUT_CONSULTER_CONTENU,
- securiteSession,
- false
- )
- }
-
- /**
- * Vérifie la remonté des agendas par type et par permission pour un acteur
- */
- void testGetAgendaInfoForActeur() {
- SecuriteSession securiteSession = SessionUtils.securiteSession(dummySession())
- TypeAgenda typeStandard = TypeAgenda.findByCode(TypeAgendaEnum.STANDARD.getCode())
-
- Long nbAgendasVisibles = getAgendasVisibles(securiteSession, typeStandard).size()
-
- Agenda agendaPerso = retournerAgenda("Agenda Perso", securiteSession)
-
- StructureEnseignement str = localInitDonneesCommunesTestService.
- getClasse(PopulationTestClasse.CLASSE_1)
- Agenda agendaStruct = tempsAgendaService.getAgendaEmploiDuTempsForStructure(
- str
- )
-
- Etablissement etablissement =
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- )
- Agenda agendaScolaire = tempsAgendaService.
- getAgendaScolaireForEtablissement(etablissement)
-
- // récupère agenda perso propriétaire => min 1
- List<AgendaAgendaInfo> listeAgendaPerso = tempsAgendaService.
- getAgendaInfoForActeur(typeStandard,
- 0,
- securiteSession,
- true
- )
- boolean contientAgendaPerso = false
- listeAgendaPerso.each {AgendaAgendaInfo agInfo ->
- if (agInfo.id == (agendaPerso.id as String))
- contientAgendaPerso = true
- }
- assertTrue("Contient agenda personnel", contientAgendaPerso)
-
- // récupère agendas perso pas propriétaire => partagées
- Long nbAgendasVisiblesApresCreations =
- getAgendasVisibles(securiteSession, typeStandard).size()
-
- assertTrue("Les agendas partagees ont ete crees, meme si elles " +
- "ne sont pas sensees de l'etre",
- (nbAgendasVisiblesApresCreations - nbAgendasVisibles) == 0)
-
- // récupère agenda structure avec droit de consultation => 1
- TypeAgenda typeStructure = TypeAgenda.findByCode(TypeAgendaEnum.ETS.getCode())
-
- List<AgendaAgendaInfo> listeAgendaStruct = tempsAgendaService.
- getAgendaInfoForActeur(typeStructure,
- Permission.PEUT_CONSULTER_CONTENU,
- securiteSession
- )
- boolean contientAgendaStruct = false
- listeAgendaStruct.each {AgendaAgendaInfo agInfo ->
- if (agInfo.id == (agendaStruct.id as String))
- contientAgendaStruct = true
- }
- assertTrue("Contient agenda structure", contientAgendaStruct)
-
- // récupère agenda structure avec droit de modification => 0
- List<AgendaAgendaInfo> listeAgendaStructModif = tempsAgendaService.
- getAgendaInfoForActeur(typeStructure,
- Permission.PEUT_MODIFIER_CONTENU,
- securiteSession
- )
- assertTrue("Agenda structure droit modification", listeAgendaStructModif.size() == 0)
- }
-
-
private void verifieDroitsAgendaStructure(Agenda agenda, StructureEnseignement str) {
//Direction
}
}
- /**
- * Retourne un agenda de type standard
- */
- private Agenda retournerAgenda(String nomAgenda,
- SecuriteSession securiteSession) {
- // crée le type si il n'existe pas dans la base
- TypeAgendaEnum typeAgendaEnum = TypeAgendaEnum.STANDARD
- TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
- typeAgendaEnum
- )
- return tempsAgendaService.creerAgendaPersonnel(nomAgenda,
- "description",
- securiteSession)
- }
-
/*
* élève
*/
import org.lilie.services.eliot.agenda.menu.MenuService
import org.lilie.services.eliot.SessionUtils
import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.temps.AgendaAgendaInfo
-import org.lilie.services.eliot.temps.Agenda
-import org.lilie.services.eliot.temps.PreferencesUtilisateurAgenda
/**
* @author jbui
MenuAideAgendaService menuAideAgendaService
AgendaService agendaService
- /**
- * Construit un agenda information pour la vue
- * Si les préférences ne sont pas crées, il sont crées
- * @return agendaInfo agenda info de l'agenda en paramètre
- *
- */
- AgendaAgendaInfo formateAgendaForStore(Agenda agenda) {
- // Récupère la préférence
- PreferencesUtilisateurAgenda prefAgenda = agendaService.
- getPreferencesUtilisateurAgenda(
- agenda,
- getSecuriteSession()
- )
- // construit l'agenda info
- AgendaAgendaInfo agendaInfo = agendaService.getAgendaAgendaInfo(
- agenda,
- prefAgenda,
- getSecuriteSession()
- )
- return agendaInfo
- }
-
- /**
- * Indique s'il s'agit d'un agenda partagé
- */
- Boolean isAgendaPartage(Agenda agenda) {
- Boolean isAgendaPartage = false
-
- List listeAgendasPartages = agendaService.getPartagesAgendaInfoForActeur(
- getSecuriteSession()
- )
- listeAgendasPartages.each {
- AgendaAgendaInfo agendaAgendaInfo ->
-
- if (Integer.parseInt(agendaAgendaInfo.id) ==
- agenda.id && !agendaAgendaInfo.proprietaire) {
- isAgendaPartage = true
- }
- }
- return isAgendaPartage
- }
/**
* Retourne la securité session de la session courante
return menuAideInfo
}
-
}
import grails.converters.JSON
import org.lilie.services.eliot.temps.Agenda
-import org.lilie.services.eliot.temps.AgendaAgendaInfo
import org.lilie.services.eliot.temps.exception.EliotTempsException
-import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.temps.TempsSecuriteService
import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.url.EliotUrlService
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.temps.exception.AgendaIntrouvabeException
/**
- * author bahj
+ * @author bahj
*/
class AgendaController extends AbstractAgendaController {
- LocalPersonneService localPersonneService
TempsSecuriteService tempsSecuriteService
EliotUrlService eliotUrlService
AgendaPersonnaliseService agendaPersonnaliseService
+ AgendaInfoMarshallerService agendaInfoMarshallerService
def index = {
jourCourant: session.jourCourant,
aUnAccesRetreint: SessionUtils.securiteSession(session).
defaultAutorite.aUnAccesRetreint(),
- mesAgenda: getAgendaInfo(mesAgenda) as JSON,
- agendaScolaire: getAgendaInfo(agendaScolaire) as JSON,
- agendaPartage: getAgendaInfo(agendaPartage) as JSON
+ mesAgenda: agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ mesAgenda
+ ) as JSON,
+ agendaScolaire: agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ agendaScolaire
+ ) as JSON,
+ agendaPartage: agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ agendaPartage
+ ) as JSON
]
// pré-sélection
)
}
- AgendaAgendaInfo agendaInfo = formateAgendaForStore(agenda)
+ Map modele = prepareBaseModele(null)
+ AgendaInfo agendaInfo = agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ agenda
+ )
+
Boolean agendaCree = params?.agendaCree ? true : false
Boolean afficheDroitsEtPermissions = afficheDroitsEtPermissions(agenda)
- Map modele = [
+ modele += [
agenda: agendaInfo as JSON,
agendaCree: agendaCree,
agendaObj: agendaInfo,
jourCourant: session?.jourCourant
]
- modele += prepareBaseModele(null)
+
render(view: '/agenda/creerAgenda', model: modele)
}
agendaInfoSuppression = message(code: "eliot.agenda.agendaInfoSuppression")
}
- AgendaAgendaInfo agendaInfo = formateAgendaForStore(agenda)
+ AgendaInfo agendaInfo = agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ agenda
+ )
Boolean afficheDroitsEtPermissions = afficheDroitsEtPermissions(agenda)
agenda: agendaInfo as JSON,
agendaObj: agendaInfo,
nomProprietaire: nomProprietaire,
- isAgendaPartage: isAgendaPartage(agenda)
+ isAgendaPartage: agendaService.isAgendaMAEtePartageManuellement(
+ securiteSession,
+ agenda
+ )
]
modele += prepareBaseModele(null)
return agendaCouleur
}
- /**
- * Transforme les agendas personnalisé en des agendas info pour la vue
- */
- private List<AgendaInfo> getAgendaInfo(
- Collection<AgendaPersonnalise> allAgendaPersonnalise,
- boolean encodeAsHtml = true
- ) {
-
- List<AgendaInfo> resultats = []
-
- allAgendaPersonnalise.each { AgendaPersonnalise agendaPersonnalise ->
-
- resultats << new AgendaInfo(
- id: agendaPersonnalise.agenda.id,
- nom: encodeAsHtml ? agendaPersonnalise.getNom().encodeAsHTML() :
- agendaPersonnalise.getNom(),
- couleur: agendaPersonnalise.preferences.couleur,
- description: agendaPersonnalise.agenda.description,
- typeCode: agendaPersonnalise.typeCode,
- selectionne: false,
- enCoursSuppression: agendaPersonnalise.isProprietaireAAccesRestreint() &&
- !agendaPersonnalise.isProprietaire(),
- peutCreerEvenement: agendaPersonnalise.peutModifierLeContenu() &&
- !securiteSession.defaultAutorite.aUnAccesRetreint(),
- peutModifierProprietes: agendaPersonnalise.isProprietaire(),
- peutSupprimer: agendaPersonnalise.peutSupprimer(),
- proprietaire: agendaPersonnalise.isProprietaire()
- )
- }
-
- return resultats.sort {a, b ->
- if (a.typeCodeValeurTri > b.typeCodeValeurTri) {
- return +1
- }
- else if (a.typeCodeValeurTri < b.typeCodeValeurTri) {
- return -1
- }
-
- return a.nom <=> b.nom
- }
- }
private def verifieAgendaNom(AgendaCommand command) {
if (command.isNomIncorrect()) {
* <http://www.cecill.info/licences.fr.html>.
*/
+
+
package org.lilie.services.eliot.agenda
import org.lilie.services.eliot.temps.Agenda
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.securite.permission.ItemDroits
import org.lilie.services.eliot.securite.AccessManager
-import org.lilie.services.eliot.temps.AgendaAgendaInfo
import grails.converters.JSON
import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
import org.lilie.services.eliot.securite.permission.ItemDroitsService
PartageManuelService partageManuelService
ItemDroitsService itemDroitsService
+ AgendaInfoMarshallerService agendaInfoMarshallerService
/**
* Affiche les droits et permissions d'un agenda
flash.message = g.message(code: 'eliot.agenda.droits.maj.success')
flash.gardeMessages = true // affiche le message
- AgendaAgendaInfo agendaInfo = formateAgendaForStore(agenda)
-
+ AgendaInfo agendaInfo = agendaInfoMarshallerService.getAgendaInfo(
+ securiteSession,
+ agenda
+ )
Map modele = prepareBaseModele(null)
modeEdition: true,
disableDroitsEtPermissions: false,
droitsIncomplets: agenda.droitsIncomplets,
- isAgendaPartage: isAgendaPartage(agenda)
+ isAgendaPartage: agendaService.isAgendaMAEtePartageManuellement(
+ securiteSession,
+ agenda
+ )
]
render(view: '/agenda/proprietesAgenda', model: modele)
-
}
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.url.EliotUrlService
import org.lilie.services.eliot.applications.EliotApplicationEnum
-import org.lilie.services.eliot.temps.AgendaAgendaInfo
-import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.temps.TypeAgendaEnum
Agenda agenda = Agenda.get(Long.parseLong(temp[1]))
Evenement evenement = Evenement.get(Long.parseLong(temp[0]))
- if (getSecuriteSession()) {
- tempsSecuriteService.verifieAutorisationConsultationContenu(
- agenda,
- getSecuriteSession()
- )
- }
+ tempsSecuriteService.verifieAutorisationConsultationContenu(
+ agenda,
+ getSecuriteSession()
+ )
AgendaEvenementInfo agEvIn = getAgendaEvenementInfoFromId(idEventAgenda)
Map evt = formateAgendaEvenementInfoForForm(agEvIn)
- Boolean isAgendaPartage = false
- List listeAgendasPartages = agendaService.getPartagesAgendaInfoForActeur(
- getSecuriteSession()
+ Boolean isAgendaPartage = agendaService.isAgendaMAEtePartageManuellement(
+ securiteSession,
+ agenda
)
- listeAgendasPartages.each {
- AgendaAgendaInfo agendaAgendaInfo ->
-
- if (Integer.parseInt(agendaAgendaInfo.id) ==
- agenda.id && !agendaAgendaInfo.proprietaire) {
- isAgendaPartage = true
- }
- }
- Long proprietaireAutoriteId = evenement.auteurId
-
- String typeAutorite = Autorite.get(proprietaireAutoriteId).type
String nomProprietaire = ''
- if (typeAutorite == 'acteur') {
- Personne proprietaire = localPersonneService.findPersonneByAutoriteId(
- proprietaireAutoriteId
- )
- nomProprietaire = proprietaire.nomAffichage()
+ if (isAgendaPartage) {
+ Autorite proprietaire = Autorite.get(evenement.auteurId)
+ if (proprietaire.type == Autorite.TYPE_ACTEUR) {
+ nomProprietaire = proprietaire.nomAffichage()
+ }
}
boolean peutModifierAct
--- /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.temps.Agenda
+import org.lilie.services.eliot.temps.PreferencesUtilisateurAgenda
+import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.temps.PreferencesUtilisateursAgendaService
+
+class AgendaInfoMarshallerService {
+
+ static transactional = true
+ PreferencesUtilisateursAgendaService preferencesUtilisateursAgendaService
+
+ /**
+ * Transforme les agendas personnalisé en des agendas info pour la vue
+ */
+ List<AgendaInfo> getAgendaInfo(SecuriteSession securiteSession,
+ Collection<AgendaPersonnalise> allAgendaPersonnalise,
+ boolean encodeAsHtml = true
+ ) {
+
+ List<AgendaInfo> resultats = []
+
+ allAgendaPersonnalise.each { AgendaPersonnalise agendaPersonnalise ->
+
+ resultats << new AgendaInfo(
+ id: agendaPersonnalise.agenda.id,
+ nom: encodeAsHtml ? agendaPersonnalise.getNom().encodeAsHTML() :
+ agendaPersonnalise.getNom(),
+ couleur: agendaPersonnalise.preferences.couleur,
+ description: agendaPersonnalise.agenda.description,
+ typeCode: agendaPersonnalise.typeCode,
+ selectionne: false,
+ enCoursSuppression: agendaPersonnalise.isProprietaireAAccesRestreint() &&
+ !agendaPersonnalise.isProprietaire(),
+ peutCreerEvenement: agendaPersonnalise.peutModifierLeContenu() &&
+ !securiteSession.defaultAutorite.aUnAccesRetreint(),
+ peutModifierProprietes: agendaPersonnalise.isProprietaire(),
+ peutSupprimer: agendaPersonnalise.peutSupprimer(),
+ proprietaire: agendaPersonnalise.isProprietaire()
+ )
+ }
+
+ return resultats.sort {a, b ->
+ if (a.typeCodeValeurTri > b.typeCodeValeurTri) {
+ return +1
+ }
+ else if (a.typeCodeValeurTri < b.typeCodeValeurTri) {
+ return -1
+ }
+
+ return a.nom <=> b.nom
+ }
+ }
+
+ /**
+ * Construit un agenda information pour la vue
+ */
+ AgendaInfo getAgendaInfo(SecuriteSession securiteSession, Agenda agenda) {
+
+ PreferencesUtilisateurAgenda preferences =
+ preferencesUtilisateursAgendaService.getPreferencesUtilisateurAgenda(
+ agenda,
+ securiteSession
+ )
+
+ AccessManager accessManager = new AccessManager(
+ agenda.item,
+ securiteSession
+ )
+
+ AgendaInfo agendaInfo = new AgendaInfo(
+ id: agenda.id,
+ nom: agenda.nom,
+ description: agenda.description,
+ typeCode: agenda.typeAgenda.code,
+ couleur: preferences.couleur,
+ selectionne: false,
+ proprietaire: (agenda.getProprietaire().id ==
+ securiteSession.defaultAutorite.id),
+ peutSupprimer: accessManager.peutSupprimer(),
+ peutCreerEvenement: accessManager.peutModifierLeContenu(),
+ peutModifierProprietes: (
+ agenda.getProprietaire().id == securiteSession.defaultAutorite.id
+ )
+ )
+
+ return agendaInfo
+ }
+
+}
Autorite autoriteProprietaire
public String getNom() {
- if (preferences?.nomPersonnalise) {
- return preferences.nomPersonnalise
- }
-
agenda.nom
}
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.temps.TypeAgendaEnum
import org.lilie.services.eliot.temps.TypeAgendaService
-import org.lilie.services.eliot.temps.AgendaAgendaInfo
-import org.lilie.services.eliot.securite.Permission
import grails.converters.JSON
import org.lilie.services.eliot.temps.TempsSecuriteService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.securite.impl.Autorisation
/**
* Classe de service des agendas
return agenda
}
+ Boolean isAgendaMAEtePartageManuellement(SecuriteSession securiteSession, Agenda agenda) {
+ String hql = """
+ SELECT id from Autorisation
+ WHERE item.id = :itemId
+ AND autorite.id != :autoriteId
+ AND proprietaire = true
+ AND autorite.type = 'acteur'
+ """
+ List<Autorisation> autorisations = Autorisation.executeQuery(
+ hql, [autoriteId: securiteSession.defaultAutorite.id, itemId: agenda.itemId]
+ )
+
+ return (autorisations.size() > 0)
+ }
+
/**
* Modifie les préférences de l'utilisateur sur l'agenda
* @param identifiant : identifiant de l'événement
}
-
- Collection<AgendaAgendaInfo> getPartagesAgendaInfoForActeur(SecuriteSession securiteSession) {
-
- Collection<AgendaAgendaInfo> agendasPartages
-
- // récupère le type d'agenda
- TypeAgendaEnum typeAgendaEnum = TypeAgendaEnum.STANDARD
- TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
- typeAgendaEnum
- )
-
- agendasPartages =
- tempsAgendaService.getAgendaInfoForActeur(
- typeAgenda,
- Permission.PEUT_CONSULTER_CONTENU,
- securiteSession,
- Boolean.FALSE,
- Boolean.TRUE
-
- )
-
- for (int i = agendasPartages.size() - 1; i >= 0; i--) {
-
- if (agendasPartages[i].proprietaire) {
- agendasPartages.remove(i)
- }
- }
-
- return agendasPartages
- }
-
/**
* Permet de selectionner l'agenda
* Met dans la liste des agendas sélectionnés en session,
}
}
-/**
- * Construit un agendaInfo
- * @param preferences : les preferences de l'utilisateur sur l'agenda
- * @param session : la session courante
- * @return agendaInfo : l'agenda information construit
- */
- AgendaAgendaInfo getAgendaAgendaInfo(Agenda agenda,
- PreferencesUtilisateurAgenda preferences,
- SecuriteSession securiteSession
- ) {
- return tempsAgendaService.getAgendaAgendaInfo(agenda,
- preferences,
- securiteSession
- )
- }
-
-/**
- * retourne les préférences de l'utilisateur si elle existe
- * sinon crée les préférences avec des valeur par défaut
- * @param securiteSession : la session en cours
- * @param forceCreationPreferences : flag indiquant si il faut forcer la création
- * @return preference : la preférence créee
- *
- */
- PreferencesUtilisateurAgenda getPreferencesUtilisateurAgenda(Agenda agenda,
- SecuriteSession securiteSession,
- Boolean forceCreation = true
- ) {
- return preferencesUtilisateursAgendaService.
- getPreferencesUtilisateurAgenda(agenda,
- securiteSession,
- forceCreation
- )
- }
-
/**
* Permet de récupérer la liste des agendas à séléctionnés par défaut pour la session courante
* @param securiteSession la session courante
* - Agendas de types structure d'enseignement auxquels les fils sont attachés
*/
private List<AgendaPersonnalise> getParentAgendaScolaireASelectionner(Personne personne, Map allAgendaPersonnalise) {
- List<AgendaPersonnalise> agendas = []
-
// récupère la liste des fils-élèves
List<Personne> fils =
eleveAnnuaireService.findAllEleveFromResponsable(personne)
return allAgendaPersonnalise[AgendaPersonnaliseService.AGENDA_SCOLAIRE].findAll {
structuresEnseignements*.id.contains(it.agenda.structureEnseignementId)
}
-
- return agendas
}
-
}