INVITE(
"UI",
"eliot.fonction.libelle.UI",
- true
+ false
),
CONSEILLER_FORMATION_CONTINUE(
"CFC",
),
PERSONNEL_MEDICO_SOCIAL(
"MDS",
- "eliot.fonction.libelle.MDS"
- ,true
+ "eliot.fonction.libelle.MDS",
+ true
),
PERSONNEL_OUVRIER(
"OUV",
return CODE
}
- public String getLibelle(){
+ public String getLibelle() {
return LIBELLE
}
- public Boolean getAccesParametrable(){
+ public Boolean getAccesParametrable() {
return ACCES_PARAMETRABLE
}
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveCalendrierMoisPosition
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveAbsencesService
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveAbsencesCalendrierService
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
class JsonFicheEleveController extends AbstractEliotController {
def getFicheEleveByIdPersonne = {
Map result = (Map) [:]
try {
- verifieDroitsFicheEleve(securiteSession)
+ eliotDroitsService.verifieDroitsAccesFicheEleve(
+ securiteSession,
+ etablissementCourant()
+ )
Personne eleve = Personne.get(params?.eleveId.toLong())
FicheEleve ficheEleve = ficheEleveService.construitFicheEleve(
eleve
)
result.ficheEleve = ficheEleveMarshallerService.marshallFicheEleve(ficheEleve)
- result.voirOngletCommentaire = getDroitFicheEleveCommentaire(securiteSession)
+ result.droitAccessOnglets = getFicheEleveDroitOnglets()
result.donneesNotes = getDonneesSpecifiquesNotes(eleve, ficheEleve.classe)
result[EliotConstantes.JSON_SUCCESS] = true
} catch (AutorisationException ex) {
render result as JSON
}
+ private Map getFicheEleveDroitOnglets() {
+ Map droitParOnglelt = [
+ commentaire: false,
+ sanctions: false,
+ absences: false,
+ notes: false,
+ conseil: false
+ ]
+
+ List<EliotFonctionnalites> fonctionnalites =
+ eliotDroitsService.getFicheEleveEliotFonctionnalitesAccessible(
+ securiteSession,
+ etablissementCourant()
+ )
+
+ if (fonctionnalites.contains(ScolariteFonctionnalites.FICHE_ELEVE_COMMENTAIRE)) {
+ droitParOnglelt.commentaire = true
+ }
+
+ if (fonctionnalites.contains(ScolariteFonctionnalites.FICHE_ELEVE_SANCTIONS)) {
+ droitParOnglelt.sanctions = true
+ }
+
+ if (fonctionnalites.contains(ScolariteFonctionnalites.FICHE_ELEVE_ABSENCES)) {
+ droitParOnglelt.absences = true
+ }
+
+ if (fonctionnalites.contains(ScolariteFonctionnalites.FICHE_ELEVE_NOTES)) {
+ droitParOnglelt.notes = true
+ }
+
+ if (fonctionnalites.contains(ScolariteFonctionnalites.FICHE_ELEVE_CONSEIL)) {
+ droitParOnglelt.conseil = true
+ }
+
+ return droitParOnglelt
+ }
+
/**
* Donees specifiques pour les onglet Notes de la fiche eleve
*/
preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
- List <FicheEleveCalendrierMoisPosition> allFicheEleveCalendrierMoisPosition =
+ List<FicheEleveCalendrierMoisPosition> allFicheEleveCalendrierMoisPosition =
ficheEleveAbsencesService.associerPositionEtMois(calendrier)
DetailJourInfo detailJourInfo =
def saveCommentaire = {
Map result = [:]
try {
- if (!getDroitFicheEleveCommentaire(securiteSession)) {
- throw AutorisationException.modificationContenuException()
- }
+ eliotDroitsService.verifieDroitsModificationFicheEleve(
+ securiteSession,
+ etablissementCourant()
+ )
Personne eleve = Personne.get(params?.eleveId.toLong())
ficheEleveCommentaireService.saveCommentaire(
render result as JSON
}
- private def verifieDroitsFicheEleve(SecuriteSession securiteSession) {
- if (!securiteSession.
- hasFonctionIn([
- FonctionEnum.DIRECTION,
- FonctionEnum.EDUCATION,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.ENSEIGNANT],
- etablissementCourantId())) {
- throw AutorisationException.consultationContenuException()
- }
- }
-
- private boolean getDroitFicheEleveCommentaire(SecuriteSession securiteSession) {
- return securiteSession.hasFonctionIn(
- [
- FonctionEnum.DIRECTION,
- FonctionEnum.EDUCATION,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
- FonctionEnum.CHEF_TRAVAUX
- ],
- etablissementCourantId()
- )
- }
-
-
protected MenuInfo buildMenuInfo(Object page) {
return null; //To change body of implemented methods use File | Settings | File Templates.
etablissement(nullable: false)
actif(nullable: false)
}
-
-
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.securite.impl
-import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.annuaire.Fonction
+import org.lilie.services.eliot.environnement.EnvironnementUtil
class AccesFonctionnaliteFonctionDefaut {
static mapping = {
table('securite.acces_fonctionnalite_fonction_defaut')
id column: 'id', generator: 'sequence', params: [sequence: 'securite.acces_fonctionnalite_fonction_defaut_id_seq']
- cache true
+ cache usage: 'read-only'
version false
}
actif(nullable: false)
}
+ transient beforeInsert = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
+
+ transient beforeUpdate = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
+ transient beforeDelete = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
-
-
-
-
package org.lilie.services.eliot.securite.impl
import org.lilie.services.eliot.scolarite.Etablissement
cache true
version false
}
-
-
-
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.securite.impl
+import org.lilie.services.eliot.environnement.EnvironnementUtil
+
/**
* Fonctionnalité paramétrable dans Scolarite/Paramétrage/Accès aux fonctions
*/
// correspond à l'entrée de menu
String code
-
Fonctionnalite parent
-
Boolean parametrable
-
Integer ordre
-
Boolean groupe
static constraints = {
static mapping = {
table('securite.fonctionnalite')
id column: 'id', generator: 'sequence', params: [sequence: 'securite.fonctionnalite_id_seq']
- cache true
+ cache usage: 'read-only'
version false
}
"Fonctionnalite $code {$ordre, groupe=$groupe, parametrable=$parametrable}"
}
+ transient beforeInsert = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
+
+ transient beforeUpdate = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
+
+ transient beforeDelete = {
+ if (!EnvironnementUtil.isEnvironmentTest()) {
+ throw new IllegalStateException('La classe domaine est en lecture seule')
+ }
+ }
}
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
/**
- * Reprèsente les fonctionnalités d'absences
+ * Représente les fonctionnalités d'absences
*/
-
public enum AbsencesFonctionnalite implements EliotFonctionnalites {
ABS(true),
ABS_PARAM_INC_PUN_SAN(true) ,
ABS_CONSULT_PARENT(false),
ABS_CONSULT_ELEVE(false),
- ABS_CONSULT_ENSEIGNANT(false)
+ ABS_CONSULT_ENSEIGNANT(false),
+ ETABLISSEMENT(false)
private AbsencesFonctionnalite() {}
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.securite.fonctionnalite.FonctionService
-import org.lilie.services.eliot.securite.fonctionnalite.TypeFonctionEnum
+import org.lilie.services.eliot.securite.fonctionnalite.ModeGestionDroitFonctions
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
+import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
class EliotDroitsService {
static transactional = true
- FonctionService fonctionService
+ FonctionAnnuaireService fonctionAnnuaireService
/**
* Retourne la liste des fonctionnalités de l'application
- * @return une List<EliotFonctionnalites>
* @author jbui
*/
protected List<EliotFonctionnalites> getFonctionnalites() {
/**
* Indique si la session courante à droit peut accéder à la fonctionnalité
* sur l'établissement
- * @param securiteSession
- * @param etablissement
- * @param fonctionnalite
- * @return un booléen
- * @author jbui
*/
protected Boolean getDroitFonctionnalite(SecuriteSession securiteSession,
Etablissement etablissement,
* Permet de construire la liste des fonctionnalités
* accessibles par l'utilisateur
* @author bahj
- * @param securiteSession
- * @param etablissement
- * @return une Hash
* @author jbui
*/
public HashSet getFonctionnalitesAccessibles(SecuriteSession securiteSession,
List<EliotFonctionnalites> listeFonctionnalites = getFonctionnalites()
- for (EliotFonctionnalites fonctionnalite: listeFonctionnalites) {
+ for (EliotFonctionnalites fonctionnalite : listeFonctionnalites) {
if (getDroitFonctionnalite(
securiteSession,
etablissement,
return fonctionnalitesAccessibles
}
+ /**
+ * Vérifie les droits de la session courante à accéder à une fonctionnalité
+ * @param securiteSesion
+ * @param etablissement
+ * @param fonctionnalite
+ * @throws AutorisationException
+ */
+ void verifieDroitFonctionnalite(SecuriteSession securiteSession,
+ Etablissement etablissement,
+ EliotFonctionnalites fonctionnalite)
+ throws AutorisationException {
+ if (!getDroitFonctionnalite(securiteSession, etablissement, fonctionnalite)) {
+ throw AutorisationException.consultationContenuException()
+ }
+ }
+
+ /**
+ * Vérifie les droits de la session courante à accéder à une fonctionnalité
+ * @param securiteSesion
+ * @param etablissement
+ * @param fonctionnalite
+ * @throws AutorisationException
+ */
+ void verifieDroitModificationFonctionnalite(SecuriteSession securiteSession,
+ Etablissement etablissement,
+ EliotFonctionnalites fonctionnalite)
+ throws AutorisationException {
+ if (!getDroitFonctionnalite(securiteSession, etablissement, fonctionnalite)) {
+ throw AutorisationException.modificationContenuException()
+ }
+ }
+
+
+ List<EliotFonctionnalites> getFicheEleveEliotFonctionnalitesAccessible(SecuriteSession securiteSession,
+ Etablissement etablissement) {
+
+ HashSet fonctionnalitesAccessibles = securiteSession.allFonctionnalite(etablissement.id)
+
+ if (securiteSession.hasFonctionIn([FonctionEnum.DIRECTION, FonctionEnum.ENSEIGNANT],
+ etablissement.id
+ )) {
+ fonctionnalitesAccessibles.addAll([
+ ScolariteFonctionnalites.FICHE_ELEVE,
+ ScolariteFonctionnalites.FICHE_ELEVE_ABSENCES,
+ ScolariteFonctionnalites.FICHE_ELEVE_SANCTIONS,
+ ScolariteFonctionnalites.FICHE_ELEVE_NOTES,
+ ScolariteFonctionnalites.FICHE_ELEVE_CONSEIL
+ ])
+ }
+
+ if (securiteSession.hasFonctionIn([FonctionEnum.DIRECTION], etablissement.id)) {
+ fonctionnalitesAccessibles.add(ScolariteFonctionnalites.FICHE_ELEVE_COMMENTAIRE)
+ }
+
+ return fonctionnalitesAccessibles.toList()
+ }
+
+
+ void verifieDroitsAccesFicheEleve(SecuriteSession securiteSession, Etablissement etablissement) {
+ Boolean accesFicheEleve = getFicheEleveEliotFonctionnalitesAccessible(
+ securiteSession,
+ etablissement
+ ).contains(ScolariteFonctionnalites.FICHE_ELEVE)
+
+ if (!accesFicheEleve) {
+ throw AutorisationException.consultationContenuException()
+ }
+ }
+
+ void verifieDroitsModificationFicheEleve(SecuriteSession securiteSession, Etablissement etablissement) {
+ Boolean accesCommentaire = getFicheEleveEliotFonctionnalitesAccessible(
+ securiteSession,
+ etablissement
+ ).contains(ScolariteFonctionnalites.FICHE_ELEVE_COMMENTAIRE)
+
+ if (!accesCommentaire) {
+ throw AutorisationException.modificationContenuException()
+ }
+ }
+
/**
* Indique si l'utilisateur a le droit de modifier le paramétrage
* @param etablissement : établissement dont on veut modifier le paramétrage
action.throwException()
}
+ // TOREFACT bper: il ne faut pas appeler cette méthode dans les controllers directement.
+ // Il faut une méthode de plus haut niveau dans les modules qui combine les deux façon de gérer les droits
+ // Par exemple, dans Notes dans chaque action on prepare une closure qui encapsule la méthode verifieAutorisationByEtablissement()
+ // avec 4 params et on appelle cette méthode avec 4 params aussi, alors que seules variables qui changent d'une action à l'autre c'est
+ // la fonction non paramétrable ayant accès à l'action et la fonctionnalité dont l'action fait parti. Il suffit donc d'une méthode à 2 paramètres.
+ // Il faut alors créer une méthode dans NotesDroitService avec 4 paramètres (Action est inutile) qui encapsulerait tout la gestion des droits.
+ // et puis créer une autre dans AbstractNotesController avec 2 paramètres NotesFonction et NotesFonctionnalite,
+ // securiteSession et etablissement sont récupérés de la session.
+
void verifieDroitSurFonctionnaliteParametrable(SecuriteSession securiteSession,
Etablissement etablissement,
EliotFonctionnalites fonctionnalite,
- Closure verifieDroitFonctionsNonParametrables){
+ Closure verifieDroitFonctionsNonParametrables) {
- TypeFonctionEnum typeFonctions = fonctionService.getTypeFonctions(securiteSession, etablissement)
+ ModeGestionDroitFonctions modeGestionDroitFonctions = fonctionAnnuaireService.getModeGestionDroitFonctions(securiteSession, etablissement)
- if (TypeFonctionEnum.NON_PARAMETRABLES == typeFonctions){
+ if (ModeGestionDroitFonctions.NON_PARAMETRABLE == modeGestionDroitFonctions) {
verifieDroitFonctionsNonParametrables()
- } else if (TypeFonctionEnum.PARAMETRABLES == typeFonctions){
+ } else if (ModeGestionDroitFonctions.PARAMETRABLE == modeGestionDroitFonctions) {
securiteSession.verifieAccesFonctionnalite(fonctionnalite, etablissement?.id)
} else {
- try {
+ if (!securiteSession.hasAccesFonctionnalite(fonctionnalite, etablissement?.id)){
verifieDroitFonctionsNonParametrables()
- } catch(AutorisationException e){
- securiteSession.verifieAccesFonctionnalite(fonctionnalite, etablissement?.id)
}
}
}
- boolean hasDroitSurFonctionnaliteParametrable( SecuriteSession securiteSession,
+ boolean hasDroitSurFonctionnaliteParametrable(SecuriteSession securiteSession,
+ Etablissement etablissement,
+ EliotFonctionnalites fonctionnalite,
+ Closure hasDroitFonctionsNonParametrables) {
+
+ return hasDroitSurFonctionnalitesParametrable(securiteSession,
+ [etablissement],
+ [fonctionnalite],
+ hasDroitFonctionsNonParametrables
+ )
+
+ }
+
+ boolean hasDroitSurFonctionnalitesParametrable(SecuriteSession securiteSession,
Etablissement etablissement,
- EliotFonctionnalites fonctionnalite,
- Closure hasDroitFonctionsNonParametrables){
+ List<EliotFonctionnalites> fonctionnalites,
+ Closure hasDroitFonctionsNonParametrables) {
- TypeFonctionEnum typeFonctions = fonctionService.getTypeFonctions(securiteSession, etablissement)
+ return hasDroitSurFonctionnalitesParametrable(securiteSession,
+ [etablissement],
+ fonctionnalites,
+ hasDroitFonctionsNonParametrables
+ )
- if (TypeFonctionEnum.NON_PARAMETRABLES == typeFonctions){
- return hasDroitFonctionsNonParametrables()
- }
+ }
- else if (TypeFonctionEnum.PARAMETRABLES == typeFonctions){
- return securiteSession.hasAccesFonctionnalite(fonctionnalite, etablissement?.id)
- }
+ boolean hasDroitSurFonctionnalitesParametrable(SecuriteSession securiteSession,
+ List<Etablissement> etablissementsAccessibles,
+ List<EliotFonctionnalites> fonctionnalites,
+ Closure hasDroitFonctionsNonParametrables) {
+
+ boolean hasAcces = false
+
+ etablissementsAccessibles?.each { Etablissement etablissementAccessible ->
+
+ ModeGestionDroitFonctions modeGestionDroitFonctions =
+ fonctionAnnuaireService.getModeGestionDroitFonctions(securiteSession, etablissementAccessible)
+
+ if (ModeGestionDroitFonctions.NON_PARAMETRABLE == modeGestionDroitFonctions) {
+ if (hasDroitFonctionsNonParametrables()) {
+ hasAcces = true
+ return
+ }
+ }
+ else if (ModeGestionDroitFonctions.PARAMETRABLE == modeGestionDroitFonctions) {
+ if (securiteSession.hasAccesFonctionnalitesList(fonctionnalites, etablissementAccessible.id)) {
+ hasAcces = true
+ return
+ }
+ }
+ else {
+ if (hasDroitFonctionsNonParametrables() ||
+ securiteSession.hasAccesFonctionnalitesList(fonctionnalites, etablissementAccessible.id)) {
+ hasAcces = true
+ return
+ }
+ }
- else {
- return hasDroitFonctionsNonParametrables() ||
- securiteSession.hasAccesFonctionnalite(fonctionnalite, etablissement?.id)
}
+ return hasAcces
+
+ }
+
+ boolean hasDroitsDirection(SecuriteSession securiteSession,
+ boolean fonctionnaliteParametrable,
+ Etablissement etablissement) {
+ return securiteSession.hasFonctionIn(
+ (List) [FonctionEnum.DIRECTION],
+ etablissement.id
+ ) ||
+ (fonctionnaliteParametrable &&
+ securiteSession.hasFonctionIn(
+ FonctionEnum.findAll{it.getAccesParametrable() && it != FonctionEnum.DOCUMENTALISTE},
+ etablissement.id
+ )
+ )
}
}
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.springframework.context.ApplicationContext
/**
* Classe utilitaire permettant de définir des comportements spéciaux pour des éléments de menu
* Le principe est de dériver cette classe et surcharger 3 méthodes
+ * @author othe
*/
abstract class AbstractMenu {
* d'avoir l'entrée dans le menu.
* @return
*/
- public Boolean autoriseAjoutElementMenu(){
+ public Boolean autoriseAjoutElementMenu() {
true
}
Etablissement etablissement
SecuriteSession securiteSession
- /**
- * TOREFACT : doit retourner dans DroitService ?
- * @return
- */
- public Boolean isDirectionAdminLocalOuCorrespondant() {
- return (
- isDirection()
- ||
- securiteSession.hasFonctionIn(
- [FonctionEnum.ADMIN_LOCAL],
- etablissement.id
- ) ||
- securiteSession.hasFonctionIn(
- [FonctionEnum.CORRESPONDANT_DEPLOIEMENT],
- etablissement.id
- )
- )
-
- }
-
- /**
- * TOREFACT : doit retourner dans DroitService ?
- * @return
- */
- public Boolean isDirectionAdminLocalCorrespondantOuEducation() {
-
- return (isDirectionAdminLocalOuCorrespondant() ||
- (securiteSession.hasFonctionIn(
- [FonctionEnum.EDUCATION],
- etablissement.id
- ))
- )
-
- }
-
- /**
- * TOREFACT : doit retourner dans DroitService ?
- * @return
- */
- public Boolean isDirection() {
- securiteSession.hasFonctionIn([FonctionEnum.DIRECTION])
- }
-
}
* Construction du menu établissement
* @param securiteSession
* @param etablissementCourant
- * @param codeLabelMenu : code label du menu principal
+ * @param codeLabelMenu : code label du menu principal
* @param pageCourante : object représentant la page courante
* @return
*/
Etablissement etablissementCourant,
String codeLabelMenu,
Object pageCourante) {
+ this(securiteSession, etablissementCourant, codeLabelMenu, pageCourante,
+ {
+ return true
+ }
+ )
+ }
+
+/**
+ * Construction du menu établissement
+ * @param securiteSession
+ * @param etablissementCourant
+ * @param codeLabelMenu : code label du menu principal
+ * @param pageCourante : object représentant la page courante
+ * @return
+ */
+ public EtablissementMenuItemInfo(SecuriteSession securiteSession,
+ Etablissement etablissementCourant,
+ String codeLabelMenu,
+ Object pageCourante,
+ Closure isEtablissementAccessible) {
+
+
+
+ List<Etablissement> lstEtablissements = []
+
+ securiteSession.etablissementsAccessibles.each { Etablissement etablissement ->
+ if (isEtablissementAccessible(etablissement)) {
+ lstEtablissements.add(etablissement)
+ }
+ }
- List<Etablissement> lstEtablissements =
- (List<Etablissement>)securiteSession.etablissementsAccessibles
-
if (lstEtablissements.size() > 1) {
this.codeLabel = codeLabelMenu
- lstEtablissements.each {
- Etablissement etablissement ->
+ lstEtablissements.each { Etablissement etablissement ->
items <<
- new MenuItemInfo(
- label: etablissement.nomAffichage,
- controleur: 'application',
- action: 'changeEtablissement',
- menuType: 'radio',
- nom : 'etabRadio',
- checked: (etablissementCourant == etablissement),
- params: [
- id: etablissement.id,
- page: pageCourante.toString()
- ]
- )
+ new MenuItemInfo(
+ label: etablissement.nomAffichage,
+ controleur: 'application',
+ action: 'changeEtablissement',
+ menuType: 'radio',
+ nom : 'etabRadio',
+ checked: (etablissementCourant == etablissement),
+ params: [
+ id: etablissement.id,
+ page: pageCourante.toString()
+ ]
+ )
}
}
}
package org.lilie.services.eliot.menu
+/**
+ * Description des menus déroulants d'une application
+ * @author othe
+ */
class MenuApplication {
// infos pour les entêtes de menu
List<Entete> entetes
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
import org.lilie.services.eliot.annuaire.SecuriteSession
+/**
+ *
+ * @author othe
+ */
class MenuService implements ApplicationContextAware {
@SuppressWarnings('GrailsStatelessService')
entetes.each {
Entete menuEntete ->
- if (!allFonctionnaliteAutorisees.find {it.code == menuEntete.fonctionnalite.code}) {
+ log.debug "Entête menu : " + menuEntete.toString()
+
+ if (!allFonctionnaliteAutorisees.find {
+ (it.code == menuEntete.fonctionnalite.code)
+ }) {
+ log.debug "Entête menu inactive."
return
}
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+/**
+ *
+ * @author : othe
+ * TOREFACT : supprimer controleur/action/fonctionnalité - s'appuyer sur Page pour ces valeurs
+ */
public interface SousMenu {
public String codeLabel
package org.lilie.services.eliot.menu
+
+/**
+ *
+ * @author othe
+ */
class SousMenuNormal extends AbstractMenu {
public MenuItemInfo construitMenuItem(Object pageCourante) {
action,
fonctionsAutorises
)
-
+
switch (action) {
case (Action.CONSULTATION):
case (Action.CREATION):
NOTES_PARAM(true),
NOTES_PUBLIPOST(true),
NOTES_EXPORT(true),
+ NOTES_SAISIE_NOTES_ENSEIGNANTS(true),
NOTES_SAISIE_SYNTH(true),
NOTES_SAISIE_BREVET(true),
- NOTES_CONSULT_NOTES(true),
NOTES_CONSULT_RELEVE_BULLETIN(true),
NOTES_CONSULT_APPR(true),
- NOTES_SAISIE_SYNTH_CONSEIL(true),
- NOTES_CONSULT_NOTES_MODIF(true)
+ NOTES_SAISIE_SYNTH_CONSEIL(true)
+
+ private final Boolean parametrable
private NotesFonctionnalite() {}
private NotesFonctionnalite(Boolean parametrable) {
- this.PARAMETRABLE = parametrable
+ this.parametrable = parametrable
}
- private final Boolean PARAMETRABLE
-
public String getCode() {
return toString()
}
public Boolean isParametrable() {
- return PARAMETRABLE
+ return parametrable
}
}
\ No newline at end of file
BulletinOptionsPersonnalise bulletinOptionsPersonnalise = null)
throws AutorisationException {
+/*
notesDroitService.verifieAutorisationByEleve(
securiteSession,
eleve,
[FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
)
)
+*/
StructureEnseignement classe = periode.classe
)
}
- notesDroitService.verifieAutorisationByEleve(
- securiteSession,
- eleve,
- Action.MODIFICATION,
- (List) NotesFonction.ENSEIGNANT_ASSIMILE + [
- FonctionEnum.DIRECTION,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ]
- )
+// TOREFACT : gérer les droits en tenant compte des fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEleve(
+// securiteSession,
+// eleve,
+// Action.MODIFICATION,
+// (List) NotesFonction.ENSEIGNANT_ASSIMILE + [
+// FonctionEnum.DIRECTION,
+// FonctionEnum.CORRESPONDANT_DEPLOIEMENT
+// ]
+// )
internalSaveAppreciation(eleve.autorite, periode, appreciation)
}
throw new IllegalArgumentException("La structure d'enseignment $classe n'est de type CLASSE")
}
- notesDroitService.verifieAutorisationByClasse(
+ /*Gestion des droits de direction*/
+ boolean hasDroitsDirection = notesDroitService.hasDroitsDirection(
securiteSession,
- classe,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
+ true,
+ classe.etablissement
)
+ /**/
+
+ if (!hasDroitsDirection){
+ notesDroitService.verifieAutorisationByClasse(
+ securiteSession,
+ classe,
+ Action.CONSULTATION,
+ (List) (FonctionEnum.ENSEIGNANT +
+ FonctionEnum.DOCUMENTALISTE
+ )
+ )
+ }
+ // TODO comment gérer les droits des fonctions paramétrables sur cette méthode?
// Récupère les informations sur les élèves (actifs & inactifs)
StructureEnseignementElevesListes elevesListes =
eleveAnnuaireService.findStructureEnseignementElevesListes(
Periode periode)
throws AutorisationException {
+/*
notesDroitService.verifieAutorisationByEleve(
securiteSession,
elevePersonne,
[FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
)
)
+*/
SyntheseEleve syntheseEleve = new SyntheseEleve()
syntheseEleve.eleve = elevePersonne
import org.lilie.services.eliot.notification.ParametrageEtablissement
import org.lilie.services.eliot.notification.NotificationTypeId
import org.lilie.services.eliot.notification.Media
-import org.lilie.services.eliot.securite.fonctionnalite.FonctionService
+import org.lilie.services.eliot.securite.fonctionnalite.FonctionAnnuaireService
+import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
class NotificationPreferenceUtilisateurService {
static transactional = true
NotificationParametrageService notificationParametrageService
- FonctionService fonctionService
+ FonctionAnnuaireService fonctionAnnuaireService
/**
* Lecture des paramétrages pour une personne
securiteSession.getAllFonctionEtablissement()
//Récupération des fonctions de l'utilisateur
- List<Fonction> allFonction = fonctionService.getAllFonction(securiteSession, etablissement)
+ List<Fonction> allFonction = fonctionAnnuaireService.getAllFonction(securiteSession, etablissement)
//Récupération de toutes les notifications auquelles l'utilisateur a droit (toutes fonctions de l'utilisateur confondues)
List<NotificationType> allNotificationType =
* que celles passées dans les paramétres
* @author msan
*/
- Long calculeServicesEvaluablesDehorsPeriodes(SecuriteSession securiteSession,
- Service service,
+ Long calculeServicesEvaluablesDehorsPeriodes(Service service,
NaturePeriode naturePeriodeEnum,
TypePeriode typePer) {
PARAMETRAGE_NOTIFICATION(false),
PARAMETRAGE_ACCES_FONCTIONS(false),
NOTIFICATION_PREFERNCE_UTILISATEUR(false),
- MAGISTER(false),
+ SCOL_MAGISTER(false),
ETABLISSEMENT(false)
List<Periode> periodes,
Boolean evaluable = true,
Boolean prefetchSousServices = false,
- Boolean prefetchEnseignements = false
+ Boolean prefetchEnseignements = false,
+ boolean fonctionnaliteParametrable = false
)
throws AutorisationException {
- eliotDroitsService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.CONSULTATION,
- (List) [
- FonctionEnum.DIRECTION,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
- FonctionEnum.ENSEIGNANT,
- FonctionEnum.DOCUMENTALISTE,
- FonctionEnum.EDUCATION,
- FonctionEnum.ELEVE,
- FonctionEnum.PERS_REL_ELEVE
- ]
- )
+/*
+ if (!fonctionnaliteParametrable){
+ eliotDroitsService.verifieAutorisationByEtablissement(
+ securiteSession,
+ classe.etablissement,
+ Action.CONSULTATION,
+ (List) [
+ FonctionEnum.DIRECTION,
+ FonctionEnum.CHEF_TRAVAUX,
+ FonctionEnum.ADMIN_LOCAL,
+ FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
+ FonctionEnum.ENSEIGNANT,
+ FonctionEnum.DOCUMENTALISTE,
+ FonctionEnum.EDUCATION,
+ FonctionEnum.ELEVE,
+ FonctionEnum.PERS_REL_ELEVE
+ ]
+ )
+ } else {
+ if(!eliotDroitsService.hasDroitsDirection(
+ securiteSession,
+ true,
+ classe.etablissement
+ )){
+ eliotDroitsService.verifieAutorisationByEtablissement(
+ securiteSession,
+ classe.etablissement,
+ Action.CONSULTATION,
+ (List) [
+ FonctionEnum.ENSEIGNANT,
+ FonctionEnum.DOCUMENTALISTE,
+ FonctionEnum.ELEVE,
+ FonctionEnum.PERS_REL_ELEVE
+ ]
+ )
+ }
+ }
+*/
if (periodes != null && periodes.isEmpty()) {
return []
// Récupère la classe et les groupes de l'élève
List<StructureEnseignement> structureEnseignements =
- localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- securiteSession,
- eleve
- )
+ localStructureEnseignementService.findAllStructureEnseignementForPersonne(
+ securiteSession,
+ eleve
+ )
if (!structureEnseignements) {
return []
Etablissement etablissement)
throws AutorisationException {
- if (securiteSession.hasFonctionIn([FonctionEnum.ADMIN_CENTRAL]) ||
- securiteSession.hasFonctionIn([
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.DIRECTION,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
- FonctionEnum.EDUCATION],
- etablissement.id)
-
- ) {
- return // OK
- }
-
- // Non autorisé
- throw AutorisationException.modificationContenuException()
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// if (securiteSession.hasFonctionIn([FonctionEnum.ADMIN_CENTRAL]) ||
+// securiteSession.hasFonctionIn([
+// FonctionEnum.ADMIN_LOCAL,
+// FonctionEnum.DIRECTION,
+// FonctionEnum.CHEF_TRAVAUX,
+// FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
+// FonctionEnum.EDUCATION],
+// etablissement.id)
+//
+// ) {
+// return // OK
+// }
+//
+// // Non autorisé
+// throw AutorisationException.modificationContenuException()
}
/**
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.annuaire.ResponsableEleve
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
+import org.lilie.services.eliot.securite.fonctionnalite.ModeGestionDroitFonctions
+import org.lilie.services.eliot.annuaire.SecuriteSession
/**
* Gestion des fonctions des personnes de l'annuaire
pps.proprietesScolarite.fonction=f and
"""
-// ResponsableEleve re right join re.personne p,
+ private static final HQL_FONCTION_ETAB_POUR_ETAB =
+ HQL_FONCTION_ETAB +
+ "etab.id=:etabId"
+
private static final HQL_FONCTION_ETAB_POUR_ADMIN_LOCAL =
HQL_FONCTION_ETAB +
Boolean isPersonelEducation(Personne personne) {
return hasFonction(personne, FonctionEnum.EDUCATION)
}
+
+ /**
+ * Retrourne l'ensemble des fonctions établissements d'un utilisateur pour un établissement
+ * @param autorite
+ * @param etablissement
+ * @return
+ * @author bahj
+ */
+ List<FonctionEtablissement> findAllFonctionEtablissementBy(Etablissement etablissement,
+ Autorite autorite) {
+
+ List<FonctionEtablissement> fonctionEtablissements =
+ findAllFonctionEtablissement(
+ HQL_FONCTION_ETAB_POUR_ETAB,
+ autorite,
+ [
+ etabId: etablissement.id
+ ]
+ )
+
+ if (CITE_SCOLAIRE_DROITS_ETTENDUS) {
+ fonctionEtablissements = ajoutFonctionsCiteScolaireUtilisateurNormal(
+ fonctionEtablissements
+ )
+ }
+
+ return fonctionEtablissements
+ }
/**
* Retourne la liste des fonctions / établissement pour une autorite de type Acteur en
}
}
+ /**
+ * Retourne la liste des fonctions de l'utilisateur pour la session courante
+ */
+ List<Fonction> getAllFonction(SecuriteSession session,
+ Etablissement etablissement) {
+
+ List<FonctionEtablissement> allFonctionEtablissementSurEtablissement =
+ session.getAllFonctionEtablissement()
+
+ List<Fonction> allFonction = Fonction.findAllByCodeInList(
+ allFonctionEtablissementSurEtablissement*.fonctionEnum*.code
+ )
+
+ return allFonction
+ }
+
+ List<Fonction> getAllFonctionParametrable() {
+ List<FonctionEnum> fonctionParametrables = getAllFonctionEnumParametrable()
+
+ return Fonction.findAllByCodeInList(
+ fonctionParametrables.collectAll {it.code},
+ [sort: "libelle"]
+ )
+ }
+
+ List<FonctionEnum> getAllFonctionEnumParametrable() {
+ return FonctionEnum.values().findAll {it.getAccesParametrable()}
+ }
+
+ ModeGestionDroitFonctions getModeGestionDroitFonctions(SecuriteSession securiteSession, Etablissement etablissement) {
+ List<Fonction> fonctionList = getAllFonction(securiteSession, etablissement)
+ List<FonctionEnum> fonctionEnumList = []
+ fonctionList.each {
+ fonctionEnumList.add(FonctionEnum.parseFromCode(it.code))
+ }
+
+ // TOREFACT bper: il vaut mieux utiliser les méthodes de List (Groovy) 'every' et 'any', leur sémantique est plus claire
+
+ int fonctionEnumListSize = fonctionEnumList.size()
+ if (fonctionEnumListSize == fonctionEnumList.findAll {it.accesParametrable == true}?.size()) {
+ return ModeGestionDroitFonctions.PARAMETRABLE
+ } else if (fonctionEnumListSize == fonctionEnumList.findAll {it.accesParametrable == false}?.size()) {
+ return ModeGestionDroitFonctions.NON_PARAMETRABLE
+ } else {
+ return ModeGestionDroitFonctions.PARAMETRABLE_ET_NON_PARAMETRABLE
+ }
+ }
+
}
CreeMatiereParam creeMatiereParam)
throws AutorisationException, SauvegardeEchoueException {
- verifieCreeMatiere(securiteSession, creeMatiereParam.etablissement)
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieCreeMatiere(securiteSession, creeMatiereParam.etablissement)
// Recherche de la matiere
Matiere matiere = findMatiereByCodeGestionAndEtablissement(
AutorisationException {
// Vérifier l'autorisation de suppression
- verifieAutorisationModifierMatiereManuel(securiteSession, etablissement)
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationModifierMatiereManuel(securiteSession, etablissement)
CreeMatiereParam creeMatiereParam = new CreeMatiereParam(
origine: OrigineEnum.MANUEL,
}
// verifie l'autorisation de modification
- verifieAutorisationModifierMatiereManuel(
- securiteSession,
- matiere.etablissement
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationModifierMatiereManuel(
+// securiteSession,
+// matiere.etablissement
+// )
if (codeGestion) {
matiere.codeGestion = codeGestion
SauvegardeEchoueException {
// verifie l'autorisation de modification
- verifieAutorisationModifierMatiereManuel(
- securiteSession,
- matiere.etablissement
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationModifierMatiereManuel(
+// securiteSession,
+// matiere.etablissement
+// )
if (libelleLong == null && specialite == null) {
return matiere // Aucune modification à effectuer
}
// Verifie l'autorisation de suppression
- verifieAutorisationsupprimeMatiereManuel(
- securiteSession,
- matiere.etablissement
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationsupprimeMatiereManuel(
+// securiteSession,
+// matiere.etablissement
+// )
if (isMatiereUtilise(securiteSession, matiere)) {
throw new MatiereNonSupprimableException()
+++ /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.fonctionnalite
-
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.annuaire.FonctionEtablissement
-import org.lilie.services.eliot.annuaire.Fonction
-import org.lilie.services.eliot.annuaire.FonctionEnum
-
-/**
- *
- * @author othe
- */
-class FonctionService {
-
-
- /**
- * Retourne la liste des fonctions de l'utilisateur pour la session courante
- * @param session
- * @return notificationTypePreferenceUtilisateurs
- */
- List<Fonction> getAllFonction(SecuriteSession session,
- Etablissement etablissement) {
-
- List<FonctionEtablissement> allFonctionEtablissementSurEtablissement =
- session.getAllFonctionEtablissement()
-
- List<Fonction> allFonction = Fonction.findAllByCodeInList(
- allFonctionEtablissementSurEtablissement*.fonctionEnum*.code
- )
-
- return allFonction
-
- }
-
- TypeFonctionEnum getTypeFonctions(SecuriteSession securiteSession, Etablissement etablissement){
- List<Fonction> fonctionList = getAllFonction(securiteSession, etablissement)
- List<FonctionEnum> fonctionEnumList = []
- fonctionList.each{
- fonctionEnumList.add(FonctionEnum.parseFromCode(it.code))
- }
- int fonctionEnumListSize = fonctionEnumList.size()
- if (fonctionEnumListSize == fonctionEnumList.findAll {it.accesParametrable == true}?.size()){
- return TypeFonctionEnum.PARAMETRABLES
- } else if (fonctionEnumListSize == fonctionEnumList.findAll {it.accesParametrable == false}?.size()){
- return TypeFonctionEnum.NON_PARAMETRABLES
- } else {
- return TypeFonctionEnum.PARAMETRABLES_ET_NON_PARAMETRABLES
- }
- }
-
-}
+++ /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.fonctionnalite
-
-import org.lilie.services.eliot.annuaire.Fonction
-import org.lilie.services.eliot.securite.impl.Fonctionnalite
-import org.lilie.services.eliot.securite.impl.AccesFonctionnaliteFonction
-import org.lilie.services.eliot.scolarite.Etablissement
-
-class FonctionnaliteFonctionService {
-
-
- public List<AccesFonctionnaliteFonction> getAllFonctionnaliteFonctionSurEtablissement(Etablissement etablissement,
- Fonction fonction) {
-
- List<AccesFonctionnaliteFonction> accesFonctionnaliteFonction =
- AccesFonctionnaliteFonction.findAllByFonctionAndEtablissement(
- fonction,
- etablissement)
-
- }
-
- public List<AccesFonctionnaliteFonction> getAllAccesFonctionnaliteForAllFonctionSurEtablissement(Etablissement etablissement,
- List<Fonction> fonction
- ) {
-
-
- AccesFonctionnaliteFonction.withCriteria {
- fonctionnalite{
- 'eq'('parametrable', true)
- }
- 'in'('fonction', fonction)
- 'eq'('etablissement', etablissement)
-
- }
-
-
- }
-
- public void donneAccesFonctionnaliteFonction(Etablissement etablissement,
- Fonction fonction,
- Fonctionnalite fonctionnalite
- ) {
-
- AccesFonctionnaliteFonction accesFonctionnaliteFonction =
- AccesFonctionnaliteFonction.findByFonctionnaliteAndFonctionAndEtablissement(
- fonctionnalite,
- fonction,
- etablissement)
-
- if (!accesFonctionnaliteFonction) {
- accesFonctionnaliteFonction = new AccesFonctionnaliteFonction(
- etablissement: etablissement,
- fonctionnalite: fonctionnalite,
- fonction: fonction
- )
-
- accesFonctionnaliteFonction.save(flush: true, failOnError: true)
- }
-
- }
-
-
- public void supprimeAccesFonctionnaliteFonction(Etablissement etablissement,
- Fonction fonction,
- Fonctionnalite fonctionnalite
- ) {
-
- AccesFonctionnaliteFonction accesFonctionnaliteFonction =
- AccesFonctionnaliteFonction.findByFonctionnaliteAndFonctionAndEtablissement(
- fonctionnalite,
- fonction,
- etablissement)
-
- if (accesFonctionnaliteFonction) {
- accesFonctionnaliteFonction.delete()
- }
-
- }
-
-
-}
+++ /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.fonctionnalite
-
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.securite.impl.AccesFonctionnalitePersonne
-import org.lilie.services.eliot.securite.impl.Fonctionnalite
-
-class FonctionnalitePersonneService {
-
-
- public void donneAccesFonctionnalitePersonne(Personne personne,
- Etablissement etablissement,
- Fonctionnalite fonctionnalite
- ) {
-
- AccesFonctionnalitePersonne accesFonctionnalitePersonne =
- AccesFonctionnalitePersonne.findByEtablissementAndFonctionnaliteAndPersonne(
- etablissement,
- fonctionnalite,
- autorite)
-
- if (!accesFonctionnalitePersonne) {
- accesFonctionnalitePersonne = new AccesFonctionnalitePersonne(
- etablissement: etablissement,
- personne: personne,
- fonctionnalite: fonctionnalite
- )
-
- accesFonctionnalitePersonne.save(flush: true, failOnError: true)
- }
-
- }
-
-
- public void supprimeAccesFonctionnalitePersonne(Personne personne,
- Etablissement etablissement,
- Fonctionnalite fonctionnalite
- ) {
-
- AccesFonctionnalitePersonne accesFonctionnalitePersonne =
- AccesFonctionnalitePersonne.findByEtablissementAndFonctionnaliteAndPersonne(
- etablissement,
- fonctionnalite,
- personne)
-
- if (accesFonctionnalitePersonne) {
- accesFonctionnalitePersonne.delete()
- }
-
- }
-
-}
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.GormUtils
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
class SecuriteFonctionnaliteService {
- FonctionService fonctionService
+ FonctionAnnuaireService fonctionAnnuaireService
boolean verifieDroitFonctionnalite(
SecuriteSession securiteSession,
Fonctionnalite fonctionnalite
) {
List<Fonction> fonctions =
- fonctionService.getAllFonction(securiteSession, etablissement)
+ fonctionAnnuaireService.getAllFonction(securiteSession, etablissement)
+
+ boolean hasAcces = false
- boolean accesParFontion = false
if (!fonctions.isEmpty()) {
- accesParFontion = AccesFonctionnaliteFonction.createCriteria().get {
+ boolean accesParFontion = AccesFonctionnaliteFonction.createCriteria().get {
'eq'('actif', true)
'eq'('fonctionnalite', fonctionnalite)
'eq'('etablissement', etablissement)
'in'('fonction', fonctions)
maxResults(1)
} != null
- }
- boolean accesParPersonne = AccesFonctionnalitePersonne.createCriteria().get {
- 'eq'('fonctionnalite', fonctionnalite)
- 'eq'('etablissement', etablissement)
- 'eq'('personne', securiteSession.personne)
- maxResults(1)
- } != null
+ boolean accesParPersonne = AccesFonctionnalitePersonne.createCriteria().get {
+ 'eq'('fonctionnalite', fonctionnalite)
+ 'eq'('etablissement', etablissement)
+ 'eq'('personne', securiteSession.personne)
+ maxResults(1)
+ } != null
+
+ hasAcces = accesParFontion || accesParPersonne
+ }
- return accesParFontion || accesParPersonne
+ return hasAcces
}
Map<Long, HashSet<EliotFonctionnalites>> getMapEnumFonctionnalitesAccessibles(
List<Fonctionnalite> fonctionnalitesAccessibles = []
List<Fonction> fonctions =
- fonctionService.getAllFonction(securiteSession, etablissement)
+ fonctionAnnuaireService.getAllFonction(securiteSession, etablissement)
if (!fonctions.isEmpty()) {
- List<AccesFonctionnaliteFonction> accesFonctionnaliteFonctions =
+ List<Fonctionnalite> fonctionnalitesAccessiblesPourFonctions =
AccesFonctionnaliteFonction.withCriteria {
'eq'('actif', true)
'eq'('etablissement', etablissement)
'in'('fonction', fonctions)
+ projections {
+ property('fonctionnalite')
+ }
}
- fonctionnalitesAccessibles.addAll(
- accesFonctionnaliteFonctions.collect {it.fonctionnalite})
- }
+ fonctionnalitesAccessibles.addAll(fonctionnalitesAccessiblesPourFonctions)
- List<AccesFonctionnalitePersonne> accesFonctionnalitePersonnes =
- AccesFonctionnalitePersonne.withCriteria {
- 'eq'('etablissement', etablissement)
- 'eq'('personne', securiteSession.personne)
- }
+ List<Fonctionnalite> fonctionnalitesAccessiblesPourPersonnes =
+ AccesFonctionnalitePersonne.withCriteria {
+ 'eq'('etablissement', etablissement)
+ 'eq'('personne', securiteSession.personne)
+ projections {
+ property('fonctionnalite')
+ }
+ }
- fonctionnalitesAccessibles.addAll(
- accesFonctionnalitePersonnes.collect {it.fonctionnalite})
+ fonctionnalitesAccessibles.addAll(fonctionnalitesAccessiblesPourPersonnes)
+ }
return fonctionnalitesAccessibles
}
+ // TOREFACT bper: la méthode est redondante avec celle d'avant
List<Fonctionnalite> listeFonctionnalitesAccessibles(
SecuriteSession securiteSession,
Etablissement etablissement,
}
List<Fonction> fonctions =
- fonctionService.getAllFonction(securiteSession, etablissement)
+ fonctionAnnuaireService.getAllFonction(securiteSession, etablissement)
if (!fonctions.isEmpty()) {
- List<AccesFonctionnaliteFonction> accesFonctionnaliteFonctions = AccesFonctionnaliteFonction.withCriteria {
+ List<Fonctionnalite> fonctionnalitesAccessiblesPourFonctions = AccesFonctionnaliteFonction.withCriteria {
'eq'('actif', true)
'in'('fonctionnalite', fonctionnalites)
'eq'('etablissement', etablissement)
'in'('fonction', fonctions)
+ projections {
+ property('fonctionnalite')
+ }
}
- fonctionnalitesAccessibles.addAll(
- accesFonctionnaliteFonctions.collect {it.fonctionnalite})
- }
+ fonctionnalitesAccessibles.addAll(fonctionnalitesAccessiblesPourFonctions)
- List<AccesFonctionnalitePersonne> accesFonctionnalitePersonnes =
- AccesFonctionnalitePersonne.withCriteria {
- 'in'('fonctionnalite', fonctionnalites)
- 'eq'('etablissement', etablissement)
- 'eq'('personne', securiteSession.personne)
- }
+ List<Fonctionnalite> fonctionnalitesAccessiblesPourPersonnes =
+ AccesFonctionnalitePersonne.withCriteria {
+ 'in'('fonctionnalite', fonctionnalites)
+ 'eq'('etablissement', etablissement)
+ 'eq'('personne', securiteSession.personne)
+ projections {
+ property('fonctionnalite')
+ }
+ }
- fonctionnalitesAccessibles.addAll(
- accesFonctionnalitePersonnes.collect {it.fonctionnalite})
+ fonctionnalitesAccessibles.addAll(fonctionnalitesAccessiblesPourPersonnes)
+ }
return fonctionnalitesAccessibles
}
/**
* Vérifie que les droits par fonctions paramétrables sur les fonctionnalités paramétrables
- * existent pour l'étab donné. Sinon, on les créé à partir des droits par défaut
- * @param etablissement
+ * existent pour l'étab donné. Sinon, on les crée à partir des droits par défaut
*/
public void initialiseEtablissement(Etablissement etablissement) {
package org.lilie.services.eliot.securite.fonctionnalite
/**
+ * Définit si un groupe de fonctions est paramétrable, non paramétrable ou
+ * si, dans le groupe de fonctions, certaines sont paramétrables et d'autres non
* @author agia
*/
-public enum TypeFonctionEnum {
+public enum ModeGestionDroitFonctions {
- PARAMETRABLES,
- NON_PARAMETRABLES,
- PARAMETRABLES_ET_NON_PARAMETRABLES
+ PARAMETRABLE,
+ NON_PARAMETRABLE,
+ PARAMETRABLE_ET_NON_PARAMETRABLE
}
\ No newline at end of file
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.annuaire.FonctionEtablissement
import org.lilie.services.eliot.securite.impl.AccesFonctionnalitePersonne
-import org.lilie.services.eliot.portail.TypeUtilisateur
+
import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
import org.lilie.services.eliot.annuaire.FonctionEnum
}
- /**
- * Recherche toutes les fonctions disponible pour le paramétrage
- * @return
- */
- public List<Fonction> findAllfonction() {
-
- List<String> allCodeFonctionParametrable = []
-
- FonctionEnum.each {FonctionEnum fonctionEnum ->
- if (fonctionEnum.getAccesParametrable()) {
- allCodeFonctionParametrable << fonctionEnum.getCode()
- }
- }
- List<Fonction> allFonctionParametrable = Fonction.findAllByCodeInList(
- allCodeFonctionParametrable)
-
- allFonctionParametrable.sort {it.libelle}
-
- return allFonctionParametrable
- }
-
public void enregistreDroitFonction(Etablissement etablissement,
List<FonctionnaliteParams> listeFonctionnaliteParam) {
throw new IllegalStateException("Fonctionnalité $fonctionnaliteParams.fonctionnaliteId inconnue en base.")
}
+ Boolean isFrereDuNoeudActif = false
+
while (fonctionnalite) {
fonctionnaliteParams.parametres.each {
+
FonctionParams fonctionParams ->
Fonction fonction = Fonction.findByCode(fonctionParams.codeFonction)
+
enregistreDroitFonction(etablissement,
fonction,
fonctionnalite,
- fonctionParams.actif
+ fonctionParams.actif || isFrereDuNoeudActif
)
+ isFrereDuNoeudActif =
+ isFreresFonctionnaliteFonctionActif(
+ fonctionnalite,
+ fonction,
+ etablissement
+ )
+
+
}
fonctionnalite = fonctionnalite.parent
+
}
}
}
+ /**
+ * test si le noeud fonctionnalite a des frères actifs.
+ * @param fonctionnalite
+ * @param fonction
+ * @param etablissement
+ * @return
+ */
+ private Boolean isFreresFonctionnaliteFonctionActif(Fonctionnalite fonctionnalite,
+ Fonction fonction,
+ Etablissement etablissement) {
+
+ if (!fonctionnalite) {
+ return false
+ }
+
+ Fonctionnalite parent = fonctionnalite.parent
+
+ if (!parent) {
+ return false
+ }
+
+
+ String hql = """
+from AccesFonctionnaliteFonction aff
+where
+ aff.fonctionnalite.parent=:parent
+ and
+ not(aff.fonctionnalite=:fonctionnalite)
+ and
+ aff.actif=true
+ and
+ aff.etablissement=:etablissement
+ and
+ aff.fonction=:fonction
+
+"""
+
+ List<AccesFonctionnaliteFonction> allAccesFonctionnaliteFonction = AccesFonctionnaliteFonction.executeQuery(
+ hql,
+ [
+ parent: parent,
+ fonctionnalite: fonctionnalite,
+ etablissement: etablissement,
+ fonction: fonction
+ ]
+ )
+
+ return (allAccesFonctionnaliteFonction.size() != 0)
+
+ }
+
+ /**
+ * test si le noeud fonctionnalite a des frères actifs.
+ * @param fonctionnalite
+ * @param personne
+ * @param etablissement
+ * @return
+ */
+ private Boolean isFreresFonctionnalitePersonneActif(Fonctionnalite fonctionnalite,
+ Personne personne,
+ Etablissement etablissement) {
+
+ if (!fonctionnalite) {
+ return false
+ }
+
+ Fonctionnalite parent = fonctionnalite.parent
+
+ if (!parent) {
+ return false
+ }
+
+
+ String hql = """
+from AccesFonctionnalitePersonne aff
+where
+ aff.fonctionnalite.parent=:parent
+ and
+ not(aff.fonctionnalite=:fonctionnalite)
+ and
+ aff.etablissement=:etablissement
+ and
+ aff.personne=:personne
+
+"""
+
+ List<AccesFonctionnalitePersonne> allAccesFonctionnalitePersonne = AccesFonctionnalitePersonne.executeQuery(
+ hql,
+ [
+ parent: parent,
+ fonctionnalite: fonctionnalite,
+ etablissement: etablissement,
+ personne: personne
+ ]
+ )
+
+ return (allAccesFonctionnalitePersonne.size() != 0)
+
+
+ }
+
private void enregistreDroitFonction(Etablissement etablissement,
Fonction fonction,
Fonctionnalite fonctionnalite,
throw new IllegalStateException("La fonctionnalité $fonctionnalitePersonneElement.fonctionnaliteId n'existe pas.")
}
+ Boolean isFrereDuNoeudActif = false
+
while (fonctionnalite) {
enregistreDroitPersonne(
etablissement,
personne,
fonctionnalite,
- fonctionnalitePersonneElement.actif
+ fonctionnalitePersonneElement.actif || isFrereDuNoeudActif
)
+
+ isFrereDuNoeudActif = isFreresFonctionnalitePersonneActif(
+ fonctionnalite,
+ personne,
+ etablissement
+ )
+
fonctionnalite = fonctionnalite.parent
}
}
- public enregistreDroitPersonne(Etablissement etablissement,
- Personne personne,
- Fonctionnalite fonctionnalite,
- Boolean actif) {
+ private enregistreDroitPersonne(Etablissement etablissement,
+ Personne personne,
+ Fonctionnalite fonctionnalite,
+ Boolean actif) {
List<AccesFonctionnalitePersonne> allAccesFonctionnalitePersonne = AccesFonctionnalitePersonne.withCriteria {
'eq'('personne', personne)
*/
public List<Personne> findAllPersonne(Etablissement etablissement) {
- List<FonctionEnum> fonctionsUtilisateur =
- [
- FonctionEnum.ADMIN_CENTRAL,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT,
- FonctionEnum.INVITE,
- FonctionEnum.EDUCATION,
- FonctionEnum.DOCUMENTALISTE,
- FonctionEnum.CONSEILLER_FORMATION_CONTINUE,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.PERSONNEL_ADMINISTRATIF,
- FonctionEnum.LABORATOIRE,
- FonctionEnum.ASSISTANT_ETRANGER,
- FonctionEnum.PERSONNEL_LABORATOIRE,
- FonctionEnum.PERSONNEL_MEDICO_SOCIAL,
- FonctionEnum.PERSONNEL_OUVRIER,
- FonctionEnum.SURVEILLANCE,
- FonctionEnum.ORIENTATION,
- FonctionEnum.ASSISTANT_EDUCATION,
- FonctionEnum.AUXILIAIRE_VIE_SCOLAIRE,
- FonctionEnum.APPRENTISSAGE
- ]
-
List<Personne> allPersonneParametrable =
fonctionAnnuaireService.findAllPersonnesByEtablissementAndAllFonction(
etablissement,
- fonctionsUtilisateur
+ fonctionAnnuaireService.getAllFonctionEnumParametrable()
)
allPersonneParametrable.sort {it.nomNormalise}
return allPersonneParametrable
-
}
arbrePersonne: true
)
- List<Fonction> allFonctionPersonne = findAllFonctionPourPersonneSurEtablissement(personne, etablissement)
+ List<Fonction> allFonctionPersonne =
+ findAllFonctionParametrablePourPersonneSurEtablissement(personne, etablissement)
List<AccesFonctionnaliteFonction> listeFonctionnalite =
findAllAccesFonctionnaliteForAllFonctionSurEtablissement(
}
}
- private List<Fonction> findAllFonctionPourPersonneSurEtablissement(Personne personne, Etablissement etablissement) {
-
- List<FonctionEtablissement> fonctionEtablissement =
- fonctionAnnuaireService.findAllFonctionEtablissementForAutoriteActeur(
- personne.autorite,
- TypeUtilisateur.UTILISATEUR_NORMAL
- )
+ private List<Fonction> findAllFonctionParametrablePourPersonneSurEtablissement(Personne personne,
+ Etablissement etablissement) {
+ List<FonctionEtablissement> allFonctionSurEtablissement =
+ fonctionAnnuaireService.findAllFonctionEtablissementBy(etablissement, personne.autorite)
- List<FonctionEtablissement> allFonctionSurEtablissement = fonctionEtablissement.findAll {FonctionEtablissement fe ->
- fe.etablissement.id == etablissement.id
- }
+ List<Fonction> allFonctionPersonne =
+ allFonctionSurEtablissement.collect { FonctionEtablissement fe ->
+ Fonction.findByCode(fe.fonctionEnum.getCode())
+ }
- List<Fonction> allFonctionPersonne = allFonctionSurEtablissement.collect { FonctionEtablissement fe ->
- Fonction.findByCode(fe.fonctionEnum.getCode())
- }
+ allFonctionPersonne.remove(Fonction.findByCode(FonctionEnum.ENSEIGNANT.code))
+ allFonctionPersonne.remove(Fonction.findByCode(FonctionEnum.DIRECTION.code))
+ allFonctionPersonne.remove(Fonction.findByCode(FonctionEnum.PERS_REL_ELEVE.code))
+ allFonctionPersonne.remove(Fonction.findByCode(FonctionEnum.ELEVE.code))
allFonctionPersonne
}
* Classe ancêtre décrivant les données de tous les éléments d'affichage texte associé
* à une url
*/
+//TOREFACT : (othe) fusion possible avec AbstractMenu ???
class UrlLabelInfo {
// url si la partie du BreadCrumbs en question est cliquable
String codePorteurENT
+ // TOREFACT bper: pourquoi la variable n'est pas typée?
// Cache des Fonction/Etablissement associées à cette session
private cacheAllFonctionEtablissement = null
+ // TOREFACT bper: pourquoi la variable n'est pas typée?
// Cache des Fonctionnalite paramétrables/Etablissement associées à cette session
- private cacheAllFonctionnaliteParametrableEtablissement= null
+ private cacheAllFonctionnaliteParametrableEtablissement = null
// Cache de l'établissement courant
private Long etablissementCourantId = null
/**
* Liste des groupes étendus auxquels l'utilisateur a accès
- * @return
*/
public List<RessourceIndexeeInfo> getGroupesEtendusInfo() {
listeGroupesEtendus
* Détermine si la securiteSession détient le droit d'accès à une fonctionnalité paramétrable donnée
*/
public boolean hasAccesFonctionnalite(EliotFonctionnalites fonctionnalite, Long etablissementId){
+
+ //TOREFACT bper: Il vaut mieux utiliser la méthode de List "any"
boolean hasAcces = false
cacheAllFonctionnaliteParametrableEtablissement?.get(etablissementId)?.each{ EliotFonctionnalites fonctionnaliteCache ->
if (fonctionnaliteCache == fonctionnalite){
}
return hasAcces
}
+
+ // TOREFACT bper: la sémantique de la méthode n'est pas claire, le nom de la méthode fait penser "toutes les fonctionnalités" alors qu'il s'agit de "au moins une"
/**
* Détermine si la securiteSession détient le droit d'accès sur au moins une des fonctionnalités paramétrables données
*/
public boolean hasAccesFonctionnalitesList(List<EliotFonctionnalites> fonctionnalites, Long etablissementId){
+
+ //TOREFACT bper: Il vaut mieux utiliser la méthode de List "any"
boolean hasAcces = false
fonctionnalites?.each{ EliotFonctionnalites fonctionnalite ->
- if(hasAccesFonctionnalite(fonctionnalites, etablissementId)){
+ if(hasAccesFonctionnalite(fonctionnalite, etablissementId)){
hasAcces = true
return
}
}
public List<EliotFonctionnalites> allFonctionnalite(Long etablissementId){
- cacheAllFonctionnaliteParametrableEtablissement?.get(etablissementId).toList()
+ cacheAllFonctionnaliteParametrableEtablissement?.get(etablissementId)?.toList()
}
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import grails.converters.JSON
import org.lilie.services.eliot.securite.impl.Fonctionnalite
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.securite.impl.AccesFonctionnalitePersonne
-import org.lilie.services.eliot.securite.fonctionnalite.saisie.SaisieFonctionnaliteMarshallerService
import org.lilie.services.eliot.securite.fonctionnalite.saisie.SaisieFonctionnaliteService
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteArbre
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteParams
+
+import org.lilie.services.eliot.securite.impl.AccesFonctionnaliteFonction
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionParams
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnalitePersonneParams
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnalitePersonneElement
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteNoeud
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteFonctionnalite
+import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteEtat
+
class SaisieFonctionnaliteServiceTests extends GrailsUnitTestCase {
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
SaisieFonctionnaliteService saisieFonctionnaliteService
- SaisieFonctionnaliteMarshallerService saisieFonctionnaliteMarshallerService
+ SecuriteFonctionnaliteService securiteFonctionnaliteService
+ AnneeScolaireService anneeScolaireService
Etablissement etablissement1
Fonctionnalite fonctionnalite
Fonction fonctionAdminLocal
Personne personne
Fonctionnalite groupe
+ Etablissement etablissementTest
protected void setUp() {
super.setUp()
etablissement1 = localInitDonneesCommunesTestService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1)
+ etablissementTest = localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_9)
+
fonctionEducation = Fonction.findByCode(FonctionEnum.EDUCATION.code)
fonctionAdminLocal = Fonction.findByCode(FonctionEnum.ADMIN_LOCAL.code)
personne = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.EDUCATION_1)
- saisieFonctionnaliteService.initialiseEtablissement(etablissement1)
+ securiteFonctionnaliteService.initialiseEtablissement(etablissement1)
groupe = Fonctionnalite.findByCode('SCOL_PARAM_MODELES_DOC')
accesFonctionnalitePersonne.save(flush: true, failOnError: true)
}
- void testConstruireArbreFonction() {
+ void testFindAllPersonne() {
+
+ List<FonctionEnum> fonctionEnums = FonctionEnum.values()
+ Map<Personne, FonctionEnum> personnesFonctionsExemple = [:]
+
+ // cree personnes pour toutes les fonctions
+ fonctionEnums.each { FonctionEnum fonctionEnum ->
+ Personne personne =
+ creePersonnePourEtablissement(etablissement1, fonctionEnum)
+ personnesFonctionsExemple.put(personne, fonctionEnum)
+ }
+
+ // recupere personnes
+ List<Personne> personnesTrouvees =
+ saisieFonctionnaliteService.findAllPersonne(etablissement1)
+
+ // verifie que les bonne personnes sont remontees
+ personnesFonctionsExemple.each { Personne personne, FonctionEnum fonctionEnum ->
+ if (fonctionEnum.accesParametrable) {
+ assertNotNull(
+ "Personne avec la fonction parametrable N'EST PAS remontee",
+ personnesTrouvees.find {it == personne}
+ )
+ } else {
+ assertNull(
+ "Personne avec la fonction NON parametrable EST remontee",
+ personnesTrouvees.find {it == personne}
+ )
+ }
+ }
+
+ }
+
+ void testEnregistreDroitFonction() {
+
+ List<FonctionnaliteParams> fonctionnalites = creeFonctionnalites()
+
+ saisieFonctionnaliteService.enregistreDroitFonction(etablissement1, fonctionnalites)
+
+ verifieFonctionnalites(fonctionnalites, etablissement1)
+
+ }
+
+ void testEnregistreDroitPersonne() {
+
+ FonctionnalitePersonneParams fonctionalitePersonnes = creeFonctionnalitePersonnes(personne)
+
+ saisieFonctionnaliteService.enregistreDroitPersonne(etablissement1, fonctionalitePersonnes)
+
+ verifieFonctionnalitePersonnes(fonctionalitePersonnes, etablissement1, personne)
+
+ }
+
+ void testGetAllAccesFonction() {
+
+ List<FonctionnaliteParams> fonctionnaliteParams =
+ creeFonctionnalitesPourFonction(fonctionAdminLocal)
+
+ saisieFonctionnaliteService.
+ enregistreDroitFonction(etablissement1, fonctionnaliteParams)
+ FonctionnaliteArbre fonctionnaliteArbre =
+ saisieFonctionnaliteService.getAllAcces(etablissement1, [fonctionAdminLocal])
+
+ verifieAccesUneFonction(fonctionnaliteArbre, fonctionnaliteParams)
+
+ }
+
+ void testGetAllAccesPersonne() {
+ String codeFonctionEducation = fonctionEducation.code
- FonctionnaliteArbre arbre = saisieFonctionnaliteService.getAllAcces(
+ List<FonctionnaliteParams> fonctionnaliteParams =
+ creeFonctionnalitesPourFonction(fonctionEducation)
+
+ saisieFonctionnaliteService.
+ enregistreDroitFonction(etablissement1, fonctionnaliteParams)
+
+ Personne enseignant = creePersonnePourEtablissement(
etablissement1,
- [fonctionEducation]
+ FonctionEnum.EDUCATION
+ )
+
+ activateFonctionnalitePourPersonne(enseignant, 'SCOL_PARAM_CAL_HEBDO_ANNU')
+
+ FonctionnaliteArbre fonctionnaliteArbre =
+ saisieFonctionnaliteService.getAllAcces(etablissement1, enseignant)
+
+ assertEquals(
+ "L'etat de fonction n'est pas comme prevu",
+ FonctionnaliteEtat.ACTIF_FONCTION, // defini par fonction
+ getEtat(fonctionnaliteArbre, 'ABS_PARAM_GENERAUX', codeFonctionEducation)
+ )
+ assertEquals(
+ "L'etat de fonction n'est pas comme prevu",
+ FonctionnaliteEtat.INACTIF, // defini par fonction
+ getEtat(fonctionnaliteArbre, 'NOTES_SAISIE_SYNTH_CONSEIL', codeFonctionEducation)
+ )
+ assertEquals(
+ "L'etat de fonction n'est pas comme prevu",
+ FonctionnaliteEtat.ACTIF_PERSONNE, // defini pour personne
+ getEtatDePersonne(fonctionnaliteArbre, 'SCOL_PARAM_CAL_HEBDO_ANNU')
)
- println saisieFonctionnaliteMarshallerService.marshallFonction(arbre) as JSON
- //TODO : à compléter
+ }
+ /**
+ * Activate une ofnctionnalite pour une personne donnee
+ */
+ private void activateFonctionnalitePourPersonne(Personne personne, String codeFonctionnalite) {
+ FonctionnalitePersonneParams params = new FonctionnalitePersonneParams(
+ personneId: personne.id,
+ listeFonctionnalitePersonne:[
+ new FonctionnalitePersonneElement(
+ fonctionnaliteId: codeFonctionnalite,
+ actif: true
+ )
+ ]
+ )
+ saisieFonctionnaliteService.enregistreDroitPersonne(etablissement1, params)
}
- void testConstruireArbrePlusieursFonction() {
+ /**
+ * Verifie que les acces sont bien charge pour une fonction donnee
+ */
+ private void verifieAccesUneFonction(FonctionnaliteArbre fonctionnaliteArbre,
+ List<FonctionnaliteParams> fonctionnaliteParams) {
+ fonctionnaliteParams.each { FonctionnaliteParams param ->
+ String codeFonctionnalite = param.fonctionnaliteId
+ Boolean isActif = param.parametres.first().actif // on presume qu'on a une seule fonction dans params
+ String codeFonction = param.parametres.first().codeFonction
+ FonctionnaliteEtat etat = getEtat(fonctionnaliteArbre, codeFonctionnalite, codeFonction)
+ if (isActif) {
+ assertTrue(
+ "La fonctionnalite est sense d'etre actif, mais elle est $etat",
+ [
+ FonctionnaliteEtat.ACTIF_FONCTION,
+ FonctionnaliteEtat.ACTIF_PERSONNE
+ ].contains(etat))
+ } else {
+ assertEquals(
+ "La fonctionnalite est sense d'etre INACTIF. $codeFonction $codeFonctionnalite",
+ FonctionnaliteEtat.INACTIF, etat)
+ }
+ }
+ }
+ private FonctionnaliteEtat getEtat(FonctionnaliteNoeud noeud,
+ String codeFonctionnalite,
+ String codeFonction) {
+ FonctionnaliteEtat etat = null
- List<Fonction> listefonction = [fonctionEducation, fonctionAdminLocal]
+ if(noeud.fonctionnalite?.code == codeFonctionnalite &&
+ noeud instanceof FonctionnaliteFonctionnalite) {
+ etat = noeud.etat.find { it.fonction.code == codeFonction }.etat
+ return etat
+ }
- FonctionnaliteArbre arbre = saisieFonctionnaliteService.getAllAcces(
- etablissement1,
- listefonction
+ noeud.enfants?.each {
+ if (etat == null) {
+ etat = getEtat(it, codeFonctionnalite, codeFonction)
+ }
+ }
+
+ return etat
+ }
+
+ private FonctionnaliteEtat getEtatDePersonne(FonctionnaliteNoeud noeud,
+ String codeFonctionnalite) {
+ FonctionnaliteEtat etat = null
+
+ if(noeud.fonctionnalite?.code == codeFonctionnalite &&
+ noeud instanceof FonctionnaliteFonctionnalite) {
+ return noeud.etatFonctionnalitePersonne
+ }
+
+ noeud.enfants?.each {
+ if (etat == null) {
+ etat = getEtatDePersonne(it, codeFonctionnalite)
+ }
+ }
+
+ return etat
+ }
+
+ private void verifieFonctionnalitePersonnes(FonctionnalitePersonneParams fonctionnalitePersonneParams,
+ Etablissement etablissement,
+ Personne personne) {
+ fonctionnalitePersonneParams.listeFonctionnalitePersonne.each {
+ verifieFonctionnalitePersonne(
+ etablissement,
+ personne,
+ it.fonctionnaliteId,
+ it.actif
+ )
+ }
+ }
+
+ private void verifieFonctionnalitePersonne(Etablissement etablissement,
+ Personne personne,
+ String codeFonctionalite,
+ boolean isActif) {
+ AccesFonctionnalitePersonne droitAcces =
+ AccesFonctionnalitePersonne.createCriteria().get {
+ eq('etablissement', etablissement)
+ eq('personne', personne)
+ fonctionnalite {
+ eq('code', codeFonctionalite)
+ }
+ }
+
+ if (isActif) {
+ assertNotNull(
+ "Le droit d'acces n'est pas enregistre: $personne $codeFonctionalite",
+ droitAcces
+ )
+ } else {
+ assertNull(
+ "Le droit d'acces est enregistre mais ne devrait pas etre: "+
+ "$personne $codeFonctionalite",
+ droitAcces
+ )
+ }
+ }
+
+ private void verifieFonctionnalites(List<FonctionnaliteParams> fonctionnaliteParams,
+ Etablissement etablissement) {
+
+ fonctionnaliteParams.each { FonctionnaliteParams fonctionnaliteParam ->
+ String fonctionaliteCode = fonctionnaliteParam.fonctionnaliteId
+ fonctionnaliteParam.parametres.each { FonctionParams fonctionParams ->
+ verifieAccesFonction(
+ etablissement,
+ fonctionParams.codeFonction,
+ fonctionaliteCode,
+ fonctionParams.actif
+ )
+ }
+ }
+
+ }
+
+ private void verifieAccesFonction(Etablissement etablissement,
+ String codeFonction,
+ String codeFonctionnalite,
+ boolean isActif) {
+ AccesFonctionnaliteFonction droitAcces =
+ AccesFonctionnaliteFonction.createCriteria().get {
+ eq('etablissement', etablissement)
+ 'fonction' {
+ eq('code', codeFonction)
+ }
+ fonctionnalite {
+ eq('code', codeFonctionnalite)
+ }
+ }
+
+ assertEquals(
+ "L'acces de fonction a la fonctionnalite n'est pas comme prevu",
+ isActif,
+ droitAcces.actif
)
- println saisieFonctionnaliteMarshallerService.marshallFonction(arbre) as JSON
- //TODO : à compléter
+ }
+
+ private List<FonctionnaliteParams> creeFonctionnalites() {
+ String fonction1code = fonctionEducation.code
+ String fonction2code = fonctionAdminLocal.code
+ String fonctionnalite1code = "ABS_PARAM_GENERAUX"
+ String fonctionnalite2code = "NOTES_SAISIE_SYNTH_CONSEIL"
+
+ return [
+ new FonctionnaliteParams(
+ fonctionnaliteId: fonctionnalite1code,
+ parametres: [
+ new FonctionParams(
+ codeFonction: fonction1code,
+ actif: true
+ ),
+ new FonctionParams(
+ codeFonction: fonction2code,
+ actif: false
+ )
+ ]
+ ),
+ new FonctionnaliteParams(
+ fonctionnaliteId: fonctionnalite2code,
+ parametres: [
+ new FonctionParams(
+ codeFonction: fonction1code,
+ actif: false
+ ),
+ new FonctionParams(
+ codeFonction: fonction2code,
+ actif: true
+ )
+ ]
+ )
+ ]
}
+ private List<FonctionnaliteParams> creeFonctionnalitesPourFonction(Fonction fonction) {
+ String fonction1code = fonction.code
+ String fonctionnalite1code = "ABS_PARAM_GENERAUX"
+ String fonctionnalite2code = "NOTES_SAISIE_SYNTH_CONSEIL"
+ String fonctionnalite3code = "SCOL_PARAM_CAL_HEBDO_ANNU"
+
+ return [
+ new FonctionnaliteParams(
+ fonctionnaliteId: fonctionnalite1code,
+ parametres: [
+ new FonctionParams(
+ codeFonction: fonction1code,
+ actif: true
+ )
+ ]
+ ),
+ new FonctionnaliteParams(
+ fonctionnaliteId: fonctionnalite2code,
+ parametres: [
+ new FonctionParams(
+ codeFonction: fonction1code,
+ actif: false
+ )
+ ]
+ ),
+ new FonctionnaliteParams(
+ fonctionnaliteId: fonctionnalite3code,
+ parametres: [
+ new FonctionParams(
+ codeFonction: fonction1code,
+ actif: false
+ )
+ ]
+ )
+ ]
- void testConstruireArbreFonctionnalitePersonne() {
+ }
- FonctionnaliteArbre arbre = saisieFonctionnaliteService.getAllAcces(
- etablissement1,
- personne
+ private FonctionnalitePersonneParams creeFonctionnalitePersonnes(Personne personne) {
+
+ String fonctionnalite1code = "ABS_PARAM_GENERAUX"
+ String fonctionnalite2code = "NOTES_SAISIE_SYNTH_CONSEIL"
+
+ FonctionnalitePersonneParams params = new FonctionnalitePersonneParams(
+ personneId: personne.id,
+ listeFonctionnalitePersonne:[
+ new FonctionnalitePersonneElement(
+ fonctionnaliteId: fonctionnalite1code,
+ actif: true
+ ),
+ new FonctionnalitePersonneElement(
+ fonctionnaliteId: fonctionnalite2code,
+ actif: false
+ )
+ ]
+ )
+
+ return params
+ }
+
+ /**
+ * Cree une personne avec la fonction donne dans l'etablissement
+ */
+ private Personne creePersonnePourEtablissement(Etablissement etablissement,
+ FonctionEnum fonctionEnum) {
+
+ String idGenere = "Personne-"+(new Date().getTime())
+ Fonction fonction = Fonction.findByCode(fonctionEnum.code)
+
+ // crée l'autorité
+ Autorite autorite = new Autorite(
+ type: Autorite.TYPE_ACTEUR,
+ idExterne: idGenere
)
+ autorite.modifieEtat(CompteUtilisateurEtat.ACTIF)
+
+ autorite.save(failOnError: true)
- println saisieFonctionnaliteMarshallerService.marshallFonction(arbre) as JSON
- //TODO : à compléter
+ // crée la personne
+ Personne personne = new Personne(
+ nom: idGenere,
+ prenom: idGenere,
+ autorite: autorite,
+ etablissementRattachement: etablissement,
+ )
+ personne.save(failOnError: true)
+ // crée la propriété scolarité
+ ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ fonction: fonction,
+ etablissement: etablissement
+ )
+ 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 personne
}
-}
+}
\ No newline at end of file
eleveId:undefined,
isPersonneId:undefined,
ficheEleve:undefined,
- voirOngletCommentaire:undefined,
+ droitAccessOnglets:undefined,
donneesOngletSanctions:undefined,
classes:undefined,
classeId:undefined,
responsable_1:'responsable1',
responsable_2:'responsable2',
responsable:'responsable',
- recapitulatifGrid: 'ficheEleveConseilRecapitulatif'
+ recapitulatifGrid:'ficheEleveConseilRecapitulatif',
+ ongletAbsences:'ongletAbsences',
+ ongletSanctions:'ongletSanctions',
+ ongletNotes:'ongletNores',
+ ongletConseil:'ongletConseil'
},
calendrierColExpanded:'mois',
this.config.model.applyValue({
eleveId:resultats.ficheEleve.eleve.id,
ficheEleve:resultats.ficheEleve,
- voirOngletCommentaire:resultats.voirOngletCommentaire,
+ droitAccessOnglets:resultats.droitAccessOnglets,
donneesOngletSanctions:resultats.donneesOngletSanctions,
classeNotesId:resultats.donneesNotes.classeId,
classesNotes:resultats.donneesNotes.classesNotes,
{
title:this.ConfigServeur.libelle.absences,
- layout: 'fit',
+ layout:'fit',
items:this.config.absencesPanelView.panel,
- view:this.config.absencesPanelView
+ view:this.config.absencesPanelView,
+ id:this.Constantes.id.ongletAbsences
},
{
- title: this.ConfigServeur.libelle.sanctions,
- layout: 'fit',
- items: this.config.sanctionsPanelView.panel,
- view: this.config.sanctionsPanelView
+ title:this.ConfigServeur.libelle.sanctions,
+ layout:'fit',
+ items:this.config.sanctionsPanelView.panel,
+ view:this.config.sanctionsPanelView,
+ id:this.Constantes.id.ongletSanctions
},
{
title:this.ConfigServeur.libelle.ongletNote,
layout:'fit',
items:this.config.notePanelView.getItem(),
- view:this.config.notePanelView
+ view:this.config.notePanelView,
+ id:this.Constantes.id.ongletNotes
},
{
title:this.ConfigServeur.libelle.ongletConseil,
layout:'fit',
items:this.config.conseilPanelView.getItem(),
- view:this.config.conseilPanelView
+ view:this.config.conseilPanelView,
+ id:this.Constantes.id.ongletConseil
}
],
listeners:{
});
this.fenetre = new Ext.Window({
- id: 'ficheEleveWindow',
+ id:'ficheEleveWindow',
modal:true,
width:780,
height:590,
function (value) {
if ((value != null)
&& (value.ficheEleve != null)
- && (value.voirOngletCommentaire != null)) {
+ && (value.droitAccessOnglets != null)) {
- this.initialiseDatas(value.ficheEleve, value.voirOngletCommentaire);
+ this.initialiseDatas(value.ficheEleve, value.droitAccessOnglets);
}
},
this);
* @param voirOngletCommentaire : flag indiquant si l'onglet Commentaire
* doit être visible
*/
- initialiseDatas:function (ficheEleve, voirOngletCommentaire) {
-
+ initialiseDatas:function (ficheEleve, droitAccessOnglets) {
this.fenetre.setTitle(this.ConfigServeur.libelle.ficheEleve + ' - ' +
ficheEleve.eleve.nom + ' ' + ficheEleve.eleve.prenom + ' - ' +
ficheEleve.eleve.classe);
- if (!voirOngletCommentaire) {
+ if (!droitAccessOnglets.commentaire) {
this.tabPnl.remove(this.tabCommentaire);
}
+
+ if (!droitAccessOnglets.sanctions) {
+ this.tabPnl.remove(this.Constantes.id.ongletSanctions)
+ }
+
+ if (!droitAccessOnglets.absences) {
+ this.tabPnl.remove(this.Constantes.id.ongletAbsences)
+ }
+
+ if (!droitAccessOnglets.notes) {
+ this.tabPnl.remove(this.Constantes.id.ongletNotes)
+ }
+
+ if (!droitAccessOnglets.conseil) {
+ this.tabPnl.remove(this.Constantes.id.ongletConseil)
+ }
},
/**
</sql>
</changeSet>
+ <changeSet id="2" author="agia">
+
+ <comment>
+ Supprimer la fonctionnalité 'NOTES_CONSULT_NOTES_MODIF'
+ </comment>
+
+ <sql>
+
+ DELETE FROM securite.acces_fonctionnalite_fonction_defaut
+ WHERE fonctionnalite_id = (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_CONSULT_NOTES_MODIF');
+
+ DELETE FROM securite.acces_fonctionnalite_fonction
+ WHERE fonctionnalite_id = (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_CONSULT_NOTES_MODIF');
+
+ DELETE FROM securite.fonctionnalite
+ WHERE code LIKE 'NOTES_CONSULT_NOTES_MODIF';
+
+ </sql>
+
+ <comment>
+ Ajouter la fonctionnalite 'NOTES_SAISIE_NOTES'
+ </comment>
+
+ <sql>
+
+ UPDATE securite.fonctionnalite
+ SET ordre = 3
+ WHERE code LIKE 'NOTES_SAISIE_BREVET';
+
+ UPDATE securite.fonctionnalite
+ SET ordre = 2
+ WHERE code LIKE 'NOTES_SAISIE_SYNTH';
+
+ INSERT INTO securite.fonctionnalite (id, code, parent_id, parametrable, ordre, groupe)
+ VALUES (nextVal('securite.fonctionnalite_id_seq'), 'NOTES_SAISIE_NOTES', (SELECT id FROM securite.fonctionnalite WHERE code = 'NOTES_SAISIE'), true, 1, false);
+
+ <!-- fonction AC -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'AC'),
+ false
+ );
+ <!-- fonction AL -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'AL'),
+ false
+ );
+ <!-- fonction CD -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'CD'),
+ false
+ );
+ <!-- fonction UI -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'UI'),
+ false
+ );
+ <!-- fonction EDU -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'EDU'),
+ true
+ );
+ <!-- fonction DOC -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'DOC'),
+ true
+ );
+ <!-- fonction CFC -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'CFC'),
+ false
+ );
+ <!-- fonction CTR -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'CTR'),
+ false
+ );
+ <!-- fonction ADF -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'ADF'),
+ false
+ );
+ <!-- fonction ALB -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'ALB'),
+ false
+ );
+ <!-- fonction ASE -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'ASE'),
+ false
+ );
+ <!-- fonction LAB -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'LAB'),
+ false
+ );
+ <!-- fonction MDS -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'MDS'),
+ false
+ );
+ <!-- fonction OUV -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'OUV'),
+ false
+ );
+ <!-- fonction SUR -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'SUR'),
+ false
+ );
+ <!-- fonction ORI -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'ORI'),
+ false
+ );
+ <!-- fonction AED -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'AED'),
+ false
+ );
+ <!-- fonction AVS -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'AVS'),
+ false
+ );
+ <!-- fonction APP -->
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut(id, fonctionnalite_id, fonction_id, actif)
+ VALUES (
+ nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+
+ (SELECT id FROM securite.fonctionnalite WHERE CODE LIKE 'NOTES_SAISIE_NOTES'),
+ (SELECT id FROM ent.fonction WHERE CODE LIKE 'APP'),
+ false
+ );
+
+ </sql>
+
+ </changeSet>
--- /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>
+ Suppression de paramétrage par défaut d'accès aux fonctionnalité
+ pour la fonction invité
+ </comment>
+
+ <sql>
+ delete from securite.acces_fonctionnalite_fonction_defaut as affd
+ where affd.fonction_id in (
+ select id from ent.fonction
+ where code = 'UI'
+ )
+ </sql>
+
+ </changeSet>
+
+ <changeSet id="2" author="bahj">
+ <comment>
+ Alimentation de la table AccesFonctionnaliteFonctionDefaut pour la
+ fonctionnalité FICHE_ELEVE
+ </comment>
+
+ <sql>
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'AL'), true);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'CD'), true);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'DOC'), true);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'EDU'), true);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'CTR'), true);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'AC'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'UI'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'CFC'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'ADF'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'ALB'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'LAB'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'MDS'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'OUV'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'ASE'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'ORI'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'AED'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'APP'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'AVS'), false);
+
+ INSERT INTO securite.acces_fonctionnalite_fonction_defaut (id,
+ fonctionnalite_id, fonction_id, actif)
+ VALUES
+ (nextVal('securite.acces_fonctionnalite_fonction_defaut_id_seq'),
+ (SELECT id FROM securite.fonctionnalite WHERE code = 'FICHE_ELEVE'),
+ (SELECT id FROM ent.fonction WHERE code = 'SUR'), false);
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="2" author="msan">
+
+ <comment>
+ Suppression de fonctionnalite NOTES_CONSULT_NOTES
+ </comment>
+
+ <sql>
+ delete from securite.acces_fonctionnalite_fonction_defaut as affd
+ where affd.fonctionnalite_id in (
+ select id from securite.fonctionnalite
+ where code = 'NOTES_CONSULT_NOTES'
+ )
+ </sql>
+
+ <sql>
+ delete from securite.acces_fonctionnalite_fonction as aff
+ where aff.fonctionnalite_id in (
+ select id from securite.fonctionnalite
+ where code = 'NOTES_CONSULT_NOTES'
+ )
+ </sql>
+
+ <sql>
+ delete from securite.acces_fonctionnalite_personne as afp
+ where afp.fonctionnalite_id in (
+ select id from securite.fonctionnalite
+ where code = 'NOTES_CONSULT_NOTES'
+ )
+ </sql>
+
+ <delete tableName="fonctionnalite" schemaName="securite">
+ <where>code = 'NOTES_CONSULT_NOTES'</where>
+ </delete>
+
+ </changeSet>
+
+ <changeSet id="3" author="msan">
+
+ <comment>
+ Renommage de fonctionnalite NOTES_SAISIE_NOTES ->
+ NOTES_SAISIE_NOTES_ENSEIGNANTS
+ </comment>
+
+ <update tableName="fonctionnalite" schemaName="securite">
+ <column name="code" value="NOTES_SAISIE_NOTES_ENSEIGNANTS"/>
+ <where>code = 'NOTES_SAISIE_NOTES'</where>
+ </update>
+
+ </changeSet>
+
+
+</databaseChangeLog>
\ No newline at end of file
<include file="changelogs/scolarite/2013-06-12-0027533.xml"/>
<include file="changelogs/scolarite/2013-06-12-0027533-2.xml"/>
<include file="changelogs/scolarite/2013-06-13-0027533.xml"/>
+ <include file="changelogs/scolarite/2013-06-27-0027533.xml"/>
</databaseChangeLog>
eliot.absences.publipostage.sms.trigger.startDelay = 1000
// Délais de répétition du job de publipostage des sms en ms (0 = arrêt du job)
-eliot.absences.publipostage.sms.trigger.repeatInterval = 1000
+eliot.absences.publipostage.sms.trigger.repeatInterval = 0
// Emplacement de l'aide en ligne
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.absences.page.Page
import org.lilie.services.eliot.menu.MenuInfo
-import org.lilie.services.eliot.absences.menu.MenuService
import org.lilie.services.eliot.AbstractEliotController
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.PartenaireAPrevenirService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
-
import org.lilie.services.eliot.securite.AutorisationException
import java.text.SimpleDateFormat
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypePunitionService
import org.lilie.services.eliot.scolarite.Calendrier
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.parametrages.calendrier.CalendrierSessionService
import org.lilie.services.eliot.CodeComparator
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.scolarite.personne.PersonneAnnuaireService
import org.lilie.services.eliot.applications.absences.BasicCriteresRecherche
-
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.urllabel.UrlLabelInfo
import org.lilie.services.eliot.absences.breadcrumbs.MenuAideAbsencesService
import org.lilie.services.eliot.urllabel.aide.AideItemInfo
import grails.converters.JSON
import org.lilie.services.eliot.absences.securite.DroitsSessionService
-import org.lilie.services.eliot.absences.fonctionnalites.AbsencesFonctionnaliteAnc
+import org.lilie.services.eliot.menu.MenuService
+import org.lilie.services.eliot.menu.MenuApplication
+import org.lilie.services.eliot.absences.menu.description.MenuEntete
+import org.lilie.services.eliot.absences.menu.description.MenuSousMenu
+import org.lilie.services.eliot.absences.securite.DroitsService
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.annuaire.SecuriteSession
/**
* Classe ancêtre embarquant des traitements génériques à tous les controleurs d'absences
CalendrierSessionService calendrierSessionService
PersonneAnnuaireService personneAnnuaireService
MenuAideAbsencesService menuAideAbsencesService
+ DroitsService droitsService
CodeComparator comparateurLogique = new CodeComparator()
final static Long VALEUR_TOUS = -1
+
+ private MenuApplication getMenuApplication() {
+
+ return new MenuApplication(
+ entetes: MenuEntete.collect {it},
+ sousMenus: MenuSousMenu.collect {it}
+ )
+
+ }
+
+ private List<EliotFonctionnalites> findAllFonctionnalite(SecuriteSession securiteSession,
+ Etablissement etablissement) {
+ HashSet<EliotFonctionnalites> setFonctionnalite = droitsService.getFonctionnalitesAccessibles(
+ securiteSession,
+ etablissement
+ )
+
+ setFonctionnalite.toList()
+ }
+
+
protected MenuInfo buildMenuInfo(Object page) {
+
return menuService.getMenuInfo(
getSecuriteSession(),
- (Page) page,
- getPreferencesEtablissementCourant().etablissement
+ page,
+ findAllFonctionnalite(securiteSession, etablissementCourant()),
+ getMenuApplication()
)
+
}
/**
* mémorisé en session
*/
protected PreferencesEtablissementAbsences getPreferencesEtablissementForIdExterne(
- String idExterneEtab, Boolean miseEnCacheSession) {
+ String idExterneEtab, Boolean miseEnCacheSession) {
PreferencesEtablissementAbsences pref =
- preferencesUtilisateurAbsencesSessionService.
- getPreferencesEtablissementAbsencesCourant(getSecuriteSession())
+ preferencesUtilisateurAbsencesSessionService.
+ getPreferencesEtablissementAbsencesCourant(getSecuriteSession())
if (pref?.etablissement?.idExterne == idExterneEtab) {
return pref
List<UrlLabelInfo> breadCrumbsInfo = []
Etablissement etablissementCourant =
- (Etablissement) getSecuriteSession().etablissementCourant
+ (Etablissement) getSecuriteSession().etablissementCourant
BreadCrumbsItemInfo breadCrumbsItemInfoEnTete = new BreadCrumbsItemInfo(
codeLabel: 'absences.breadCrumbs.Etablissement',
List<Map> etablissementsInfo = []
List<Etablissement> etabs =
- (List<Etablissement>) getSecuriteSession().etablissementsAccessibles
+ (List<Etablissement>) getSecuriteSession().etablissementsAccessibles
etabs.each { it ->
etablissementsInfo.add([
* @param fonctionnalite
* @throws AutorisationException
*/
- protected verificationDroitFonctionnalite(AbsencesFonctionnalite fonctionnalite)
+ protected verificationDroitFonctionnalite(EliotFonctionnalites fonctionnalite)
throws AutorisationException {
droitsSessionService.verifieDroitFonctionnalite(
getSecuriteSession(),
)
}
- /**
- * détermine le droit de la session courante aux
- * création/modification/suppression d'une punition / sanction / incident
- * @return flag
- * @author bahj
- */
- protected Boolean aDroitsCUDDiscipline() {
- Boolean droitsCud = false
- PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
-
- if (
- getSecuriteSession().hasFonctionIn([
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- pref.etablissement.id)
- ) {
- droitsCud = true
- }
-
- return droitsCud
- }
/**
* Retourne la liste des enseignants de l'établissement courant
List enseignantMaps = []
List<Personne> enseignants =
- personneAnnuaireService.findAllEnseignantByEtablissement(
- etablissementCourant()
- )
+ personneAnnuaireService.findAllEnseignantByEtablissement(
+ etablissementCourant()
+ )
enseignants.each { Personne enseignant ->
enseignantMaps.add([
pref.groupeMotifs.each {
GroupeMotif groupe ->
result << [
- id: groupe.id,
- libelle: groupe.libelle,
- ordre: groupe.ordre
+ id: groupe.id,
+ libelle: groupe.libelle,
+ ordre: groupe.ordre
]
}
result.sort { it.ordre }
* Retourne les données pour la construction du menu d'aide en ligne
* @return
*/
- protected AideItemInfo getAideInfo(){
+ protected AideItemInfo getAideInfo() {
AideItemInfo menuAideInfo = menuAideAbsencesService.getMenuAideInfo(securiteSession)
menuAideInfo.urlImage = resource(dir: 'images',
- file: 'help.png',
- plugin :'eliot-app-plugin'
+ file: 'help.png',
+ plugin: 'eliot-app-plugin'
)
return menuAideInfo
}
* @return une intersection des 2 listes de motifs
*/
protected List<Motif> getSousListeMotifsDefaut(List<Motif> motifDefauts,
- List<Motif> motifs) {
+ List<Motif> motifs) {
List<Motif> result = []
motifDefauts.each {
Motif motif ->
return result
}
- protected Boolean traiteChangementEtablissement(Map params, Page page){
+ protected Boolean traiteChangementEtablissement(Map params, Page page) {
Boolean changeEtab = false
- if(params.etablissementId){
+ if (params.etablissementId) {
Long etablissementId = Long.parseLong(params.etablissementId)
- if(etablissementId != etablissementCourantId()){
+ if (etablissementId != etablissementCourantId()) {
changeEtab = true
- redirect (
- controller: 'application',
- action: 'changeEtablissement',
- params: [
- id: etablissementId,
- page: page,
- params: params as JSON
- ]
+ redirect(
+ controller: 'application',
+ action: 'changeEtablissement',
+ params: [
+ id: etablissementId,
+ page: page,
+ params: params as JSON
+ ]
)
}
}
}
-
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences
import org.lilie.services.eliot.scolarite.Calendrier
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.page.Page
-import org.lilie.services.eliot.annuaire.FonctionEnum
import grails.converters.JSON
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.absences.menu.description.MenuEntete
+import org.lilie.services.eliot.absences.menu.description.MenuSousMenu
+/**
+ *
+ * @author othe
+ */
class ApplicationController extends AbstractAbsencesController {
def index = {
return
}
- if (
- getSecuriteSession().hasFonctionIn([
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- pref.etablissement.id)
- ) {
+ if (getSecuriteSession().hasAccesFonctionnalite(
+ (EliotFonctionnalites) AbsencesFonctionnalite.ABS_SAISIE_APPELS,
+ pref.etablissement.id)) {
if (Calendrier.findByEtablissement(pref.etablissement)) {
chain(
controller: ConstantesControleurs.CONTROLLER_NAME_SAISIE_ABSENCES,
}
}
- if (getSecuriteSession().hasFonctionIn([
- FonctionEnum.ENSEIGNANT,
- FonctionEnum.DOCUMENTALISTE],
+ if (getSecuriteSession().hasAccesFonctionnalite(
+ (EliotFonctionnalites) AbsencesFonctionnalite.ABS_CONSULT_PARENT,
pref.etablissement.id)) {
- chain(
- controller: ConstantesControleurs.CONTROLLER_NAME_SAISIE_ABSENCES,
- action: ConstantesControleurs.ACTION_NAME_SAISIE_PROF
- )
- return
- }
-
- if (getSecuriteSession().hasFonctionIn([FonctionEnum.PERS_REL_ELEVE], pref.etablissement.id)) {
chain(
controller: ConstantesControleurs.CONTROLLER_NAME_CONSULTATION,
action: ConstantesControleurs.ACTION_NAME_PAR_PARENT_INDEX
return
}
- if (getSecuriteSession().hasFonctionIn([FonctionEnum.ELEVE], pref.etablissement.id)) {
+ if (getSecuriteSession().hasAccesFonctionnalite(
+ (EliotFonctionnalites) AbsencesFonctionnalite.ABS_CONSULT_ELEVE,
+ pref.etablissement.id)) {
chain(
controller: ConstantesControleurs.CONTROLLER_NAME_CONSULTATION,
action: ConstantesControleurs.ACTION_NAME_PAR_ELEVE_INDEX
return
}
- if (getSecuriteSession().hasFonctionIn([FonctionEnum.CORRESPONDANT_DEPLOIEMENT])) {
+ Page page = getDefaultPage()
+
+ if (page) {
chain(
- controller: ConstantesControleurs.CONTROLLER_NAME_MAINTENANCE,
- action: ConstantesControleurs.ACTION_NAME_INDEX
+ controller: page.controllerName,
+ action: page.actionName
)
- return
+ } else {
+ throw AutorisationException.consultationContenuException()
}
- throw AutorisationException.consultationContenuException()
+ }
+
+ /**
+ * Retourne la page par défaut
+ * @return
+ */
+ private Page getDefaultPage() {
+
+ Page page = null
+
+ List<EliotFonctionnalites> allFonctionnalite =
+ droitsService.getFonctionnalitesAccessibles(getSecuriteSession(), etablissementCourant()).toList()
+
+ MenuEntete.each {
+
+ MenuEntete menuEntete ->
+
+ MenuSousMenu.each {MenuSousMenu menuSousMenu ->
+
+ if (menuSousMenu.menuEnteteEnum.toString() == menuEntete.toString()) {
+
+ if (allFonctionnalite.find {it.getCode() == menuSousMenu.fonctionnalite.getCode()}) {
+
+ if (!page) {
+ if (menuSousMenu.page != Page.NOTIFICATION_PREFERNCE_UTILISATEUR) {
+ page = (Page) menuSousMenu.page
+ }
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+ return page
}
def changeEtablissement = {
page.absencesFonctionnalite
)) {
Map mapParams = [:]
- if(params.params){
+ if (params.params) {
mapParams = JSON.parse(params.params)
}
redirect(
import org.lilie.services.eliot.SessionUtils
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.notification.parametrage.PreferencePersonneEtablissement
+import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
class NotificationPreferenceUtilisateurController extends AbstractAbsencesController {
def index = {
- // seul ces rôles peuvent avoir accès a cette fonctionnalité
- if (!securiteSession.hasFonctionIn([
- org.lilie.services.eliot.annuaire.FonctionEnum.DIRECTION,
- org.lilie.services.eliot.annuaire.FonctionEnum.CHEF_TRAVAUX,
- org.lilie.services.eliot.annuaire.FonctionEnum.EDUCATION,
- org.lilie.services.eliot.annuaire.FonctionEnum.ADMIN_LOCAL,
- org.lilie.services.eliot.annuaire.FonctionEnum.ENSEIGNANT,
- org.lilie.services.eliot.annuaire.FonctionEnum.PERS_REL_ELEVE,
- org.lilie.services.eliot.annuaire.FonctionEnum.ELEVE
- ])) {
- throw AutorisationException.consultationContenuException()
- }
+ verificationDroitFonctionnalite(ScolariteFonctionnalites.NOTIFICATION_PREFERNCE_UTILISATEUR)
Map modele = prepareBaseModele(Page.NOTIFICATION_PREFERNCE_UTILISATEUR)
Etablissement etablissement = etablissementCourant()
PreferencePersonneEtablissement preferencePersonne =
- notificationPreferenceUtilisateurService.getPreferencePersonne(
- etablissement,
- securiteSession
- )
+ notificationPreferenceUtilisateurService.getPreferencePersonne(
+ etablissement,
+ securiteSession
+ )
modele.preferencesUtilisateur =
preferencePersonne.allNotificationTypePreferenceUtilisateur as JSON
def enregistre = {
- // seul ces rôles peuvent avoir accès a cette fonctionnalité
- if (!securiteSession.hasFonctionIn([
- org.lilie.services.eliot.annuaire.FonctionEnum.DIRECTION,
- org.lilie.services.eliot.annuaire.FonctionEnum.CHEF_TRAVAUX,
- org.lilie.services.eliot.annuaire.FonctionEnum.EDUCATION,
- org.lilie.services.eliot.annuaire.FonctionEnum.ADMIN_LOCAL,
- org.lilie.services.eliot.annuaire.FonctionEnum.ENSEIGNANT,
- org.lilie.services.eliot.annuaire.FonctionEnum.PERS_REL_ELEVE,
- org.lilie.services.eliot.annuaire.FonctionEnum.ELEVE
- ])) {
- throw AutorisationException.consultationContenuException()
- }
+ verificationDroitFonctionnalite(ScolariteFonctionnalites.NOTIFICATION_PREFERNCE_UTILISATEUR)
Map notificationsMisesAJour = [:]
Boolean erreurs = false
- if(params.notifications){
+ if (params.notifications) {
notificationsMisesAJour = (Map) JSON.parse(params.notifications)
}
- if (erreurs){
+ if (erreurs) {
render([
success: false,
message: message(code: 'eliot.absences.messages.notification.parametrageChangeErreur')
/**
* La liste des groupes de pages de l'application eliot-absences
- *
+ * TOREFACT : (othe) à supprimer
* @author jtra
+ * @deprecated
*/
public enum GroupePage {
SAISIE,
package org.lilie.services.eliot.absences.page
import org.lilie.services.eliot.absences.ConstantesControleurs
-import org.lilie.services.eliot.absences.fonctionnalites.AbsencesFonctionnaliteAnc
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
/**
* La liste des pages de l'application eliot-absences
),
SAISIE_DISPENSES(
GroupePage.SAISIE,
- AbsencesFonctionnaliteAnc.SAISIE_DISPENSES,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS,
ConstantesControleurs.CONTROLLER_NAME_SAISIE_DISPENSES,
ConstantesControleurs.ACTION_NAME_SAISIE_DISPENSES,
),
),
NOTIFICATION_PREFERNCE_UTILISATEUR(
GroupePage.AUCUNE,
- AbsencesFonctionnaliteAnc.NOTIFICATION_PREFERNCE_UTILISATEUR,
+ ScolariteFonctionnalites.NOTIFICATION_PREFERNCE_UTILISATEUR,
ConstantesControleurs.CONTROLLER_NOTIFICATION_PREFERNCE_UTILISATEUR,
ConstantesControleurs.ACTION_NAME_INDEX
)
private GroupePage groupePage
- private AbsencesFonctionnaliteAnc absencesFonctionnalite
+ private EliotFonctionnalites absencesFonctionnalite
private String controllerName
private String actionName
private Page(GroupePage groupePage,
- AbsencesFonctionnaliteAnc absencesFonctionnalite,
+ EliotFonctionnalites absencesFonctionnalite,
String controleur,
String action) {
this.groupePage = groupePage
return groupePage
}
- public AbsencesFonctionnaliteAnc getAbsencesFonctionnalite() {
+ public EliotFonctionnalites getAbsencesFonctionnalite() {
return absencesFonctionnalite
}
import org.lilie.services.eliot.applications.absences.BasicCriteresRecherche
import org.lilie.services.eliot.impression.template.ImpressionTemplateDocumentService
import org.lilie.services.eliot.impression.TemplateDocument
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.demon.DemandeTraitementStatut
import org.lilie.services.eliot.demon.ChampHistoriqueDemandeTraitement
class PublipostageController extends AbstractConsultationController {
CalendrierService calendrierService
LocalStructureEnseignementService localStructureEnseignementService
- LocalPersonneService localPersonneService
PublipostageAbsencesService publipostageAbsencesService
ImpressionTemplateDocumentService impressionTemplateDocumentService
PublipostageDirectService publipostageDirectService
verificationDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
// construction du modèle
Map modele = prepareBaseModele(Page.SAISIE_INCIDENTS)
- modele.activeCRUD = aDroitsCUDDiscipline()
+ modele.activeCRUD = droitsService.aDroitsCUDDiscipline(
+ getSecuriteSession(),
+ etablissementCourant()
+ )
render(
view: '/saisie/incident/consultation/index',
securiteSession,
securiteSession.personne,
getPreferencesEtablissementCourant().etablissement,
- sortInfo.field ?: 'date',
+ sortInfo.field ?: 'date',
(sortInfo.direction == 'ASC'),
start,
limit
)
Map nomsAffichageByIdExterne =
- affichageIncidentService.getNomsAffichageByIdExterne(listeIncidents)
+ affichageIncidentService.getNomsAffichageByIdExterne(listeIncidents)
List<IncidentConsultationInfo> incidentsData =
- affichageIncidentService.getIncidentConsultationsInfos(
- listeIncidents.incidents,
- nomsAffichageByIdExterne
- )
+ affichageIncidentService.getIncidentConsultationsInfos(
+ listeIncidents.incidents,
+ nomsAffichageByIdExterne
+ )
def resultats = [
data: incidentsData,
verificationDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
DonneesPourExportCSV donneesPourExportCSV =
- absencesPreparationExportCSVService.findIncidents(
- securiteSession,
- getPreferencesEtablissementCourant().etablissement,
- securiteSession.personne
- )
+ absencesPreparationExportCSVService.findIncidents(
+ securiteSession,
+ getPreferencesEtablissementCourant().etablissement,
+ securiteSession.personne
+ )
sendCsvFile(
response,
}
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
modele.anneeScolaire = [
debutAnneeScolaire: formateDate(calendrier.premierJour),
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
modele.anneeScolaire = [
debutAnneeScolaire: formateDate(calendrier.premierJour),
String dateComplete = incidentInfo.date + ',' + incidentInfo.heure
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
IncidentParams incidentParams = new IncidentParams(
date: parseDateComplete(dateComplete),
partenairesParams: getPartenairesAPrevenir(
incidentInfo.partenaireAPrevenir,
),
- preferences : preferences
+ preferences: preferences
)
if (identifiant) {
// Mode Modification
- resultats = modifieIncident(incidentParams,
+ resultats = modifieIncident(incidentParams,
Long.parseLong(identifiant)
)
}
}
private List<PartenaireAPrevenirIncidentParams> getPartenairesAPrevenir(
- String partenairesParams
+ String partenairesParams
) {
List<PartenaireAPrevenirIncidentParams> partenairesDto = []
if (partenairesParams != "") {
* @author bahj
*/
private List<ProtagonisteModificationInfo> getProtagonistesModificationInfo(
- Incident incident
+ Incident incident
) {
List<ProtagonisteModificationInfo> protagonistesModInfo = []
)
)
}
- protagonistesModInfo.sort{Personne.findByAutorite(Autorite.get(it.idAutorite)).nom}
+ protagonistesModInfo.sort {Personne.findByAutorite(Autorite.get(it.idAutorite)).nom}
return protagonistesModInfo
}
// construction du modèle
Map modele = prepareBaseModele(Page.SAISIE_PUNITIONS)
- modele.activeCUD = aDroitsCUDDiscipline()
+ modele.activeCUD = droitsService.aDroitsCUDDiscipline(
+ getSecuriteSession(),
+ etablissementCourant()
+ )
render(
view: '/saisie/punition/consultation/index',
}
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Locale locale = RCU.getLocale(request)
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
modele.anneeScolaire = [
debutAnneeScolaire: formateDate(calendrier.premierJour),
modele.message = getMessageModele(params)
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
Locale locale = RCU.getLocale(request)
modele.anneeScolaire = [
* @return
*/
private List<PunitionConsultationInfo> parsePunitionsInfoForConsultation(
- List punitionsInfo
+ List punitionsInfo
) {
List<PunitionConsultationInfo> punitionsConsultationInfo = []
SimpleDateFormat sdf = getSimpleDateFormatJour()
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
return new PunitionParams(
id: mapParams.id,
import org.lilie.services.eliot.absences.saisie.discipline.sanction.exceptions.SanctionException
import org.lilie.services.eliot.absences.Motif
import org.codehaus.groovy.grails.web.json.JSONObject
-import org.lilie.services.eliot.absences.consultation.ConsultationService
import org.lilie.services.eliot.absences.PlageHoraire
import org.lilie.services.eliot.parametrages.calendrier.PlageHoraireService
import org.lilie.services.eliot.export.DonneesPourExportCSV
CalendrierService calendrierService
AbsencesSanctionService absencesSanctionService
- ConsultationService consultationService
PlageHoraireService plageHoraireService
AbsencesPreparationExportCSVService absencesPreparationExportCSVService
EnumMarshallerService enumMarshallerService
// construction du modèle
Map modele = prepareBaseModele(Page.SAISIE_SANCTIONS)
- modele.activeCUD = aDroitsCUDDiscipline()
+ modele.activeCUD = droitsService.aDroitsCUDDiscipline(
+ getSecuriteSession(),
+ etablissementCourant()
+ )
render(
view: '/saisie/sanction/consultation/index',
}
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
Locale locale = RCU.getLocale(request)
modele.anneeScolaire = [
modele.message = getMessageModele(params)
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
+ calendrierService.getCalendrierForEtablissement(preferences.etablissement)
Locale locale = RCU.getLocale(request)
modele.anneeScolaire = [
*/
private Map getSanctionAModifierInfo(long sanctionId) {
Sanction sanction = Sanction.get(sanctionId)
- Map sanctionAModifierInfo = (Map)[
+ Map sanctionAModifierInfo = (Map) [
id: sanction.id,
date: formateDate(sanction.date),
typeSanctionId: sanction.typeSanction.id,
String identifiant = sanctionInfo.id
PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ getPreferencesEtablissementCourant()
Personne eleve = null
Personne censeur = null
if (sanctionInfo.autoriteEleveId != JSONObject.NULL) {
description: sanctionInfo.description,
incident: getIncident(sanctionInfo.incidentId ?: null),
absenceLiee: sanctionInfo.isAbsenceLiee,
- preferences : preferences
+ preferences: preferences
)
if (sanctionParams.absenceLiee) {
}
}
-
/**
* Permet de modifier une sanction
* @param identifiant
* @return
*/
private List<SanctionConsultationInfo> parseSanctionsInfoForConsultation(
- List sanctionsInfo
+ List sanctionsInfo
) {
List<SanctionConsultationInfo> sanctionsConsultationInfo = []
import org.lilie.services.eliot.export.DonneesPourExportCSV
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.urllabel.UrlLabelInfo
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class TableauDeBordController extends AbstractAbsencesController {
static int nbLigneParPage = ConfigurationHolder.config.eliot.absences.statistique.tableauDeBord.nombreLignesParPage ?: 100
def index = {
+ verificationDroitFonctionnalite(AbsencesFonctionnalite.ABS_STATS)
+
Map modele = prepareBaseModele(Page.STATISTIQUES_TABLEAU_DE_BORD)
Calendrier calendrier = calendrierService.getCalendrierForEtablissement(
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
-
import org.lilie.services.eliot.absences.Motif
import org.lilie.services.eliot.temps.DateUtil
import org.lilie.services.eliot.export.DonneesPourExportCSV
import grails.converters.JSON
import org.lilie.services.eliot.absences.AbstractAbsencesController
import org.lilie.services.eliot.absences.export.AbsencesPreparationExportCSVService
-import org.lilie.services.eliot.absences.fonctionnalites.AbsencesFonctionnaliteAnc
import org.lilie.services.eliot.absences.page.Page
import org.lilie.services.eliot.absences.statistiques.Type
import org.lilie.services.eliot.annuaire.SecuriteSession
import java.text.SimpleDateFormat
import org.lilie.services.eliot.absences.statistiques.mensuelle.*
-
import org.lilie.services.eliot.absences.statistiques.StatsMarshallerService
import org.lilie.services.eliot.absences.statistiques.commons.NiveauDetail
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* @author bahj
Map modele
AppelLigne.withTransaction {
- verificationDroitFonctionnalite(
- AbsencesFonctionnalite.ABS_STATS
- )
+ verificationDroitFonctionnalite(AbsencesFonctionnalite.ABS_STATS)
// construction du modèle
modele = prepareBaseModele(Page.STATISTIQUE_TEMPS_REEL)
absences.menu.consultation.departs.titrePrincipal=Départs anticipés du jour
absences.menu.consultation.parParent.titrePrincipal=Absences, retards et départs anticipés
absences.menu.consultation.parEleve.titrePrincipal=Absences, retards et départs anticipés
+absences.menu.consultation.parEnseignant.titrePrincipal=Absences, retards et départs anticipés
absences.menu.consultation.internat.titrePrincipal=Internat
absences.menu.consultation.demiPension.titrePrincipal=Demi-pension
absences.menu.consultation.appelsoublies.titrePrincipal=Appels oubliés
absences.libelle.bulletin=Bulletin
absences.libelle.stat=Consult./Stat.
absences.libelle.selection=Sélection
-absences.libelle.total=Total
\ No newline at end of file
+absences.libelle.total=Total
+
+eliot.scolarite.menu.etablissements.titrePrincipal=Etablissements
\ No newline at end of file
import java.text.DecimalFormat
import org.lilie.services.eliot.absences.consultation.ResultatConsultation
import org.lilie.services.eliot.absences.consultation.LigneConsultation
+import org.lilie.services.eliot.absences.securite.DroitsService
/**
* Preparation des donnees pour l'export CSV
AbsencesSanctionService absencesSanctionService
AbsencesPunitionService absencesPunitionService
- AbsencesIncidentService absencesIncidentService
EleveRecupService eleveRecupService
+ DroitsService droitsService
AffichageIncidentService affichageIncidentService
private static final DecimalFormat DF = new DecimalFormat("###.##")
Punition punition = (Punition) donnees[0]
StructureEnseignement structureEnseignement =
- (StructureEnseignement) donnees[1]
+ (StructureEnseignement) donnees[1]
donneesPourExportCSV.lignes << [
punition.date,
// personne est seulement prof/docu
// si elle a une autre fonctionne qui est plus forte, elle gagne
Boolean personneIsEnseignant =
- securiteSession.hasFonctionIn(
- [
- FonctionEnum.ENSEIGNANT,
- FonctionEnum.DOCUMENTALISTE
- ],
- etablissement.id
- ) &&
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.DIRECTION,
- FonctionEnum.EDUCATION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id
- )
+ droitsService.isSeulementEnseignantOuDocumentatliste(
+ securiteSession,
+ etablissement
+ )
List<Autorite> eleves = []
if (personneIsEnseignant) {
eleves = eleveRecupService.
findAllEleveByEnseignantAndEtablissement(
- securiteSession,
- personne,
- etablissement)?.collect { it.autorite }
+ securiteSession,
+ personne,
+ etablissement)?.collect { it.autorite }
}
// fait la requête seulement si on n'est pas prof sans élèves
)
Map nomsAffichageByIdExterne =
- affichageIncidentService.getNomsAffichageByIdExterne(listeIncidents)
+ affichageIncidentService.getNomsAffichageByIdExterne(listeIncidents)
List<IncidentConsultationInfo> incidentsData =
- affichageIncidentService.getIncidentConsultationsInfos(
- listeIncidents.incidents,
- nomsAffichageByIdExterne
- )
+ affichageIncidentService.getIncidentConsultationsInfos(
+ listeIncidents.incidents,
+ nomsAffichageByIdExterne
+ )
donneesPourExportCSV.colonnes = [
'eliot.absences.export.absences.incident.date',
}
private List<List> listeLignesExportTableauDeBord(
- TableauDeBord tableauDeBord, String totauxTraduction) {
+ TableauDeBord tableauDeBord, String totauxTraduction) {
List<List> lignes = []
+++ /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.absences.menu
-
-import org.lilie.services.eliot.absences.fonctionnalites.AbsencesFonctionnaliteAnc
-import org.lilie.services.eliot.absences.page.Page
-import org.lilie.services.eliot.menu.EtablissementMenuItemInfo
-import org.lilie.services.eliot.menu.MenuInfo
-import org.lilie.services.eliot.menu.MenuItemInfo
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.absences.page.GroupePage
-import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.absences.AbsencesFonctionnalite
-
-/**
- * Permet d'obtenir les informations de construction du menu pour la session
- * HTTP courante
- * @author othe
- * @author bahj
- * @author ywan
- */
-class MenuService {
-
- DroitsService droitsService
-
- private final static String MENU_ITEM = 'menuitem'
-
- /**
- * Retourne les information de construction du menu
- * @param pageCourante la page courante
- * @param securiteSession la session de sécurité Eliot de l'utilisateur
- * @return
- */
- MenuInfo getMenuInfo(SecuriteSession securiteSession,
- Page pageCourante,
- Etablissement etablissementCourant) {
-
- HashSet fonctionnalitesAccessibles = droitsService.getFonctionnalitesAccessibles(
- securiteSession,
- etablissementCourant
- )
-
- MenuInfo menuInfo = new MenuInfo()
-
- // Saisie
- MenuItemInfo saisie = getMenuInfoSaisie(fonctionnalitesAccessibles, pageCourante)
- if (saisie) {menuInfo.items << saisie}
-
- // Consultation
- MenuItemInfo consultation = getMenuInfoConsultation(pageCourante, fonctionnalitesAccessibles)
- if (consultation) {menuInfo.items << consultation}
-
- // Statistiques
- MenuItemInfo statistiques = getMenuInfoStatistiques(pageCourante, fonctionnalitesAccessibles)
- if (statistiques) {menuInfo.items << statistiques}
-
- //paramétrage
- MenuItemInfo parametrage = getMenuInfoParametrage(fonctionnalitesAccessibles, pageCourante)
- if (parametrage) {menuInfo.items << parametrage}
-
- // Publipostage
- MenuItemInfo publipostage = getMenuInfoPublipostage(fonctionnalitesAccessibles, pageCourante)
- if (publipostage) {menuInfo.items << publipostage}
-
- MenuItemInfo menuEtab = new EtablissementMenuItemInfo(
- securiteSession,
- etablissementCourant,
- 'absences.menu.etablissement.titrePrincipal',
- pageCourante)
-
- if (!menuEtab.isEmpty()) {
- menuInfo.items << menuEtab
- }
- return menuInfo
- }
-
- private MenuItemInfo getMenuInfoPublipostage(HashSet fonctionnalitesAccessibles, Page pageCourante) {
-
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PUBLIPOSTAGE)) {
- MenuItemInfo publipostage = new MenuItemInfo(
- codeLabel: 'absences.menu.publipostage.titrePrincipal',
- menuType: MENU_ITEM,
- selectionne: (pageCourante?.groupePage == GroupePage.PUBLIPOSTAGE)
- )
-
- // Sélection
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PUBLIPOSTAGE)) {
- publipostage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.publipostage.selection.titrePrincipal',
- controleur: Page.PUBLIPOSTAGE_SELECTION.controllerName,
- action: Page.PUBLIPOSTAGE_SELECTION.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PUBLIPOSTAGE_SELECTION == pageCourante)
- )
- }
-
- // Suivi des impressions
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PUBLIPOSTAGE)) {
- publipostage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.publipostage.suiviImpression.titrePrincipal',
- controleur: Page.PUBLIPOSTAGE_SUIVI_IMPRESSION.controllerName,
- action: Page.PUBLIPOSTAGE_SUIVI_IMPRESSION.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PUBLIPOSTAGE_SUIVI_IMPRESSION == pageCourante)
- )
- }
-
- // Suivi par élève
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PUBLIPOSTAGE)) {
- publipostage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.publipostage.suiviParEleve.titrePrincipal',
- controleur: Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE.controllerName,
- action: Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE == pageCourante)
- )
- }
-
-
- return publipostage
- }
- return null
- }
-
- private MenuItemInfo getMenuInfoParametrage(HashSet fonctionnalitesAccessibles, Page pageCourante) {
- boolean menuParametrageVisible = (
- (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PARAM_MOTIFS)) ||
- (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN))
- )
-
- if (menuParametrageVisible) {
- MenuItemInfo parametrage = new MenuItemInfo(
- codeLabel: 'absences.menu.parametrages.titrePrincipal',
- menuType: MENU_ITEM,
- selectionne: (pageCourante?.groupePage == GroupePage.PARAMETRAGE)
- )
-
- // Paramétrage - Générals
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PARAM_GENERAUX)) {
- parametrage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.parametrages.general.titrePrincipal',
- controleur: Page.PARAMETRAGE_GENERAL.controllerName,
- action: Page.PARAMETRAGE_GENERAL.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PARAMETRAGE_GENERAL == pageCourante)
- )
- }
-
- // Paramétrage - Motifs
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PARAM_MOTIFS)) {
- parametrage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.parametrages.motif.titrePrincipal',
- controleur: Page.PARAMETRAGE_MOTIFS.controllerName,
- action: Page.PARAMETRAGE_MOTIFS.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PARAMETRAGE_MOTIFS == pageCourante)
- )
- }
-
- // Paramétrage - Incident, punition et sanction
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN)) {
- parametrage.items << new MenuItemInfo(
- codeLabel: 'absences.menu.parametrages.incidentPunitionSanction.titrePrincipal',
- controleur: Page.PARAMETRAGES_IPS.controllerName,
- action: Page.PARAMETRAGES_IPS.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.PARAMETRAGES_IPS == pageCourante)
- )
- }
- return parametrage
- }
- return null
- }
-
- private MenuItemInfo getMenuInfoStatistiques(Page pageCourante, HashSet fonctionnalitesAccessibles) {
- boolean menuStatistiquesVisible =
- (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_STATS
- )) || (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_STATS
- )) || (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_STATS
- ))
-
- if (menuStatistiquesVisible) {
-
- MenuItemInfo statistiques = new MenuItemInfo(
- codeLabel: 'absences.menu.statistiques.titrePrincipal',
- menuType: MENU_ITEM,
- selectionne: (pageCourante?.groupePage == GroupePage.STATISTIQUE)
- )
-
- // Tableau de bord
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_STATS)) {
- statistiques.items << new MenuItemInfo(
- codeLabel: 'absences.menu.statistiques.tableauDeBord.titrePrincipal',
- controleur: Page.STATISTIQUES_TABLEAU_DE_BORD.controllerName,
- action: Page.STATISTIQUES_TABLEAU_DE_BORD.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.STATISTIQUES_TABLEAU_DE_BORD == pageCourante)
- )
- }
-
- // Temps réel
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_STATS)) {
- statistiques.items << new MenuItemInfo(
- codeLabel: 'absences.menu.statistiques.tempsReel.titrePrincipal',
- controleur: Page.STATISTIQUE_TEMPS_REEL.controllerName,
- action: Page.STATISTIQUE_TEMPS_REEL.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.STATISTIQUE_TEMPS_REEL == pageCourante)
- )
- }
-
- // Statistiques hebdomadaires
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_STATS)) {
- statistiques.items << new MenuItemInfo(
- codeLabel: 'absences.menu.statistiques.hebdomadaire.titrePrincipal',
- controleur: Page.STATISTIQUES_HEBDOMADAIRE.controllerName,
- action: Page.STATISTIQUES_HEBDOMADAIRE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.STATISTIQUES_HEBDOMADAIRE == pageCourante)
- )
- }
-
- return statistiques
- }
- return null
- }
-
- private MenuItemInfo getMenuInfoConsultation(Page pageCourante, HashSet fonctionnalitesAccessibles) {
- if (
- fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT)
- ) {
- MenuItemInfo menuConsultation = new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.titrePrincipal',
- menuType: MENU_ITEM,
- selectionne: (pageCourante?.groupePage == GroupePage.CONSULTATION)
- )
-
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT)) {
- // Consultation multicritères
- menuConsultation.items << getMenuConsultationMulticritere(pageCourante)
-
- // Consultation absences du jour
- menuConsultation.items << getMenuConsultationAbsencesDuJour(pageCourante)
-
- // Consultation retards du jour
- menuConsultation.items << getMenuConsultationRetardsDuJour(pageCourante)
-
- // Consultation départs du jour
- menuConsultation.items << getMenuConsultationDepartsDuJour(pageCourante)
-
- // Consultation absence demi-pension
- menuConsultation.items << getMenuConsultationDemiPension(pageCourante)
-
- // Consultation absence d'internat
- menuConsultation.items << getMenuConsultationInternat(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT)) {
- menuConsultation.items << getMenuConsultationAppelsOublies(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT)) {
- menuConsultation.items << getMenuConsultationRegistreMensuel(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT_PARENT)) {
- // Consultation par parent
- menuConsultation.items << getMenuConsultationParParent(pageCourante)
- }
-
- // Consultation par élève
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT_ELEVE)) {
- menuConsultation.items << getMenuConsultationParEleve(pageCourante)
- }
-
- // Consultation par enseignant
- if (fonctionnalitesAccessibles.contains(AbsencesFonctionnalite.ABS_CONSULT_ENSEIGNANT)) {
- menuConsultation.items << getMenuConsultationParEnseignant(pageCourante)
- }
-
- return menuConsultation
- }
- return null
- }
-
- private MenuItemInfo getMenuConsultationMulticritere(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.multicriteres.titrePrincipal',
- controleur: Page.CONSULTATION_MULTICRITERES.controllerName,
- action: Page.CONSULTATION_MULTICRITERES.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_MULTICRITERES == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationAbsencesDuJour(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.absences.titrePrincipal',
- controleur: Page.CONSULTATION_ABSENCES_DU_JOUR.controllerName,
- action: Page.CONSULTATION_ABSENCES_DU_JOUR.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_ABSENCES_DU_JOUR == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationRetardsDuJour(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.retards.titrePrincipal',
- controleur: Page.CONSULTATION_RETARDS_DU_JOUR.controllerName,
- action: Page.CONSULTATION_RETARDS_DU_JOUR.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_RETARDS_DU_JOUR == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationDepartsDuJour(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.departs.titrePrincipal',
- controleur: Page.CONSULTATION_DEPARTS_DU_JOUR.controllerName,
- action: Page.CONSULTATION_DEPARTS_DU_JOUR.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_DEPARTS_DU_JOUR == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationDemiPension(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.demiPension.titrePrincipal',
- controleur: Page.CONSULTATION_DEMI_PENSION.controllerName,
- action: Page.CONSULTATION_DEMI_PENSION.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_DEMI_PENSION == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationInternat(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.internat.titrePrincipal',
- controleur: Page.CONSULTATION_INTERNAT.controllerName,
- action: Page.CONSULTATION_INTERNAT.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_INTERNAT == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationAppelsOublies(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.appelsoublies.titrePrincipal',
- controleur: Page.CONSULTATION_APPELS_OUBLIES.controllerName,
- action: Page.CONSULTATION_APPELS_OUBLIES.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_APPELS_OUBLIES == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationRegistreMensuel(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.registreMensuel.titrePrincipal',
- controleur: Page.CONSULTATION_REGISTRE_MENSUEL.controllerName,
- action: Page.CONSULTATION_REGISTRE_MENSUEL.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_REGISTRE_MENSUEL == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationParParent(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.parParent.titrePrincipal',
- controleur: Page.CONSULTATION_PAR_PARENT.controllerName,
- action: Page.CONSULTATION_PAR_PARENT.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_PAR_PARENT == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationParEleve(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.parEleve.titrePrincipal',
- controleur: Page.CONSULTATION_PAR_ELEVE.controllerName,
- action: Page.CONSULTATION_PAR_ELEVE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_PAR_ELEVE == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuConsultationParEnseignant(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menu.consultation.parEleve.titrePrincipal',
- controleur: Page.CONSULTATION_PAR_ENSEIGNANT.controllerName,
- action: Page.CONSULTATION_PAR_ENSEIGNANT.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.CONSULTATION_PAR_ENSEIGNANT == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuInfoSaisie(HashSet fonctionnalitesAccessibles, Page pageCourante) {
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_APPELS) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT) ||
- fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT)
- ) {
- return creeMenuSaisie(pageCourante, fonctionnalitesAccessibles)
- } else {
- return null
- }
- }
-
- private creeMenuSaisie(Page pageCourante, HashSet fonctionnalitesAccessibles) {
- MenuItemInfo menuSaisie = new MenuItemInfo(
- codeLabel: 'absences.menu.saisie.titrePrincipal',
- menuType: MENU_ITEM,
- selectionne: (pageCourante?.groupePage == GroupePage.SAISIE)
- )
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_APPELS
- )) {
- // Saisie des absences par CPE /Directeur
- menuSaisie.items << getMenuSaisieCPE(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE
- )) {
- // Saisie des absences par prof
- menuSaisie.items << getMenuSaisieProf(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS
- )) {
-
- // Saisie absences hebdomadaires
- menuSaisie.items << getMenuSaisieHebdoParClasse(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS
- )) {
-
- // Saisie absences hebdomadaires
- menuSaisie.items << getMenuSaisieHebdoParEleve(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS
- )) {
-
- // Saisie collective
- menuSaisie.items << getMenuSaisieCollective(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnaliteAnc.SAISIE_DISPENSES
- )) {
-
- // Saisie dispenses
- menuSaisie.items << getMenuSaisieDispenses(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT
- )) {
-
- // Saisie des demi-pensions
- menuSaisie.items << getMenuSaisieDemiPension(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnaliteAnc.SAISIE_INTERNAT
- )) {
-
- // Saisie internat
- menuSaisie.items << getMenuSaisieInternat(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
- )) {
- // Consultation/saisie des incidents
- menuSaisie.items << getMenuSaisieIncident(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
- )) {
-
- // Consultation/saisie des punitions
- menuSaisie.items << getMenuSaisiePunitions(pageCourante)
- }
-
- if (fonctionnalitesAccessibles.contains(
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
- )) {
-
- // Consultation/saisie des sanctions
- menuSaisie.items << getMenuSaisieSanctions(pageCourante)
- }
- return menuSaisie
- }
-
- private MenuItemInfo getMenuSaisieSanctions(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.sanctions.titrePrincipal',
- controleur: Page.SAISIE_SANCTIONS.controllerName,
- action: Page.SAISIE_SANCTIONS.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_SANCTIONS == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisiePunitions(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.punitions.titrePrincipal',
- controleur: Page.SAISIE_PUNITIONS.controllerName,
- action: Page.SAISIE_PUNITIONS.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_PUNITIONS == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieIncident(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.incidents.titrePrincipal',
- controleur: Page.SAISIE_INCIDENTS.controllerName,
- action: Page.SAISIE_INCIDENTS.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_INCIDENTS == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieInternat(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.internat.titrePrincipal',
- controleur: Page.SAISIE_INTERNAT.controllerName,
- action: Page.SAISIE_INTERNAT.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_INTERNAT == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieDemiPension(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.demiPension.titrePrincipal',
- controleur: Page.SAISIE_DEMI_PENSION.controllerName,
- action: Page.SAISIE_DEMI_PENSION.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_DEMI_PENSION == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieHebdoParClasse(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.hebdomadaires.parClasse.titrePrincipal',
- controleur: Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE.controllerName,
- action: Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieHebdoParEleve(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.hebdomadaires.parEeleve.titrePrincipal',
- controleur: Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE.controllerName,
- action: Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieDispenses(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.dispenses.titrePrincipal',
- controleur: Page.SAISIE_DISPENSES.controllerName,
- action: Page.SAISIE_DISPENSES.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_DISPENSES == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieCollective(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.collective.titrePrincipal',
- controleur: Page.SAISIE_COLLECTIVE.controllerName,
- action: Page.SAISIE_COLLECTIVE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_COLLECTIVE == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieProf(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.absences.prof.titrePrincipal',
- controleur: Page.SAISIE_ABSENCES_PROF.controllerName,
- action: Page.SAISIE_ABSENCES_PROF.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_ABSENCES_PROF == pageCourante)
- )
- }
-
- private MenuItemInfo getMenuSaisieCPE(Page pageCourante) {
- return new MenuItemInfo(
- codeLabel: 'absences.menuActions.Saisie.absences.cpe.titrePrincipal',
- controleur: Page.SAISIE_ABSENCES_CPE.controllerName,
- action: Page.SAISIE_ABSENCES_CPE.actionName,
- menuType: MENU_ITEM,
- selectionne: (Page.SAISIE_ABSENCES_CPE == pageCourante)
- )
- }
-
-}
\ 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.absences.menu.description
+
+import org.lilie.services.eliot.menu.Entete
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.absences.page.GroupePage
+import org.lilie.services.eliot.menu.MenuEtablissement
+
+/**
+ *
+ * @author othe
+ */
+public enum MenuEntete implements Entete {
+
+ SAISIE(
+ 'absences.menu.saisie.titrePrincipal',
+ '',
+ '',
+ '',
+ GroupePage.SAISIE,
+ AbsencesFonctionnalite.ABS_SAISIE
+ ),
+
+ CONSULTATION(
+ 'absences.menu.consultation.titrePrincipal',
+ '',
+ '',
+ '',
+ GroupePage.CONSULTATION,
+ AbsencesFonctionnalite.ABS_CONSULT
+ ),
+
+ STATS(
+ 'absences.menu.statistiques.titrePrincipal',
+ '',
+ '',
+ '',
+ GroupePage.STATISTIQUE,
+ AbsencesFonctionnalite.ABS_STATS
+ ),
+
+
+ PARAMETRAGE(
+ 'absences.menu.parametrages.titrePrincipal',
+ '',
+ '',
+ '',
+ GroupePage.PARAMETRAGE,
+ AbsencesFonctionnalite.ABS_PARAM
+
+ ),
+
+ PUBLIPOSTAGE(
+ 'absences.menu.publipostage.titrePrincipal',
+ '',
+ '',
+ '',
+ GroupePage.PUBLIPOSTAGE,
+ AbsencesFonctionnalite.ABS_PUBLIPOSTAGE
+
+ ),
+
+ ETABLISSEMENT(
+ '',
+ '',
+ '',
+ '',
+ null,
+ AbsencesFonctionnalite.ETABLISSEMENT,
+ MenuEtablissement
+ )
+
+
+
+ public String codeLabel
+ public String controleur
+ public String action
+ public String menuType
+ public Object page
+ public EliotFonctionnalites fonctionnalite
+ public Class menuSpecial
+
+ private MenuEntete() {}
+
+ private MenuEntete(String codeLabel,
+ String controleur,
+ String action,
+ String menuType,
+ Object page,
+ EliotFonctionnalites fonctionnalite,
+ Class menuSpecial = null) {
+ this.codeLabel = codeLabel
+ this.controleur = controleur
+ this.action = action
+ this.menuType = menuType
+ this.page = page
+ this.fonctionnalite = fonctionnalite
+ this.menuSpecial = menuSpecial
+ }
+
+}
\ 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.absences.menu.description
+
+import org.lilie.services.eliot.menu.SousMenu
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.absences.page.Page
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.absences.menu.special.SousMenuConsult
+import org.lilie.services.eliot.absences.menu.special.SousMenuSaisieEnseignant
+
+
+/**
+ *
+ * @author othe
+ * TOREFACT : (othe) Ramener la notion d'accessiblité au niveau de la Page,
+ * TOREFACT : supprimer les références controlleur/action/fonctionnalité des MenuSousMenu
+ */
+public enum MenuSousMenu implements SousMenu {
+
+ SAISIE_CPE(
+ 'absences.menuActions.Saisie.absences.cpe.titrePrincipal',
+ Page.SAISIE_ABSENCES_CPE.controllerName,
+ Page.SAISIE_ABSENCES_CPE.actionName,
+ Page.SAISIE_ABSENCES_CPE,
+ AbsencesFonctionnalite.ABS_SAISIE_APPELS,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_PROF(
+ 'absences.menuActions.Saisie.absences.prof.titrePrincipal',
+ Page.SAISIE_ABSENCES_PROF.controllerName,
+ Page.SAISIE_ABSENCES_PROF.actionName,
+ Page.SAISIE_ABSENCES_PROF,
+ AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE,
+ MenuEntete.SAISIE,
+ SousMenuSaisieEnseignant
+ ),
+
+ SAISIE_HEBDO_PAR_CLASSE(
+ 'absences.menuActions.Saisie.hebdomadaires.parClasse.titrePrincipal',
+ Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE.controllerName,
+ Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE.actionName,
+ Page.SAISIE_HEBDOMADAIRE_PAR_CLASSE,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_HEBDO_PAR_ELEVE(
+ 'absences.menuActions.Saisie.hebdomadaires.parEeleve.titrePrincipal',
+ Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE.controllerName,
+ Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE.actionName,
+ Page.SAISIE_HEBDOMADAIRE_PAR_ELEVE,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_COLLECTIVE(
+ 'absences.menuActions.Saisie.collective.titrePrincipal',
+ Page.SAISIE_COLLECTIVE.controllerName,
+ Page.SAISIE_COLLECTIVE.actionName,
+ Page.SAISIE_COLLECTIVE,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_DISPENSE(
+ 'absences.menuActions.Saisie.dispenses.titrePrincipal',
+ Page.SAISIE_DISPENSES.controllerName,
+ Page.SAISIE_DISPENSES.actionName,
+ Page.SAISIE_DISPENSES,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_DEMI_PENSION_INTERNAT(
+ 'absences.menuActions.Saisie.demiPension.titrePrincipal',
+ Page.SAISIE_DEMI_PENSION.controllerName,
+ Page.SAISIE_DEMI_PENSION.actionName,
+ Page.SAISIE_DEMI_PENSION,
+ AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_INCIDENTS(
+ 'absences.menuActions.Saisie.incidents.titrePrincipal',
+ Page.SAISIE_INCIDENTS.controllerName,
+ Page.SAISIE_INCIDENTS.actionName,
+ Page.SAISIE_INCIDENTS,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_PUNITIONS(
+ 'absences.menuActions.Saisie.punitions.titrePrincipal',
+ Page.SAISIE_PUNITIONS.controllerName,
+ Page.SAISIE_PUNITIONS.actionName,
+ Page.SAISIE_PUNITIONS,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN,
+ MenuEntete.SAISIE
+ ),
+
+ SAISIE_SANCTIONS(
+ 'absences.menuActions.Saisie.sanctions.titrePrincipal',
+ Page.SAISIE_SANCTIONS.controllerName,
+ Page.SAISIE_SANCTIONS.actionName,
+ Page.SAISIE_SANCTIONS,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN,
+ MenuEntete.SAISIE
+ ),
+
+ CONSULTATION_MULTICRITERES(
+ 'absences.menu.consultation.multicriteres.titrePrincipal',
+ Page.CONSULTATION_MULTICRITERES.controllerName,
+ Page.CONSULTATION_MULTICRITERES.actionName,
+ Page.CONSULTATION_MULTICRITERES,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_ABSENCES_DU_JOUR(
+ 'absences.menu.consultation.absences.titrePrincipal',
+ Page.CONSULTATION_ABSENCES_DU_JOUR.controllerName,
+ Page.CONSULTATION_ABSENCES_DU_JOUR.actionName,
+ Page.CONSULTATION_ABSENCES_DU_JOUR,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_RETARDS_DU_JOUR(
+ 'absences.menu.consultation.retards.titrePrincipal',
+ Page.CONSULTATION_RETARDS_DU_JOUR.controllerName,
+ Page.CONSULTATION_RETARDS_DU_JOUR.actionName,
+ Page.CONSULTATION_RETARDS_DU_JOUR,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_DEPARTS_DU_JOUR(
+ 'absences.menu.consultation.departs.titrePrincipal',
+ Page.CONSULTATION_DEPARTS_DU_JOUR.controllerName,
+ Page.CONSULTATION_DEPARTS_DU_JOUR.actionName,
+ Page.CONSULTATION_DEPARTS_DU_JOUR,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_DEMI_PENSION(
+ 'absences.menu.consultation.demiPension.titrePrincipal',
+ Page.CONSULTATION_DEMI_PENSION.controllerName,
+ Page.CONSULTATION_DEMI_PENSION.actionName,
+ Page.CONSULTATION_DEMI_PENSION,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_INTERNAT(
+ 'absences.menu.consultation.internat.titrePrincipal',
+ Page.CONSULTATION_INTERNAT.controllerName,
+ Page.CONSULTATION_INTERNAT.actionName,
+ Page.CONSULTATION_INTERNAT,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_APPELS_OUBLIES(
+ 'absences.menu.consultation.appelsoublies.titrePrincipal',
+ Page.CONSULTATION_APPELS_OUBLIES.controllerName,
+ Page.CONSULTATION_APPELS_OUBLIES.actionName,
+ Page.CONSULTATION_APPELS_OUBLIES,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_REGISTRE_MENSUEL(
+ 'absences.menu.consultation.registreMensuel.titrePrincipal',
+ Page.CONSULTATION_REGISTRE_MENSUEL.controllerName,
+ Page.CONSULTATION_REGISTRE_MENSUEL.actionName,
+ Page.CONSULTATION_REGISTRE_MENSUEL,
+ AbsencesFonctionnalite.ABS_CONSULT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ ABS_CONSULT_PARENT(
+ 'absences.menu.consultation.parParent.titrePrincipal',
+ Page.CONSULTATION_PAR_PARENT.controllerName,
+ Page.CONSULTATION_PAR_PARENT.actionName,
+ Page.CONSULTATION_PAR_PARENT,
+ AbsencesFonctionnalite.ABS_CONSULT_PARENT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ ABS_CONSULT_ELEVE(
+ 'absences.menu.consultation.parEleve.titrePrincipal',
+ Page.CONSULTATION_PAR_ELEVE.controllerName,
+ Page.CONSULTATION_PAR_ELEVE.actionName,
+ Page.CONSULTATION_PAR_ELEVE,
+ AbsencesFonctionnalite.ABS_CONSULT_ELEVE,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ CONSULTATION_PAR_ENSEIGNANT(
+ 'absences.menu.consultation.parEnseignant.titrePrincipal',
+ Page.CONSULTATION_PAR_ENSEIGNANT.controllerName,
+ Page.CONSULTATION_PAR_ENSEIGNANT.actionName,
+ Page.CONSULTATION_PAR_ENSEIGNANT,
+ AbsencesFonctionnalite.ABS_CONSULT_ENSEIGNANT,
+ MenuEntete.CONSULTATION,
+ SousMenuConsult
+ ),
+
+ STATISTIQUES_TABLEAU_DE_BORD(
+ 'absences.menu.statistiques.tableauDeBord.titrePrincipal',
+ Page.STATISTIQUES_TABLEAU_DE_BORD.controllerName,
+ Page.STATISTIQUES_TABLEAU_DE_BORD.actionName,
+ Page.STATISTIQUES_TABLEAU_DE_BORD,
+ AbsencesFonctionnalite.ABS_STATS,
+ MenuEntete.STATS
+ ),
+
+ STATISTIQUE_TEMPS_REEL(
+ 'absences.menu.statistiques.tempsReel.titrePrincipal',
+ Page.STATISTIQUE_TEMPS_REEL.controllerName,
+ Page.STATISTIQUE_TEMPS_REEL.actionName,
+ Page.STATISTIQUE_TEMPS_REEL,
+ AbsencesFonctionnalite.ABS_STATS,
+ MenuEntete.STATS
+ ),
+
+ STATISTIQUES_HEBDOMADAIRE(
+ 'absences.menu.statistiques.hebdomadaire.titrePrincipal',
+ Page.STATISTIQUES_HEBDOMADAIRE.controllerName,
+ Page.STATISTIQUES_HEBDOMADAIRE.actionName,
+ Page.STATISTIQUES_HEBDOMADAIRE,
+ AbsencesFonctionnalite.ABS_STATS,
+ MenuEntete.STATS
+ ),
+
+ ABS_PARAM_GENERAUX(
+ 'absences.menu.parametrages.general.titrePrincipal',
+ Page.PARAMETRAGE_GENERAL.controllerName,
+ Page.PARAMETRAGE_GENERAL.actionName,
+ Page.PARAMETRAGE_GENERAL,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX,
+ MenuEntete.PARAMETRAGE
+ ),
+
+ ABS_PARAM_MOTIFS(
+ 'absences.menu.parametrages.motif.titrePrincipal',
+ Page.PARAMETRAGE_MOTIFS.controllerName,
+ Page.PARAMETRAGE_MOTIFS.actionName,
+ Page.PARAMETRAGE_MOTIFS,
+ AbsencesFonctionnalite.ABS_PARAM_MOTIFS,
+ MenuEntete.PARAMETRAGE
+ ),
+
+ PARAMETRAGES_IPS(
+ 'absences.menu.parametrages.incidentPunitionSanction.titrePrincipal',
+ Page.PARAMETRAGES_IPS.controllerName,
+ Page.PARAMETRAGES_IPS.actionName,
+ Page.PARAMETRAGES_IPS,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN,
+ MenuEntete.PARAMETRAGE
+ ),
+
+
+ PUBLIPOSTAGE_SELECTION(
+ 'absences.menu.publipostage.selection.titrePrincipal',
+ Page.PUBLIPOSTAGE_SELECTION.controllerName,
+ Page.PUBLIPOSTAGE_SELECTION.actionName,
+ Page.PUBLIPOSTAGE_SELECTION,
+ AbsencesFonctionnalite.ABS_PUBLIPOSTAGE,
+ MenuEntete.PUBLIPOSTAGE
+ ),
+
+ PUBLIPOSTAGE_SUIVI_IMPRESSION(
+ 'absences.menu.publipostage.suiviImpression.titrePrincipal',
+ Page.PUBLIPOSTAGE_SUIVI_IMPRESSION.controllerName,
+ Page.PUBLIPOSTAGE_SUIVI_IMPRESSION.actionName,
+ Page.PUBLIPOSTAGE_SUIVI_IMPRESSION,
+ AbsencesFonctionnalite.ABS_PUBLIPOSTAGE,
+ MenuEntete.PUBLIPOSTAGE
+ ),
+
+ PUBLIPOSTAGE_SUIVI_PAR_ELEVE(
+ 'absences.menu.publipostage.suiviParEleve.titrePrincipal',
+ Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE.controllerName,
+ Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE.actionName,
+ Page.PUBLIPOSTAGE_SUIVI_PAR_ELEVE,
+ AbsencesFonctionnalite.ABS_PUBLIPOSTAGE,
+ MenuEntete.PUBLIPOSTAGE
+ )
+
+ public String codeLabel
+ public String controleur
+ public String action
+ public Object page
+ public EliotFonctionnalites fonctionnalite
+ public MenuEntete menuEnteteEnum
+ public Class menuSpecial
+
+ private MenuSousMenu() {}
+
+ private MenuSousMenu(String codeLabel,
+ String controleur,
+ String action,
+ Object page,
+ EliotFonctionnalites fonctionnalite,
+ MenuEntete menuEnteteEnum,
+ Class menuSpecial = null
+ ) {
+ this.codeLabel = codeLabel
+ this.controleur = controleur
+ this.action = action
+ this.page = page
+ this.fonctionnalite = fonctionnalite
+ this.menuEnteteEnum = menuEnteteEnum
+ this.menuSpecial = menuSpecial
+ }
+
+}
\ 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.absences.menu.special
+
+import org.lilie.services.eliot.menu.SousMenuNormal
+import org.lilie.services.eliot.absences.page.Page
+import org.lilie.services.eliot.annuaire.FonctionEnum
+
+/**
+ *
+ * @author othe
+ */
+class SousMenuConsult extends SousMenuNormal {
+
+ public Boolean autoriseAjoutElementMenu() {
+
+ Boolean estEleve = securiteSession.hasFonctionIn([FonctionEnum.ELEVE])
+ Boolean estParent = securiteSession.hasFonctionIn([FonctionEnum.PERS_REL_ELEVE])
+ Boolean estEnseignant = securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT])
+ Boolean estDirecteur = securiteSession.hasFonctionIn([FonctionEnum.DIRECTION])
+
+ Boolean estFonctionNonParametrable = estEleve || estParent || estEnseignant
+
+ switch (menuItemInfoEnum.page) {
+
+ case Page.CONSULTATION_PAR_ELEVE:
+
+ return estEleve
+
+ break
+
+ case Page.CONSULTATION_PAR_PARENT:
+
+ return estParent
+
+ break
+
+ case Page.CONSULTATION_PAR_ENSEIGNANT:
+
+ return estEnseignant
+
+ break
+
+ default:
+
+ if (estFonctionNonParametrable) {
+ return estDirecteur
+ }
+
+ return true
+ }
+
+ }
+
+
+}
* <http://www.cecill.info/licences.fr.html>.
*/
-package org.lilie.services.eliot.scolarite.fonctionnalites
-
-import org.lilie.services.eliot.fonctionnalites.EliotFonctionnalite
-
-public enum ScolariteFonctionnalite implements EliotFonctionnalite {
- PARAMETRAGE_ACCES_FONCTIONS,
- PARAMETRAGE_NIVEAU,
- PARAMETRAGE_MATIERES,
- PARAMETRAGE_CALENDRIER_HEBDO,
- PARAMETRAGE_CALENDRIER_ANNUEL,
- PARAMETRAGE_MODELE_DOCUMENT,
- PARAMETRAGE_LIAISON_SSO_VIE_SCOLAIRE,
- PARAMETRAGE_LIAISON_SSO_MAGISTER,
- PARAMETRAGE_TYPES_ACTIVITES_DEVOIRS,
- PARAMETRAGE_NOTIFICATION,
- SYNCHRO_EDT,
- VIE_SCOLAIRE,
- MAGISTERE,
- NOTIFICATION_PREFERNCE_UTILISATEUR
-}
\ No newline at end of file
+package org.lilie.services.eliot.absences.menu.special
+
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.menu.SousMenuNormal
+
+/**
+ *
+ * @author othe
+ */
+class SousMenuSaisieEnseignant extends SousMenuNormal {
+
+ public Boolean autoriseAjoutElementMenu() {
+
+ securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT])
+
+ }
+
+
+}
import org.lilie.services.eliot.absences.securite.DroitsService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.absences.TauxAbsencesCalculMode
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class AbsencesGeneralService extends GeneralService {
PreferencesEtablissementAbsences preferences
) {
// Vérifie les droits de consultation
- droitsService.verifieDroitsConsultationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
return preferences.autoriseSaisieHorsEdt
}
Boolean autoriseSaisieHorsEdt
) {
// Vérifie les droits de modification
- droitsService.verifieDroitsConsultationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
preferences.autoriseSaisieHorsEdt = autoriseSaisieHorsEdt
int codePasDeDecompte
) {
// Vérifie les droits de modification
- droitsService.verifieDroitsModificationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
PasDeDecompteEnum pas = PasDeDecompteEnum.parseByCode(
PreferencesEtablissementAbsences preferences,
int codeLongueur) {
// Vérifie les droits de modification
- droitsService.verifieDroitsModificationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
switch (codeLongueur) {
String tauxAbsencesCalculMode) {
// Vérifie les droits de modification
- droitsService.verifieDroitsModificationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
try {
Boolean affichageEdt
) {
// Vérifie les droits de modification
- droitsService.verifieDroitsConsultationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
preferences.affichageEdt = affichageEdt
PreferencesEtablissementAbsences preferences
) {
// Vérifie les droits de consultation
- droitsService.verifieDroitsConsultationParametragesGeneral(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- preferences
+ preferences.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_GENERAUX
)
return preferences.affichageEdt
}
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe qui contient les fonctions de manipulation de type d'incident
CreationContraintException {
// Vérification des droits de création de type d'incident
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- pref
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreeTypeIncident(pref, libelle)
SuppressionContraintException {
// Vérifie les droits de supprission
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
LibelleLongException,
CreationContraintException {
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifieTypeIncident(type, libelle)
import org.lilie.services.eliot.absences.TypePunition
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe sui contient les fonctions de manipulation de type de punition
CreationContraintException {
// Vérification des droits de création
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- pref
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreeTypePunition(pref, libelle)
SuppressionContraintException {
// Vérifie les droits de supprission
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
CreationContraintException {
// Vérifie les droits
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifieTypePunition(type, libelle)
import org.lilie.services.eliot.absences.TypeSanction
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe sui contient les fonctions de manipulation de type de sanction
CreationContraintException {
// Vérification des droits de création
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- pref
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreeTypeSanction(pref, libelle)
SuppressionContraintException {
// Vérifie les droits de supprission
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
CreationContraintException {
// vérifie les droits de modification
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
+ droitsService.verifieDroitFonctionnalite(
securiteSession,
- type.preferencesEtablissement
+ type.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifieTypeSanction(type, libelle)
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.GormUtils
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe qui contient les fonctions de manipulation des lieux d'incident
CreationContraintException {
// Vérification des droits de création
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- pref
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreeLieuIncident(pref, libelle)
SuppressionContraintException {
// Vérifie les droits de supprission
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
- securiteSession,
- lieu.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ lieu.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
LibelleLongException,
CreationContraintException {
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- lieu.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ lieu.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifieLieuIncident(lieu, libelle)
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.GormUtils
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe qui contient les fonctions de manipulation des partenaire à prévenir
PreferencesEtablissementAbsences pref,
String libelle
) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
+ LibelleLongException,
+ CreationContraintException {
// Vérification des droits de création
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- pref
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreePartenaireAPrevenir(pref, libelle)
}
private PartenaireAPrevenir internalCreePartenaireAPrevenir(
- PreferencesEtablissementAbsences pref,
- String libelle
+ PreferencesEtablissementAbsences pref,
+ String libelle
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
PartenaireAPrevenir partenaire = new PartenaireAPrevenir(
- preferencesEtablissement: pref,
- libelle: libelle
+ preferencesEtablissement: pref,
+ libelle: libelle
)
save(partenaire)
void supprimePartenaireAPrevenir(SecuriteSession securiteSession,
PartenaireAPrevenir partenaire
) throws AutorisationException,
- SuppressionContraintException {
+ SuppressionContraintException {
// Vérifie les droits de suppression
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
- securiteSession,
- partenaire.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ partenaire.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
PartenaireAPrevenir partenaire,
String libelle
) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
+ LibelleLongException,
+ CreationContraintException {
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- partenaire.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ partenaire.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifiePartenaireAPrevenir(partenaire, libelle)
* @return partenaire le partenaire à prévenir modifiée
*/
PartenaireAPrevenir internalModifiePartenaireAPrevenir(
- PartenaireAPrevenir partenaire,
- String libelle
+ PartenaireAPrevenir partenaire,
+ String libelle
)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
partenaire.libelle = libelle
save(partenaire)
*/
void save(PartenaireAPrevenir partenaire)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
// Validation du nombre de caractères [max 30]
if (!partenaire.validate(["libelle"])) {
* @return partenaire : la liste des partenaires à prévenir
*/
List<PartenaireAPrevenir> getParteniresAPrevenir(
- PreferencesEtablissementAbsences pref
+ PreferencesEtablissementAbsences pref
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
List<PartenaireAPrevenir> partenaires = PartenaireAPrevenir.withCriteria {
eq('preferencesEtablissement.id', pref.id)
}
private List<PartenaireAPrevenir> creePartenairesAPrevenirParDefaut(
- PreferencesEtablissementAbsences pref
+ PreferencesEtablissementAbsences pref
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
List<PartenaireAPrevenir> partenaires = []
- for (DefaultsPartenaireAPrevenir partenir: DefaultsPartenaireAPrevenir.values()) {
+ for (DefaultsPartenaireAPrevenir partenir : DefaultsPartenaireAPrevenir.values()) {
partenaires.add(getPartenirAPrevenir(pref,
- messageSource.getMessage(partenir.libelle, null, null))
+ messageSource.getMessage(partenir.libelle, null, null))
)
}
String libelle)
throws LibelleLongException, CreationContraintException {
PartenaireAPrevenir partenaire = PartenaireAPrevenir.
- findByLibelleAndPreferencesEtablissement(libelle, pref)
+ findByLibelleAndPreferencesEtablissement(libelle, pref)
if (partenaire != null) {
return partenaire
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.SuppressionContraintException
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.GormUtils
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe qui contient les fonctions de manipulation de qualité de protagoniste
CreationContraintException {
// Vérification des droits de création
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- pref
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ pref.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalCreeQualiteProtagoniste(pref, libelle)
SuppressionContraintException {
// Vérifie les droits de supprission
- droitsService.verifieDroitsSupprissionIncidentsPunitionsSanctions(
- securiteSession,
- protagoniste.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ protagoniste.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
try {
LibelleLongException,
CreationContraintException {
- droitsService.verifieDroitsCreationModificationIncidentsPunitionsSanctions(
- securiteSession,
- protagoniste.preferencesEtablissement
+ droitsService.verifieDroitFonctionnalite(
+ securiteSession,
+ protagoniste.preferencesEtablissement.etablissement,
+ AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
)
return internalModifieQualiteProtagoniste(protagoniste, libelle)
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneService
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class AbsenceJourneeService {
SecuriteSession securiteSession,
AbsenceJourneeParams params) throws AutorisationException {
List<AbsenceJourneeLigneInfo> result = []
- droitsService.verifieDroitsCRUDAbsenceJournee(
+
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- params.etablissement
+ params.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS
)
//on régularise l'heure à 0:00
params.date = AbsencesDateUtil.getDay(params.date)
*/
public void supprimeAppel(SecuriteSession securiteSession, Long appelId) {
Appel appel = getAppel(appelId)
- if (droitsService.verifieDroitAvecAppel(securiteSession, appel)) {
+ if (droitsService.verifieDroitEcritureAppel(securiteSession, appel)) {
// normalement la cascade doit effacer le détail
appel.delete()
}
)
}
- if (!droitsService.verifieDroitAvecAppel(securiteSession, appel)) {
+ if (!droitsService.verifieDroitEcritureAppel(securiteSession, appel)) {
throw AutorisationException.modificationContenuException()
}
*/
public AppelAvecLignesInfo lisAppel(SecuriteSession securiteSession, Long appelId) {
Appel appel = getAppel(appelId)
- if (droitsService.verifieDroitAvecAppel(securiteSession, appel)) {
+ if (droitsService.verifieDroitEcritureAppel(securiteSession, appel)) {
return getAppelAvecLignesInfoFromAppel(appel)
}
else {
private List<Autorite> getListeAutoriteEleves(
StructureEnseignement structureEnseignement, SecuriteSession securiteSession) {
- // bahj : Il faudrait faire le tri alphabétique sur la requête
+
List<Personne> personnesEleve = eleveAnnuaireService.findAllEleveByStructureEnseignement(
securiteSession,
structureEnseignement
import org.lilie.services.eliot.temps.Evenement
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneService
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class DemiPensionInternatService {
) throws AutorisationException {
// Vérifie les droits
- droitsService.verifieDroitsCRUDDemiPensionInternat(
- securiteSession,
- params.etablissement
+ droitsService.verifieDroitModificationFonctionnalite(
+ securiteSession,
+ params.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT
)
// On régularise l'heure à 0:00
params.date = AbsencesDateUtil.getDay(params.date)
AbsenceJournee absenceJournee = absenceJourneeService.findOrCreateAbsenceJournee(
- params.etablissement,
- params.date,
- preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(params.etablissement)
+ params.etablissement,
+ params.date,
+ preferencesEtablissementAbsencesService.
+ getPreferencesEtablissementForEtablissement(params.etablissement)
)
return internalCreeAbsences(params, absenceJournee)
) throws AutorisationException {
// Vérifie les droits
- droitsService.verifieDroitsCRUDDemiPensionInternat(
- securiteSession,
- etablissement
+ droitsService.verifieDroitModificationFonctionnalite(
+ securiteSession,
+ etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT
)
return internalModifieAbsences(lignes)
) throws AutorisationException {
// Vérifie les droits
- droitsService.verifieDroitsCRUDDemiPensionInternat(
- securiteSession,
- etablissement
+ droitsService.verifieDroitModificationFonctionnalite(
+ securiteSession,
+ etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_DEMI_PENSION_INTERNAT
)
internalSupprimeAbsences(idsAppelLignes)
List<Personne> eleves
if (isDemiPension) {
eleves = localStructureEnseignementService.findAllPersonnesElevesForStructureAndRegime(
- structure, [RegimeEnum.DEMI_PENSION, RegimeEnum.INTERNAT]
+ structure, [RegimeEnum.DEMI_PENSION, RegimeEnum.INTERNAT]
)
} else {
eleves = localStructureEnseignementService.findAllPersonnesElevesForStructureAndRegime(
- structure, [RegimeEnum.INTERNAT]
+ structure, [RegimeEnum.INTERNAT]
)
}
List<Evenement> jourFeries = calendrierService.
- getEvenementsJoursFeriesEntreDatesPourEtab(date, date, etablissement)
+ getEvenementsJoursFeriesEntreDatesPourEtab(date, date, etablissement)
if ((jourFeries.size() == 1) && (jourFeries[0].touteLaJournee)) {
eleves.each { Personne eleve ->
resultats << new SaisieDemiPensionInternatInfo(
- eleveId: eleve.id,
- nom: eleve.nomAffichage(),
- absence: new EleveAbsenceInfo(
- jourOuvert: false
- )
+ eleveId: eleve.id,
+ nom: eleve.nomAffichage(),
+ absence: new EleveAbsenceInfo(
+ jourOuvert: false
+ )
)
}
} else {
if (eleves.size() > 0) {
appelLignes = AppelLigne.executeQuery(
- appelLignesPensionsHql,
- [
- autorites: eleves*.autorite,
- date: AbsencesDateUtil.getDay(date),
- demiPension: isDemiPension,
- internat: !isDemiPension
- ]
+ appelLignesPensionsHql,
+ [
+ autorites: eleves*.autorite,
+ date: AbsencesDateUtil.getDay(date),
+ demiPension: isDemiPension,
+ internat: !isDemiPension
+ ]
)
}
}
resultats << new SaisieDemiPensionInternatInfo(
- eleveId: eleve.id,
- nom: eleve.nomAffichage(),
- absence: ligne ?
- new EleveAbsenceInfo(
- appelLigneId: ligne.id,
- motifId: ligne.motif.id,
- couleur: ligne.motif.couleur
- ) :
- new EleveAbsenceInfo()
+ eleveId: eleve.id,
+ nom: eleve.nomAffichage(),
+ absence: ligne ?
+ new EleveAbsenceInfo(
+ appelLigneId: ligne.id,
+ motifId: ligne.motif.id,
+ couleur: ligne.motif.couleur
+ ) :
+ new EleveAbsenceInfo()
)
}
}
params.lignes.each { DemiPensionInternatLigneParams ligne ->
AppelLigne appelLigne = new AppelLigne(
- presence: false,
- absenceJustifiee: true,
- demiPension: params.demiPension,
- internat: params.internat,
- motif: ligne.motif,
- autorite: ligne.eleve.autorite,
- operateurSaisie: params.operateurSaisie.autorite,
- dateSaisie: params.date,
- absenceJournee: absenceJournee
+ presence: false,
+ absenceJustifiee: true,
+ demiPension: params.demiPension,
+ internat: params.internat,
+ motif: ligne.motif,
+ autorite: ligne.eleve.autorite,
+ operateurSaisie: params.operateurSaisie.autorite,
+ dateSaisie: params.date,
+ absenceJournee: absenceJournee
)
appelLigne = appelLigneService.enregistreAppelLigne(appelLigne, false)
import org.lilie.services.eliot.absences.saisie.discipline.punition.AbsencesPunitionService
import org.lilie.services.eliot.absences.saisie.discipline.sanction.AbsencesSanctionService
import org.lilie.services.eliot.applications.absences.IncidentService
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Service de gestion des incidents
IncidentException {
// Vérification des droits de création des incidents
- droitsService.verifieDroitsCRUDIncident(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- incidentParams.etablissement
+ incidentParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
// Création du nouvel incident
return internalCreeIncident(incidentParams)
SanctionException {
// Vérifie les droits de suppression
- droitsService.verifieDroitsCRUDIncident(securiteSession,
- incident.etablissement
+ droitsService.verifieDroitModificationFonctionnalite(
+ securiteSession,
+ incident.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
// Suppression
IncidentException {
// Vérification des droits de modification de l'incident
- droitsService.verifieDroitsCRUDIncident(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- incidentParams.etablissement
+ incidentParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
// Modification
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.incident
import org.lilie.services.eliot.absences.PartenaireAPrevenirIncident
*/
-
-
-
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.incident
import org.lilie.services.eliot.absences.ProtagonisteIncident
import org.lilie.services.eliot.absences.Incident
import org.lilie.services.eliot.applications.absences.PunitionService
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* @author bahj
Punition creePunition(SecuriteSession securiteSession,
PunitionParams punitionParams)
throws AutorisationException, PunitionException {
- droitsService.verifieDroitsCRUDPunition(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- punitionParams.etablissement
+ punitionParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
return internalCreePunition(punitionParams)
}
Punition punitionAModifier,
PunitionParams punitionParams
) throws AutorisationException, PunitionException {
- droitsService.verifieDroitsCRUDPunition(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- punitionParams.etablissement
+ punitionParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
return internalModifiePunition(punitionAModifier, punitionParams)
}
void supprimePunition(SecuriteSession securiteSession,
Punition punitionASupprimer)
throws AutorisationException, PunitionException {
- droitsService.verifieDroitsCRUDPunition(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- punitionASupprimer.etablissement
+ punitionASupprimer.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
internalSupprimePunition(punitionASupprimer)
}
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.absences.Incident
import org.lilie.services.eliot.applications.absences.SanctionService
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* Classe de gestion des sanctions
SanctionParams sanctionParams)
throws AutorisationException, SanctionException {
// Vérifie les droits
- droitsService.verifieDroitsCRUDSanction(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- sanctionParams.etablissement
+ sanctionParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
return internalCreeSanction(sanctionParams)
SanctionParams sanctionParams
) throws AutorisationException, SanctionException {
- droitsService.verifieDroitsCRUDSanction(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- sanctionParams.etablissement
+ sanctionParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
return internalModifierSanction(sanctionAModifier, sanctionParams)
void supprimeSanction(SecuriteSession securiteSession, Sanction sanction)
throws AutorisationException, SanctionException {
- droitsService.verifieDroitsCRUDSanction(
+ droitsService.verifieDroitModificationFonctionnalite(
securiteSession,
- sanction.etablissement
+ sanctionParams.etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
internalSupprimeSanction(sanction)
int limit
) {
- boolean personneIsEnseignant = getIsPersonnelEnseignantOuDocu(
- securiteSession,
- etablissement
- )
+ boolean personneIsEnseignant =
+ droitsService.isSeulementEnseignantOuDocumentatliste(
+ securiteSession,
+ etablissement
+ )
List sanctionsInfo = []
Map resultats = [
return resultats
}
- /**
- * @param securiteSession
- * @param etablissement
- * @return true si la personne est uniquement enseignant ou documentaliste
- * dans l'établissement
- */
- private boolean getIsPersonnelEnseignantOuDocu(SecuriteSession securiteSession, Etablissement etablissement) {
- // personne est seulement prof/docu
- // si elle a une autre fonctionne qui est plus forte, elle gagne
- Boolean personneIsEnseignant =
- securiteSession.hasFonctionIn(
- [
- FonctionEnum.ENSEIGNANT,
- FonctionEnum.DOCUMENTALISTE
- ],
- etablissement.id
- ) &&
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.DIRECTION,
- FonctionEnum.EDUCATION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id
- )
- return personneIsEnseignant
- }
private String getNomCompletChampOrdre(String champOrdre) {
String champ
* @param eleve : élève dont on veut les absences
* @return une liste de map
*/
- CalendrierHebdo findAbsencesInfoForEleveAndPeriode(
- SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- Date dateDebut,
- Personne eleve,
- StructureEnseignement classeEleve) {
+ CalendrierHebdo findAbsencesInfoForEleveAndPeriode(SecuriteSession securiteSession,
+ PreferencesEtablissementAbsences pref,
+ Date dateDebut,
+ Personne eleve,
+ StructureEnseignement classeEleve) {
Calendar calDebut = Calendar.getInstance()
calDebut.setTime(dateDebut)
DateUtil.setDebutJour(calDebut)
* @param appelDatas
* @return une liste de Map
*/
- private CalendrierHebdo creeGrilleAbsencesInfos(
- Calendrier calendrier,
- PreferencesEtablissementAbsences pref,
- List<PlageHoraire> plageHoraires,
- List appelDatas,
- List<AppelLigne> absencesAppels,
- List<AppelLigne> absencesJournees,
- List<EmploiDuTemps> emploiDuTemps,
- Date dateDebut) {
+ private CalendrierHebdo creeGrilleAbsencesInfos(Calendrier calendrier,
+ PreferencesEtablissementAbsences pref,
+ List<PlageHoraire> plageHoraires,
+ List appelDatas,
+ List<AppelLigne> absencesAppels,
+ List<AppelLigne> absencesJournees,
+ List<EmploiDuTemps> emploiDuTemps,
+ Date dateDebut) {
CalendrierHebdo result = new CalendrierHebdo()
List<JourFerieInfo> jourFeries = calendrierService.
* @param absencesAppels
* @param absencesJournees
*/
- private CalendrierHebdoCellule traiteUnJour(
- Integer jour,
- PlageHoraire plageHoraire,
- Date dateDebut,
- List<JourFerieInfo> jourFeries,
- Calendrier calendrier,
- List appelDatas,
- List<AppelLigne> absencesAppels,
- List<AppelLigne> absencesJournees,
- List<EmploiDuTemps> emploiDuTemps) {
+ private CalendrierHebdoCellule traiteUnJour(Integer jour,
+ PlageHoraire plageHoraire,
+ Date dateDebut,
+ List<JourFerieInfo> jourFeries,
+ Calendrier calendrier,
+ List appelDatas,
+ List<AppelLigne> absencesAppels,
+ List<AppelLigne> absencesJournees,
+ List<EmploiDuTemps> emploiDuTemps) {
boolean plageOuverte = isPlageOuverte(
jour,
package org.lilie.services.eliot.absences.securite
import org.lilie.services.eliot.securite.AutorisationException
-
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
import org.lilie.services.eliot.scolarite.Etablissement
-
import org.lilie.services.eliot.droits.EliotDroitsService
-
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.scolarite.personne.enseignant.EnseignantAnnuaireService
-
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
-
import org.lilie.services.eliot.absences.Appel
import org.lilie.services.eliot.absences.AppelLigne
-
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
+import org.codehaus.groovy.grails.commons.GrailsApplication
+
/**
* @author jbui
* @author bahj
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
EnseignantAnnuaireService enseignantAnnuaireService
- public HashSet getFonctionnalitesAccessibles(SecuriteSession securiteSession,
- Etablissement etablissement) {
+ @SuppressWarnings('GrailsStatelessService')
+ GrailsApplication grailsApplication
+
+
+ public HashSet<EliotFonctionnalites> getFonctionnalitesAccessibles(SecuriteSession securiteSession,
+ Etablissement etablissement) {
// Gestion des utilisateurs à accès restreint
if (securiteSession.defaultAutorite.aUnAccesRetreint()) {
// Fonction Parent non paramétrable / fonctionnalité parametrable + non paramétrables
if (securiteSession.hasFonctionIn([FonctionEnum.PERS_REL_ELEVE], etablissement.id)) {
+ fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS)
+ fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS_CONSULT)
fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS_CONSULT_PARENT)
}
// Fonction Eleve non paramétrable / fonctionnalité parametrable + non paramétrables
if (securiteSession.hasFonctionIn([FonctionEnum.ELEVE], etablissement.id)) {
+ fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS)
+ fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS_CONSULT)
fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ABS_CONSULT_ELEVE)
}
// Fonction Enseignant non paramétrable / fonctionnalité parametrable + non paramétrables
- if (securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT], etablissement.id)) {
- fonctionnalitesAccessibles.addAll(getEnseignantFonctionnalites())
+ if (securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT, FonctionEnum.DOCUMENTALISTE], etablissement.id)) {
+ fonctionnalitesAccessibles.addAll(getEnseignantAssimileFonctionnalites())
}
// Ajoute les notifications
fonctionnalitesAccessibles.add(ScolariteFonctionnalites.NOTIFICATION_PREFERNCE_UTILISATEUR)
}
-
+ fonctionnalitesAccessibles.add(AbsencesFonctionnalite.ETABLISSEMENT)
return fonctionnalitesAccessibles
}
- private HashSet getEnseignantFonctionnalites() {
+ private HashSet getEnseignantAssimileFonctionnalites() {
return [
+ AbsencesFonctionnalite.ABS,
+ AbsencesFonctionnalite.ABS_SAISIE,
AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE,
+ AbsencesFonctionnalite.ABS_CONSULT,
AbsencesFonctionnalite.ABS_CONSULT_ENSEIGNANT,
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN,
ScolariteFonctionnalites.FICHE_ELEVE_ABSENCES,
public Boolean getDroitFonctionnalite(SecuriteSession securiteSession,
Etablissement etablissement,
- AbsencesFonctionnalite fonctionnalite) {
+ EliotFonctionnalites fonctionnalite) {
HashSet fonctionnalitesAccessibles =
getFonctionnalitesAccessibles(securiteSession, etablissement)
return false
}
-/**
- * Vérifie les droits de la session courante à accéder à une fonctionnalité
- * @param securiteSesion
- * @param etablissement
- * @param fonctionnalite
- * @throws AutorisationException
- */
- void verifieDroitFonctionnalite(SecuriteSession securiteSession,
- Etablissement etablissement,
- AbsencesFonctionnalite fonctionnalite)
- throws AutorisationException {
- if (!getDroitFonctionnalite(securiteSession, etablissement, fonctionnalite)) {
- throw AutorisationException.consultationContenuException()
- }
- }
private boolean aAccesAuxNotifications(SecuriteSession securiteSession) {
if (securiteSession.hasFonctionIn([
FonctionEnum.PERS_REL_ELEVE,
FonctionEnum.ELEVE
])) {
- return true
+ return grailsApplication.config.eliot.notification.actif
}
return false
}
- // TODO : plus besoin de ces fonctions , utiliser toujours : verifieDroitFonctionnalite
- // todo garder les fonctions de vérification CRUD
-/**
- * vérifie les droits en consultation des paramétrages générals
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsConsultationParametragesGeneral(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences preferences
- ) throws AutorisationException {
-
- if (!getDroitFonctionnalite(securiteSession,
- preferences.etablissement,
- AbsencesFonctionnalite.ABS_PARAM_GENERAUX
- )
- ) {
- throw AutorisationException.consultationContenuException()
- }
- }
-
-/**
- * vérifie les droits en modification des paramétrages générals
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsModificationParametragesGeneral(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences preferences
- ) throws AutorisationException {
-
- if (!getDroitFonctionnalite(
- securiteSession,
- preferences.etablissement,
- AbsencesFonctionnalite.ABS_PARAM_GENERAUX
- )
- ) {
- throw AutorisationException.modificationContenuException()
- }
- }
-
-/**
- * vérifie les droits en création/modification des Incidents, Punitions, Sanctions
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsCreationModificationIncidentsPunitionsSanctions(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences preferences
- ) throws AutorisationException {
-
- if (!getDroitFonctionnalite(
+ /**
+ * détermine le droit de la session courante aux
+ * création/modification/suppression d'une punition / sanction / incident
+ * @return flag
+ * @author bahj
+ */
+ Boolean aDroitsCUDDiscipline(SecuriteSession securiteSession, Etablissement etablissement) {
+ Boolean aAccesFonctionnalite = getDroitFonctionnalite(
securiteSession,
- preferences.etablissement,
- AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
+ etablissement,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
)
- ) {
- throw AutorisationException.modificationContenuException()
- }
- }
-
-/**
- * vérifie les droits de supprission des Incidents, Punitions, Sanctions
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsSupprissionIncidentsPunitionsSanctions(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences preferences
- ) throws AutorisationException {
- if (!getDroitFonctionnalite(
- securiteSession,
- preferences.etablissement,
- AbsencesFonctionnalite.ABS_PARAM_INC_PUN_SAN
+ Boolean notEnseignantAssimile = securiteSession.hasFonctionIn(
+ FonctionEnum.findAll{it != FonctionEnum.ENSEIGNANT && it != FonctionEnum.DOCUMENTALISTE} as List,
+ etablissement.id
)
- ) {
- throw AutorisationException.suppressionException()
- }
- }
-/**
- * vérifie les droits de création/modification/suppression des Incidents
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsCRUDIncident(SecuriteSession securiteSession,
- Etablissement etablissement
- ) throws AutorisationException {
-
- if (
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id
- )
- ) {
- throw AutorisationException.modificationContenuException()
- }
- }
-
-/**
- * vérifie les droits de création/modification/suppression des puntions
- * @author bahj
- * @param securiteSession
- * @param preferences
- * @throws AutorisationException
- */
- void verifieDroitsCRUDPunition(SecuriteSession securiteSession,
- Etablissement etablissement
- ) throws AutorisationException {
-
- if (
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id
- )
- ) {
- throw AutorisationException.modificationContenuException()
- }
- }
-/**
- * vérifie les droits de création/modification/suppression des sanctions
- * @author bahj
- * @param securiteSession
- * @param etablissement : établissement de rattachement de la sanction
- * @throws AutorisationException
- */
- void verifieDroitsCRUDSanction(SecuriteSession securiteSession,
- Etablissement etablissement
- ) throws AutorisationException {
-
- if (
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id
- )
- ) {
- throw AutorisationException.modificationContenuException()
+ if (aAccesFonctionnalite && notEnseignantAssimile) {
+ return true
}
- }
-/**
- * vérifie les droits de création/modification/suppression des absences journée
- * @author jbui
- * @param securiteSession
- * @param etablissement : établissement de rattachement de l'absence journée
- * @throws AutorisationException
- */
- void verifieDroitsCRUDAbsenceJournee(SecuriteSession securiteSession,
- Etablissement etablissement
- ) throws AutorisationException {
-
- if (
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id)
- ) {
- throw AutorisationException.modificationContenuException()
- }
- }
-
-/**
- * vérifie les droits de création/modification/suppression des pensions
- * @author bahj
- * @param securiteSession
- * @param etablissement : établissement de rattachement de l'absence journée
- * @throws AutorisationException
- */
- void verifieDroitsCRUDDemiPensionInternat(SecuriteSession securiteSession,
- Etablissement etablissement
- ) throws AutorisationException {
-
- if (
- !securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissement.id)
- ) {
- throw AutorisationException.modificationContenuException()
- }
+ return false
}
-/**
- * détermine s'il faut afficher l'onglet de choix des établissements
- * @param securiteSession
- * @return un booléen indiquant si le menu de choix d'établissement doit s'afficher
- */
- Boolean getDroitAccesMenuEtablissement(SecuriteSession securiteSession) {
- Boolean acces = false
- List<Etablissement> etablissements = getEtablissementsAccessiblesForAbsences(
- securiteSession
- )
- if (etablissements.size() > 1) {
- acces = true
- }
- return acces
+ /**
+ * @param securiteSession
+ * @param etablissement
+ * @return true si la personne est uniquement enseignant ou documentaliste
+ * dans l'établissement
+ */
+ Boolean isSeulementEnseignantOuDocumentatliste(SecuriteSession securiteSession,
+ Etablissement etablissement) {
+ // personne est seulement prof/docu
+ // si elle a une autre fonctionne qui est plus forte, elle gagne
+ Boolean personneIsEnseignant =
+ securiteSession.hasFonctionIn(
+ [
+ FonctionEnum.ENSEIGNANT,
+ FonctionEnum.DOCUMENTALISTE
+ ],
+ etablissement.id
+ ) &&
+ !securiteSession.hasFonctionIn(
+ [
+ FonctionEnum.DIRECTION,
+ FonctionEnum.EDUCATION,
+ FonctionEnum.ADMIN_LOCAL,
+ FonctionEnum.CHEF_TRAVAUX,
+ FonctionEnum.CORRESPONDANT_DEPLOIEMENT
+ ],
+ etablissement.id
+ )
+ return personneIsEnseignant
}
+// todo à reprendre pour le paramétrage : attente dé réponse de christelle
/**
* return la liste des rôles qui ont un accès en modification à absences (v15 Novembre)
* @return une liste de types de rôles
]
}
+ // todo à reprendre pour le paramétrage
/**
* Retourne la liste des établissements accessibles à l'utilisateur dans le
* cadre de l'application absences, en fonction de ses rôles
return false
}
}
+ // todo bahj pas compris utilisation
/**
- * Vérifie le droit de l'acteur connecté à créer un appel pour la structure et
+ * Vérifie le droit de l'acteur connecté à écrire un appel pour la structure et
* retourne le type de rôle autorisant cette création
* @param securiteSession : la session de sécurité de l'acteur connecté
* @param appel : l'appel sur lequel on veut vérifier les droits
* @return le type de rôle autorisant cette opération
*/
- FonctionEnum verifieDroitAvecAppel(SecuriteSession securiteSession,
- Appel appel
+ FonctionEnum verifieDroitEcritureAppel(SecuriteSession securiteSession,
+ Appel appel
) {
- return getTypeRolePourAccesAppel(
+ FonctionEnum resultat = getTypeRolePourAccesAppel(
securiteSession,
appel.evenement.agendaMaitre.structureEnseignement,
appel.appelant
)
+
+ log.debug "verifieDroitEcritureAppel : $resultat"
+
+ return resultat
}
+ // todo bahj pas compris utilisation
/**
* Vérifie le droit de l'acteur connecté à accéder à un appel pour la structure et
* retourne le type de rôle autorisant cette accès
Autorite enseignant = null
) {
+
if (securiteSession.defaultAutorite.idExterne == enseignant?.idExterne) {
- return FonctionEnum.ENSEIGNANT
+ FonctionEnum resultat = FonctionEnum.ENSEIGNANT
+ log.debug "getTypeRolePourAccesAppel $enseignant"
+ return resultat
}
- //Si l'acteur est directeur, CPE , admin local ou chef des travaux de l'établissement : OK
Long etablissementId = structureEnseignement.etablissement.id
- if (securiteSession.hasFonctionIn(
- [
- FonctionEnum.DIRECTION,
- FonctionEnum.EDUCATION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ],
- etablissementId
- )) {
- return FonctionEnum.EDUCATION
+
+ if (securiteSession.hasAccesFonctionnalite(
+ AbsencesFonctionnalite.ABS_SAISIE,
+ etablissementId)) {
+ FonctionEnum resultat = FonctionEnum.EDUCATION
+ log.debug "getTypeRolePourAccesAppel ABS_SAISIE autorisé"
+ return resultat
}
if (enseignantAnnuaireService.isEnseignantForStructure(
(Autorite) securiteSession.defaultAutorite,
structureEnseignement)
) {
- return FonctionEnum.ENSEIGNANT
+ FonctionEnum resultat = FonctionEnum.ENSEIGNANT
+ log.debug "getTypeRolePourAccesAppel enseignant"
+ return resultat
}
return null
)
}
- boolean isEnseignantOnlyDroitsIncPunSan (
+ // todo traiter
+ boolean isEnseignantOnlyDroitsIncPunSan(
SecuriteSession securiteSession,
Etablissement etablissement
- ){
+ ) {
return securiteSession.hasFonctionIn([
FonctionEnum.ENSEIGNANT,
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.SessionUtils
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class VerificateurDroitsAccesSessionService implements VerificateurDroitsAcces {
static scope = 'session'
def Boolean verifieDroitsAccess(Object session) {
- List<FonctionEnum> fonctions =
- droitsService.getTypesRolesAccessibiliteAbsences()
+
+ List<FonctionEnum> fonctions = droitsService.getTypesRolesAccessibiliteAbsences()
SecuriteSession securiteSession = SessionUtils.securiteSession(session)
- return securiteSession.hasFonctionIn(fonctions)
+
+ Boolean accesOk = droitsService.hasDroitSurFonctionnalitesParametrable(
+ securiteSession,
+ securiteSession.getEtablissementsAccessibles(),
+ AbsencesFonctionnalite.values() as List,
+ {
+ return securiteSession.hasFonctionIn(fonctions)
+ }
+ )
+
+ return accesOk
+
}
}
* @param pref preferences établissement d'absences
* @return une Map contenant les infos du contenu des filtres de l'écran "Stats Mensuelles"
*/
- public Map marshallFiltreContenu(
- StatsMensuellesFiltresContenu statsMensuellesFiltresContenu,
- SimpleDateFormat sdf,
- Locale locale,
- Boolean filtreTypesHebdo,
- Boolean inclusListeEleves
+ public Map marshallFiltreContenu(StatsMensuellesFiltresContenu statsMensuellesFiltresContenu,
+ SimpleDateFormat sdf,
+ Locale locale,
+ Boolean filtreTypesHebdo,
+ Boolean inclusListeEleves
) {
Map filtreContenu = [
anneeScolaire: marshallCalendrier(
/**
* Récupère les types de stats nécessaires pour les stats hebdo
- **/
- private List<Map> getHebdoTypes(Locale locale){
+ * */
+ private List<Map> getHebdoTypes(Locale locale) {
MessageSource messageSource = applicationContext.getBean("messageSource")
List<Map> dataEnum = []
dataEnum.add([
import grails.converters.JSON
/**
- * Ce controlleur est le point d'accèss de la première page de notes
+ * Ce controlleur est le point d'accès de la première page de notes
*/
class ApplicationController {
FonctionnaliteSessionService fonctionnaliteSessionService
- def index = {
+ private static final Map DEFAULT_PAGE_PAR_FONCTION = [
+ (FonctionEnum.ENSEIGNANT) : Page.SAISIE_NOTES,
+ (FonctionEnum.DIRECTION) : Page.CONSULTATION_BULLETIN,
+ (FonctionEnum.PERS_REL_ELEVE) : Page.CONSULTATION_RELEVE_DE_NOTES,
+ (FonctionEnum.ELEVE) : Page.CONSULTATION_RELEVE_DE_NOTES,
+ ]
- SecuriteSession securiteSession = SessionUtils.securiteSession(session)
- Long etablissementId = securiteSession.etablissementCourant.id
+ def index = {
if (isModeMaintenance()) {
chain(controller: 'maintenance')
return
}
+ SecuriteSession securiteSession = SessionUtils.securiteSession(session)
+
// Accès restreint : pas d'accès à l'application notes
if (securiteSession.defaultAutorite.aUnAccesRetreint()) {
throw AutorisationException.consultationContenuException()
}
- //Pages par défaut par rapport au profil :
- if (
- securiteSession.hasFonctionIn(
- NotesFonction.ENSEIGNANT_ASSIMILE,
- etablissementId)
- ) {
- // Prof / DOC / CPE -> Saisie / Notes et appreciations
- chain(controller: 'saisieTableauDeNotes')
- return
- } else if (
- securiteSession.hasFonctionIn(
- NotesFonction.DIRECTION_ASSIMILE,
- etablissementId)
- ) {
- // Direction -> Consultation / Bulletin
- chain(controller: 'consultationBulletin')
- return
- } else if (securiteSession.hasFonctionIn(
- [FonctionEnum.PERS_REL_ELEVE],
- etablissementId)) {
- // Direction -> Consultation / Relevé de Notes
- chain(controller: 'consultationReleve')
- return
- } else if (securiteSession.hasFonctionIn(
- [FonctionEnum.ELEVE],
- etablissementId)) {
- // Direction -> Consultation / Relevé de Notes
- chain(controller: 'consultationReleve')
- return
+ Page page = getPageParDefaut()
+
+ if (page) {
+ chain(controller: page.controller)
} else {
- // le reste - accés interdit
throw AutorisationException.consultationContenuException()
}
}
+
+ private Page getPageParDefaut() {
+ return getPageParDefautFonctionNonParametrable() ?: getPremierePageAccessible()
+ }
+
+
+ private Page getPageParDefautFonctionNonParametrable() {
+ SecuriteSession securiteSession = SessionUtils.securiteSession(session)
+ Long etablissementId = securiteSession.etablissementCourant.id
+
+ Map.Entry entry = DEFAULT_PAGE_PAR_FONCTION.find {FonctionEnum fonction, Page page ->
+ securiteSession.hasFonctionIn([fonction], etablissementId)
+ }
+
+ return (Page) entry?.value
+ }
+
+
+ private Page getPremierePageAccessible() {
+ SecuriteSession securiteSession = SessionUtils.securiteSession(session)
+ Long etablissementId = securiteSession.etablissementCourant.id
+
+ return (Page) Page.find {Page page ->
+ page.isAccessibleParMenu() &&
+ fonctionnaliteSessionService.isFonctionnaliteAccesible(
+ securiteSession,
+ etablissementId,
+ page.fonctionnalite)
+ }
+ }
+
+
def changeEtablissement = {
Long nouvelEtablissementId = Long.parseLong(params.id)
SecuriteSession securiteSession = SessionUtils.securiteSession(session)
findAllClasseForUtilisateur(
securiteSession,
etablissementCourant,
- Action.CONSULTATION)
+ Action.CONSULTATION,
+ true)
classes.sort {a, b -> cc.compare(a.code, b.code)}
if (!result) {
result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant(),
+ Action.CONSULTATION,
+ (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+ NotesFonction.DIRECTION_ASSIMILE +
+ [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
+ )
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
etablissementCourant(),
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE +
- [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
- )
+ NotesFonctionnalite.NOTES_CONSULT_RELEVE_BULLETIN,
+ verifieDroitFonctionsNonParametrables
)
print = (params.print != null) ? Boolean.valueOf(params.print) : false
import org.lilie.services.eliot.notes.notes.ReleveService
import org.lilie.services.eliot.notes.notes.Releve
import org.lilie.services.eliot.notes.domaine.PeriodeInfo
-import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.notes.scolarite.NotesPersonneService
import org.lilie.services.eliot.impression.TemplateDocument
import org.lilie.services.eliot.impression.donnees.eleve.EleveImpressionInfo
NotesStructureEnseignementService notesStructureEnseignementService
ReleveService releveService
NotesPersonneService notesPersonneService
- ImpressionRequetageService impressionRequetageService
ImpressionRequetageBulletinReleveService impressionRequetageBulletinReleveService
ImpressionMoteurService impressionMoteurService
Map result = getResultIfNullParams(['eleveId', 'periodeId'])
if (!result) {
result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant(),
+ Action.CONSULTATION,
+ (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+ NotesFonction.DIRECTION_ASSIMILE +
+ [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
+ )
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
etablissementCourant(),
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE +
- [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
- )
+ NotesFonctionnalite.NOTES_CONSULT_RELEVE_BULLETIN,
+ verifieDroitFonctionsNonParametrables
)
+
Periode periode = Periode.get(Long.valueOf(params.periodeId))
Personne eleve = Personne.get(Long.valueOf(params.eleveId))
Releve releve = null
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.notes.AbstractTableauDeNotesController
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.notes.NotesFonctionnalite
+
import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.notes.NotesFonctionnalite
/**
* Consultation des Tableau de Notes (profil directeur)
notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
etablissementCourant,
- NotesFonctionnalite.NOTES_CONSULT_NOTES,
+ NotesFonctionnalite.NOTES_SAISIE_NOTES_ENSEIGNANTS,
verifieDroitFonctionsNonParametrables
)
personnes?.sort { it.nomAffichage() }
// get tableau de notes
- Map resultat = prepareBaseModele(Page.CONSULTATION_TABLEAU_DE_NOTES)
+ Map resultat = prepareBaseModele(Page.SAISIE_NOTES_ENSEIGNANTS)
resultat = internalPrepareTableauDeNotes(true, resultat, params, enseignantConsulte)
resultat.enseignants = personnes.collect {toMap(it)} as JSON
resultat.enseignantId = enseignantId
*/
def imprimerTableauDeNotes = {
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_NOTES_ENSEIGNANTS,
+ verifieDroitFonctionsNonParametrables
)
Autorite enseignant = Autorite.get(params.enseignantId)
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
breadCrumbsInfo << new BreadCrumbsItemInfo(
- codeLabel: 'notes.menu.consultation.titrePrincipal'
+ codeLabel: 'notes.menu.saisie.titrePrincipal'
)
breadCrumbsInfo << new BreadCrumbsItemInfo(
- codeLabel: 'notes.menu.saisie.tableauDeNotes.titrePrincipal'
+ codeLabel: 'notes.menu.saisie.notesEnseignants.titrePrincipal'
)
return breadCrumbsInfo
}
if (result) {render result as JSON}
result = tryCatch {
+/*
notesDroitService.verifieAutorisationByEtablissement(
securiteSession,
etablissementCourant(),
[FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
)
)
+*/
Long classeId = Long.valueOf(params.classeId)
StructureEnseignement classe = StructureEnseignement.get(classeId)
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.notes.NotesFonction
+import org.lilie.services.eliot.notes.NotesFonctionnalite
+import org.lilie.services.eliot.scolarite.Etablissement
+
/**
* Le controlleur utilisé pour enregistrer les appreciations des élève
* dans la table de synthèse
Map result = getResultIfInvalidCommand(command)
if (!result) {
result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ SecuriteSession securiteSession = getSecuriteSession()
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ [
+ FonctionEnum.DIRECTION,
+ FonctionEnum.CORRESPONDANT_DEPLOIEMENT
+ ] + NotesFonction.ENSEIGNANT_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- [
- FonctionEnum.DIRECTION,
- FonctionEnum.CORRESPONDANT_DEPLOIEMENT
- ] + NotesFonction.ENSEIGNANT_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_SYNTH,
+ verifieDroitFonctionsNonParametrables
)
- SecuriteSession securiteSession = getSecuriteSession()
+
Periode periode = Periode.get(command.idPeriode)
Map mapEleveAppreciation = command.getMapEleveAppreciation()
appreciationElevePeriodeService.saveAppreciations(
import org.lilie.services.eliot.notes.scolarite.NotesPeriodeParams
import org.lilie.services.eliot.notes.parametrage.ParametrageNotesService
import org.lilie.services.eliot.scolarite.NaturePeriode
+import org.lilie.services.eliot.notes.NotesFonctionnalite
+import org.lilie.services.eliot.scolarite.Etablissement
/**
* Controleur correspondant à la classe domaine Service
*/
def listeServicesPourClasse = {
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Long classeId = params.idClasse ? params.idClasse.toLong() : null
*/
def executeModifierService = { ServiceCommand command ->
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Map result = wrapResultat {
*/
private def modifieService(def command) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissementCourant(),
+// Action.MODIFICATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
Map valeurs = [:]
if (command.hasErrors()) {
*/
def actionModifierService = { ServiceCommand command ->
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Map result = getResultIfInvalidCommand(command)
*/
def creeService = { ServiceCommand command ->
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CREATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CREATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
if (command.hasErrors()) {
*/
def executeSupprimerService = { ServiceSuppressionCommand command ->
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.SUPPRESSION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.SUPPRESSION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Map result = wrapResultat {
*/
private def supprimeService(def command) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissementCourant(),
- Action.SUPPRESSION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissementCourant(),
+// Action.SUPPRESSION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (command.hasErrors()) {
log.error(command.errors)
*/
def actionSupprimerService = { ServiceSuppressionCommand command ->
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.SUPPRESSION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.SUPPRESSION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Map result = wrapResultat {
// vérifie que le service n'est pas évaluable dans les autres périodes
if (!command.phase1Passee() && notesServiceService.
- serviceEvaluableDansAutrePeriodes(securiteSession,
- service, nature, typePeriode)) {
+ serviceEvaluableDansAutrePeriodes(service, nature, typePeriode)) {
return [
message: message(code: 'eliot.notes.parametrageServices.service.evaluableDansAutresPeriodes'),
'deleted': false,
*/
def listeServicesPourEnseignant = {
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ NotesFonction.ENSEIGNANT_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- NotesFonction.ENSEIGNANT_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
Boolean success = false
List<Service> services = notesServiceService.
findAllServiceForEnseignant(
- securiteSession,
- enseignant,
- etablissementCourant())
+ securiteSession,
+ enseignant,
+ etablissementCourant())
success = true
result.serviceInfos = services
* @author bper
*/
public enum Page {
- SAISIE_TABLEAU_DE_NOTES(
+ SAISIE_NOTES(
GroupePage.SAISIE,
- Fonctionnalite.SAISIE_TABLEAU_DE_NOTES,
+ Fonctionnalite.SAISIE_NOTES,
'saisieTableauDeNotes'
),
+ SAISIE_NOTES_ENSEIGNANTS(
+ GroupePage.SAISIE,
+ Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS,
+ 'consultationTableauDeNotes' // TOREFACT traitez le fait que CONSULTATION_TABLEAU_DE_NOTES est devenu SAISIE_NOTES_ENSEIGNANTS
+ ),
SAISIE_SYNTHESE(
GroupePage.SAISIE,
Fonctionnalite.SAISIE_SYNTHESE,
SAISIE_CONSEIL_DE_CLASSE(
GroupePage.SAISIE,
Fonctionnalite.SAISIE_CONSEIL_DE_CLASSE,
- 'saisieConseilDeClasse'
+ 'saisieConseilDeClasse',
+ false
),
SAISIE_APPRECIATIONS(
GroupePage.SAISIE,
Fonctionnalite.SAISIE_APPRECIATIONS,
- 'saisieAppreciations'
+ 'saisieAppreciations',
+ false
),
- CONSULTATION_TABLEAU_DE_NOTES(
+ CONSULTATION_RELEVE_DE_NOTES(
GroupePage.CONSULTATION,
- Fonctionnalite.CONSULTATION_TABLEAU_DE_NOTES,
- 'consultationTableauDeNotes'
+ Fonctionnalite.CONSULTATION_RELEVE_DE_NOTES,
+ 'consultationReleve'
),
CONSULTATION_BULLETIN(
GroupePage.CONSULTATION,
Fonctionnalite.CONSULTATION_BULLETIN,
'consultationBulletin'
),
- CONSULTATION_RELEVE_DE_NOTES(
- GroupePage.CONSULTATION,
- Fonctionnalite.CONSULTATION_RELEVE_DE_NOTES,
- 'consultationReleve'
- ),
CONSULTATION_APPRECIATION_CLASSE(
GroupePage.CONSULTATION,
Fonctionnalite.CONSULTATION_APPRECIATION_CLASSE,
- 'consultationReleve'
+ 'consultationAppreciationsClasse'
),
PARAMETRAGES_SERVICES(
GroupePage.PARAMETRAGE,
private final GroupePage groupePage
private final String controller
private final Fonctionnalite fonctionnalite
+ private final boolean accessibleParMenu
private Page(GroupePage groupePage,
Fonctionnalite fonctionnalite,
- String controller) {
+ String controller,
+ boolean accessibleParMenu = true) {
this.groupePage = groupePage
this.fonctionnalite = fonctionnalite
this.controller = controller
+ this.accessibleParMenu = accessibleParMenu
}
public GroupePage getGroupePage() {
public boolean appartientAuGroupe(GroupePage groupePage) {
return this.groupePage == groupePage;
}
+
+ public boolean isAccessibleParMenu() {
+ return this.accessibleParMenu
+ }
}
*/
def lanceReport = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
if (params.ordreMatieres == null) {
Map resultat = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
String classeId = params.classeId
@SuppressWarnings("CatchException")
def creeLienSousMatieres = {
Map resultat = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_PARAM,
+ verifieDroitFonctionsNonParametrables
)
CreationSousServicesParams creationSousServicesParams =
def series = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List)(NotesFonction.DIRECTION_ASSIMILE))
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List)(NotesFonction.DIRECTION_ASSIMILE))
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_BREVET,
+ verifieDroitFonctionsNonParametrables
+ )
Map resultat = [:]
def fiches = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List)(NotesFonction.DIRECTION_ASSIMILE))
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List)(NotesFonction.DIRECTION_ASSIMILE))
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_BREVET,
+ verifieDroitFonctionsNonParametrables
+ )
Map resultat = [:]
def actualise = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List)(NotesFonction.DIRECTION_ASSIMILE))
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List)(NotesFonction.DIRECTION_ASSIMILE))
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_BREVET,
+ verifieDroitFonctionsNonParametrables
+ )
Map resultat = [:]
StructureEnseignement classe = StructureEnseignement.get(params.classe)
def enregistre = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.MODIFICATION,
+ (List)(NotesFonction.DIRECTION_ASSIMILE))
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.MODIFICATION,
- (List)(NotesFonction.DIRECTION_ASSIMILE))
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_BREVET,
+ verifieDroitFonctionsNonParametrables
+ )
JSONArray jsonFiches = new JSONArray(params.fiches)
typeActivites.sort{it.libelle}
Map resultat = prepareBaseModele(
- Page.SAISIE_TABLEAU_DE_NOTES,
+ Page.SAISIE_NOTES,
service?.structureEnseignement?.nomAffichage,
service?.matiere?.codeGestion,
typePeriode ? message(code: typePeriode.libelle) : '',
findAllClasseForUtilisateur(
securiteSession,
etablissementCourant,
- Action.CONSULTATION)
+ Action.CONSULTATION,
+ true)
classes.sort {a, b -> cc.compare(a.code, b.code)}
*/
def graph = {
Map result = tryCatch {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_SYNTH,
+ verifieDroitFonctionsNonParametrables
)
Personne eleve = params.eleveId ? Personne.get(Long.valueOf(params.eleveId)) : null
* Calcul des données pour l'impression de la sytnhèse
*/
private SyntheseImpression donneesTableauSynthese(SecuriteSession securiteSession, Map params) {
- notesDroitService.verifieAutorisationByEtablissement(
+
+ Etablissement etablissementCourant = etablissementCourant()
+
+ Closure verifieDroitFonctionsNonParametrables = {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant,
+ Action.CONSULTATION,
+ (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+ )
+ }
+
+ notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
- etablissementCourant(),
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
+ etablissementCourant,
+ NotesFonctionnalite.NOTES_SAISIE_SYNTH,
+ verifieDroitFonctionsNonParametrables
)
OptionsImpressionParams optionsImpressionParams =
notesDroitService.verifieDroitSurFonctionnaliteParametrable(
securiteSession,
etablissementCourant,
- NotesFonctionnalite.NOTES_CONSULT_NOTES_MODIF,
+ NotesFonctionnalite.NOTES_SAISIE_NOTES_ENSEIGNANTS,
verifieDroitFonctionsNonParametrables
)
Map result = wrapResultat {
- Map resultat = prepareBaseModele(Page.SAISIE_TABLEAU_DE_NOTES)
+ Map resultat = prepareBaseModele(Page.SAISIE_NOTES)
resultat = internalPrepareTableauDeNotes(false, resultat, params, null)
return resultat
}
codeLabel: 'notes.menu.saisie.titrePrincipal'
)
breadCrumbsInfo << new BreadCrumbsItemInfo(
- codeLabel: 'notes.menu.saisie.tableauDeNotes.titrePrincipal'
+ codeLabel: 'notes.menu.saisie.notes.titrePrincipal'
)
return breadCrumbsInfo
notes.menu.parametrages.generaux.titrePrincipal=Généraux
notes.menu.parametrages.brevet.titrePrincipal=Brevet
notes.menu.saisie.titrePrincipal=Saisie
-notes.menu.saisie.tableauDeNotes.titrePrincipal=Notes et appréciations
+notes.menu.saisie.notes.titrePrincipal=Notes et appréciations
+notes.menu.saisie.notesEnseignants.titrePrincipal=Notes et appréciations Enseignants
notes.menu.saisie.synthese.titrePrincipal=Synthèses
notes.menu.saisie.brevet.titrePrincipal=Fiches Brevet
notes.menu.saisie.conseilDeClasse.titrePrincipal=Conseil de classe
notes.menu.saisie.appreciations.titrePrincipal=Appréciations
notes.menu.consultation.titrePrincipal=Consultation
-notes.menu.consultation.tableauDeNotes.titrePrincipal=Notes et appréciations
notes.menu.consultation.bulletin.titrePrincipal=Bulletin
notes.menu.consultation.releve.titrePrincipal=Relevé de notes
notes.menu.consultation.appreciationClasse.titrePrincipal=Appréciations classes
import org.lilie.services.eliot.VerificateurDroitsAcces
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.notes.NotesDroitService
+import org.lilie.services.eliot.notes.NotesFonctionnalite
/**
* Droits d'accès à eliot-notes (par rapport au profil d'utilisateur)
class VerificateurDroitsAccesSessionService implements VerificateurDroitsAcces {
static transactional = true
+ NotesDroitService notesDroitService
+
static scope = 'session'
Boolean verifieDroitsAccess(def session) {
+
SecuriteSession securiteSession = SessionUtils.securiteSession(session)
- Boolean accesOk = securiteSession.hasFonctionIn(
- NotesFonction.ENSEIGNANT_ASSIMILE +
+
+ Boolean accesOk = notesDroitService.hasDroitSurFonctionnalitesParametrable(
+ securiteSession,
+ securiteSession.getEtablissementsAccessibles(),
+ NotesFonctionnalite.values() as List,
+ {
+ return securiteSession.hasFonctionIn(
+ NotesFonction.ENSEIGNANT_ASSIMILE +
NotesFonction.DIRECTION_ASSIMILE +
[
FonctionEnum.ELEVE,
FonctionEnum.PERS_REL_ELEVE // Parent
])
+ }
+ )
+
return accesOk
+
}
}
StructureEnseignement classe,
BrevetSerie serie) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE)
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classe.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE)
if (classe.anneeScolaire.id != serie.anneeScolaire.id) {
throw new IllegalArgumentException(
notesStructureEnseignementService.findAllClassesForAllEleves(fiches*.eleve)
classes.each {StructureEnseignement classe ->
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE)
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classe.etablissement,
+// Action.MODIFICATION,
+// NotesFonction.DIRECTION_ASSIMILE)
}
fiches = fiches.collect {BrevetFiche fiche ->
List<Personne> eleves) {\r
\r
// verifie que l'utilisateur a le droit de voir les notes\r
- notesDroitService.verifieAutorisationByEtablissement(\r
- securiteSession,\r
- classe.etablissement,\r
- Action.CONSULTATION,\r
- NotesFonction.DIRECTION_ASSIMILE)\r
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables\r
+// notesDroitService.verifieAutorisationByEtablissement(\r
+// securiteSession,\r
+// classe.etablissement,\r
+// Action.CONSULTATION,\r
+// NotesFonction.DIRECTION_ASSIMILE)\r
\r
Map eleveMap = [:]\r
eleves.each {\r
List<BrevetSerie> findAllSeriePourClasse(SecuriteSession securiteSession,\r
StructureEnseignement classe) {\r
\r
- notesDroitService.verifieAutorisationByEtablissement(\r
- securiteSession,\r
- classe.etablissement,\r
- Action.CONSULTATION,\r
- NotesFonction.DIRECTION_ASSIMILE)\r
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables\r
+// notesDroitService.verifieAutorisationByEtablissement(\r
+// securiteSession,\r
+// classe.etablissement,\r
+// Action.CONSULTATION,\r
+// NotesFonction.DIRECTION_ASSIMILE)\r
\r
List<BrevetSerie> series = PersonneProprietesScolarite.createCriteria().listDistinct {\r
createAlias('personne', 'personne')\r
* @author jtra
*/
public enum Fonctionnalite {
- SAISIE_TABLEAU_DE_NOTES,
+ SAISIE_NOTES, // == Notes et appreciations
+ SAISIE_NOTES_ENSEIGNANTS, // == Notes et appreciations Enseignants
SAISIE_SYNTHESE,
SAISIE_EVALUATION,
SAISIE_CONSEIL_DE_CLASSE,
SAISIE_APPRECIATIONS,
SAISIE_BREVET,
- CONSULTATION_TABLEAU_DE_NOTES,
CONSULTATION_BULLETIN,
CONSULTATION_RELEVE_DE_NOTES,
CONSULTATION_APPRECIATION_CLASSE,
// prof || documentaliste || education (cpe) ont les même droits
if (hasNonParametrableFonctionIn(securiteSession, NotesFonction.ENSEIGNANT_ASSIMILE, etabId)) {
- fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_TABLEAU_DE_NOTES)
+ fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_NOTES)
fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_SYNTHESE)
fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_EVALUATION)
fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_BULLETIN)
fonctionnalitesAccessibles.add(Fonctionnalite.PARAMETRAGES_PERIODES)
fonctionnalitesAccessibles.add(Fonctionnalite.PARAMETRAGES_GENERAUX)
fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_SYNTHESE)
- fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_TABLEAU_DE_NOTES)
+ fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS)
fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_BULLETIN)
fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_RELEVE_DE_NOTES)
fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_APPRECIATION_CLASSE)
fonctionnalitesAccessibles.add(Fonctionnalite.PUBLIPOSTAGE_SUIVI_IMPRESSION)
}
+ if (securiteSession.hasAccesFonctionnalite(NotesFonctionnalite.NOTES_SAISIE_NOTES_ENSEIGNANTS, etabId)) {
+ fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS)
+ }
+
if (securiteSession.hasAccesFonctionnalite(NotesFonctionnalite.NOTES_SAISIE_SYNTH, etabId)) {
fonctionnalitesAccessibles.add(Fonctionnalite.SAISIE_SYNTHESE)
}
- if (securiteSession.hasAccesFonctionnalite(NotesFonctionnalite.NOTES_CONSULT_NOTES, etabId)) {
- fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_TABLEAU_DE_NOTES)
- }
if (securiteSession.hasAccesFonctionnalite(NotesFonctionnalite.NOTES_CONSULT_RELEVE_BULLETIN, etabId)) {
fonctionnalitesAccessibles.add(Fonctionnalite.CONSULTATION_BULLETIN)
/**
* Vérifie si l'utilisateur a le droit d'accéder cette fonctionnalité
- * @param session
- * @param etabId
- * @param foncionnalite
- * @return true/false
* @author msan
*/
Boolean isFonctionnaliteAccesible(def session,
import org.lilie.services.eliot.notes.page.Page
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.menu.MenuItemSeparateur
-
+import org.lilie.services.eliot.notes.NotesDroitService
+import org.lilie.services.eliot.notes.NotesFonctionnalite
/**
* Permet d'obtenir les informations de construction du menu
* @author othe
AnneeScolaireService anneeScolaireService
FonctionnaliteService fonctionnaliteService
+ NotesDroitService notesDroitService
/**
* Retourne le nom de l'établissement et l'année scolaire courante.
// --------- Saisie
boolean menuSaisieVisible =
- fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_TABLEAU_DE_NOTES) ||
+ fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_NOTES) ||
+ fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS) ||
fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_SYNTHESE) ||
fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_BREVET)
getMenuInfoSaisie(menuSaisieVisible, pageCourante, menuInfo, fonctionnalitesAccessibles)
boolean menuConsultationVisible =
fonctionnalitesAccessibles.contains(Fonctionnalite.CONSULTATION_BULLETIN) ||
fonctionnalitesAccessibles.contains(Fonctionnalite.CONSULTATION_RELEVE_DE_NOTES) ||
- fonctionnalitesAccessibles.contains(Fonctionnalite.CONSULTATION_TABLEAU_DE_NOTES) ||
+ fonctionnalitesAccessibles.contains(Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS) ||
fonctionnalitesAccessibles.contains(Fonctionnalite.CONSULTATION_APPRECIATION_CLASSE)
getMenuInfoConsultation(menuConsultationVisible, pageCourante, menuInfo, fonctionnalitesAccessibles)
// --------- Etablissements
// EtablissementMenuItemInfo gére elle-même si elle est affichée où pas
MenuItemInfo menuEtab = new EtablissementMenuItemInfo(
+ securiteSession,
+ Etablissement.get(etablissementId),
+ 'notes.menu.etablissement.titrePrincipal',
+ pageCourante,
+ { Etablissement etablissement ->
+ return notesDroitService.hasDroitSurFonctionnalitesParametrable(
securiteSession,
- Etablissement.get(etablissementId),
- 'notes.menu.etablissement.titrePrincipal',
- pageCourante)
+ etablissement,
+ NotesFonctionnalite.values() as List,
+ {
+ return true
+ }
+ )
+ }
+ )
if (!menuEtab.isEmpty()) {
menuInfo.items << menuEtab
menuType: 'menuitem',
selectionne: (
(Page.SAISIE_SYNTHESE == pageCourante) ||
- (Page.SAISIE_TABLEAU_DE_NOTES == pageCourante) ||
+ (Page.SAISIE_NOTES == pageCourante) ||
+ (Page.SAISIE_NOTES_ENSEIGNANTS == pageCourante) ||
(Page.SAISIE_BREVET == pageCourante)
)
)
menuInfo.items << menuSaisie
if (fonctionnalitesAccessibles.contains(
- Fonctionnalite.SAISIE_TABLEAU_DE_NOTES
+ Fonctionnalite.SAISIE_NOTES
)) {
menuSaisie.items << new MenuItemInfo(
- codeLabel: 'notes.menu.saisie.tableauDeNotes.titrePrincipal',
+ codeLabel: 'notes.menu.saisie.notes.titrePrincipal',
controleur: 'saisieTableauDeNotes',
action: 'index',
menuType: 'menuitem',
- selectionne: (Page.SAISIE_TABLEAU_DE_NOTES == pageCourante)
+ selectionne: (Page.SAISIE_NOTES == pageCourante)
+ )
+ }
+
+ if (fonctionnalitesAccessibles.contains(
+ Fonctionnalite.SAISIE_NOTES_ENSEIGNANTS
+ )) {
+ menuSaisie.items << new MenuItemInfo(
+ codeLabel: 'notes.menu.saisie.notesEnseignants.titrePrincipal',
+ controleur: 'consultationTableauDeNotes',
+ action: 'index',
+ menuType: 'menuitem',
+ selectionne: (Page.SAISIE_NOTES_ENSEIGNANTS == pageCourante)
)
}
codeLabel: 'notes.menu.consultation.titrePrincipal',
menuType: 'menuitem',
selectionne: (
- (Page.CONSULTATION_TABLEAU_DE_NOTES == pageCourante) ||
(Page.CONSULTATION_BULLETIN == pageCourante) ||
(Page.CONSULTATION_RELEVE_DE_NOTES == pageCourante) ||
(Page.CONSULTATION_APPRECIATION_CLASSE == pageCourante)
menuInfo.items << menuConsultation
- if (fonctionnalitesAccessibles.contains(
- Fonctionnalite.CONSULTATION_TABLEAU_DE_NOTES
- )) {
- menuConsultation.items << new MenuItemInfo(
- codeLabel: 'notes.menu.consultation.tableauDeNotes.titrePrincipal',
- controleur: 'consultationTableauDeNotes',
- action: 'index',
- menuType: 'menuitem',
- selectionne: (Page.CONSULTATION_TABLEAU_DE_NOTES == pageCourante)
- )
- }
-
if (fonctionnalitesAccessibles.contains(
Fonctionnalite.CONSULTATION_RELEVE_DE_NOTES
)) {
\r
List<NoteTextuelleInfo> findAllNoteTextuelleAvecUtilisation(SecuriteSession securiteSession,\r
Etablissement etablissement) {\r
- notesDroitService.verifieAutorisationByEtablissement(\r
- securiteSession,\r
- etablissement,\r
- Action.CONSULTATION,\r
- NotesFonction.DIRECTION_ASSIMILE\r
- )\r
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables\r
+// notesDroitService.verifieAutorisationByEtablissement(\r
+// securiteSession,\r
+// etablissement,\r
+// Action.CONSULTATION,\r
+// NotesFonction.DIRECTION_ASSIMILE\r
+// )\r
\r
List<NoteTextuelle> notesTextuelles = NoteTextuelle.withCriteria {\r
eq('etablissement', etablissement)\r
List<NoteTextuelle> findAllNoteTextuelle(SecuriteSession securiteSession,\r
Etablissement etablissement) {\r
\r
+/*\r
notesDroitService.verifieAutorisationByEtablissement(\r
securiteSession,\r
etablissement,\r
NotesFonction.ENSEIGNANT_ASSIMILE +\r
[FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]\r
)\r
- \r
+*/\r
return internalFindAllNoteTextuelle(etablissement)\r
}\r
\r
throw new IllegalArgumentException("Le paramètre {periode} ne doit pas être null")
}
+/*
notesDroitService.verifieAutorisationByEleve(
securiteSession,
eleve,
[FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
)
)
+*/
// pour les parents/eleves verifie si les releves sont publies
if (!internalIsRelevePublie(securiteSession, periode)) {
checkArgumentNotNull('enseignement', enseignement)
checkArgumentNotNull('typePeriode', typePeriode)
- verifieAutorisationConstruisTableauDeNotes(securiteSession, enseignement)
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationConstruisTableauDeNotes(securiteSession, enseignement)
// Récupère les informations sur les élèves (actifs & inactifs)
StructureEnseignementElevesListes elevesListes =
correctionParDirecteur ? enseignantCorrige.autorite : operateurSaisie.autorite
)
- verifieAutorisationEnregistreTableauDeNotes(
- securiteSession,
- enseignement
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// verifieAutorisationEnregistreTableauDeNotes(
+// securiteSession,
+// enseignement
+// )
// Période - liste d'élèves
Map<Periode, List<Autorite>> mapPeriodeEleves = (Map) [:]
TypePeriode typePeriode,
NaturePeriode nature) {
+/*
notesDroitService.verifieAutorisationByEtablissement(
securiteSession,
classe.etablissement,
NotesFonction.DIRECTION_ASSIMILE
)
)
+*/
// Get all services with relModaliteMatiereService et modaliteMatieres
List<Service> services = getServicesEtModaliteMatieres(
throws AutorisationException {
// vérifie les droits d'accès
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE +
- [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classe.etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE +
+// [FonctionEnum.ELEVE, FonctionEnum.PERS_REL_ELEVE]
+// )
+// )
// remonte la liste des Service
List<Service> services = Service.createCriteria().listDistinct {
StructureEnseignement classe,
Periode periode) {
- notesDroitService.verifieAutorisationByClasse(
+ /*Gestion des droits de direction*/
+ boolean hasDroitsDirection = notesDroitService.hasDroitsDirection(
securiteSession,
- classe,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
+ true,
+ classe.etablissement
)
+ /**/
+
+ if (!hasDroitsDirection){
+ notesDroitService.verifieAutorisationByClasse(
+ securiteSession,
+ classe,
+ Action.CONSULTATION,
+ (List) (FonctionEnum.ENSEIGNANT +
+ FonctionEnum.DOCUMENTALISTE
+ )
+ )
+ }
// Les services et tous ses groupes et de regroupements
List<Service> services = notesServiceService.findAllServiceByClasseAndPeriodes(
securiteSession,
classe,
[periode],
+ true,
+ false,
+ false,
true)
// Trie les services dans l'ordre defini pour la période donnée
// Synthèses (les moyennes et l'appréciation) des élèves
List<SyntheseEleve> syntheseEleves = syntheseEleveService.
construisAllSyntheseEleveForClasse(
- securiteSession,
- classe,
- services,
- periode)
+ securiteSession,
+ classe,
+ services,
+ periode)
// Synthèse de la classe
SyntheseClasse syntheseClasse = syntheseClasseService.
internalConstruisSyntheseClasse(
- classe,
- services,
- periode)
+ classe,
+ services,
+ periode)
Synthese synthese = new Synthese()
synthese.classe = classe
AnneeScolaire anneeScolaire = getAnneeEnCours())
throws AutorisationException {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE
+// )
+// )
List<Service> services = Service.createCriteria().list {
createAlias("relPeriodeServices", "relPS")
throws AutorisationException, IllegalArgumentException {
//verifier l'authorisation de consultation d'une periode
+/*
notesDroitService.verifieAutorisationByEtablissement(
securiteSession,
classe.etablissement,
NotesFonction.DIRECTION_ASSIMILE
)
)
+*/
if (classe == null) {
throw new IllegalArgumentException("Le paramètre {classe} ne doit pas être null")
TypePeriode typePeriode) {
//verifier l'authorisation de consultation d'une periode
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- structureEnseignement.etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// structureEnseignement.etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE
+// )
+// )
// Crée les périodes pour la structure d'enseignement du service
creePeriodesNotationPourStructureEnseignement(structureEnseignement)
}
//verifier l'authorisation de consultation d'une periode
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- service.structureEnseignement.etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// service.structureEnseignement.etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE
+// )
+// )
// Crée les périodes pour la structure d'enseignement du service
creePeriodesNotationPourStructureEnseignement(service.structureEnseignement)
StructureEnseignement classe) throws AutorisationException {
//verifier l'authorisation de consultation d'une periode
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classe.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (!classe) {
throw new IllegalArgumentException(
)
}
- notesDroitService.verifieAutorisationByClasse(
- securiteSession,
- periode.classe,
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByClasse(
+// securiteSession,
+// periode.classe,
+// Action.MODIFICATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
TypePeriode typePeriode = periodeParams.typePeriode
Date dateDebut = periodeParams.dateDebut
)
}
- notesDroitService.verifieAutorisationByClasse(
- securiteSession,
- classe,
- Action.CREATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByClasse(
+// securiteSession,
+// classe,
+// Action.CREATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
Periode periode = new Periode(
typePeriode: typePeriode,
)
}
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- periode.classe.etablissement,
- Action.SUPPRESSION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// periode.classe.etablissement,
+// Action.SUPPRESSION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (periode.isPeriodeNotation()) {
throw new IllegalArgumentException(
Boolean periodeHasNotes(SecuriteSession securiteSession,
Periode periode) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- periode.classe.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// periode.classe.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (!periode) {
throw new IllegalArgumentException("Le paramètre {periode} ne doit pas etre null")
Boolean periodeHasAppreciations(SecuriteSession securiteSession,
Periode periode) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- periode.classe.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// periode.classe.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (!periode) {
throw new IllegalArgumentException("Le paramètre {periode} ne doit pas etre null")
Service service,
TypePeriode typePeriode) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- service.structureEnseignement.etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// service.structureEnseignement.etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE
+// )
+// )
TypePeriode typePeriodeEquivalent =
notesTypePeriodeService.getTypePeriodeEquivalent(
}
classeCibles.each {StructureEnseignement classeCible ->
- // Vérifie autorisation pour chaque classe modifiée
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classeCible.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+ // Vérifie autorisation pour chaque classe mod
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrablesifiée
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classeCible.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
if (applyToNotation) {
if (classeCible.typeIntervalle &&
// DIRECTEUR / CHEF TRAVAUX / ADMIN LOCAL : tous les élèves de la classe
- if (securiteSession.hasFonctionIn(
- NotesFonction.DIRECTION_ASSIMILE,
- classe.etablissement.id)) {
+ if (notesDroitService.hasDroitsDirection(securiteSession, true, classe.etablissement)) {
+
eleves = eleveAnnuaireService.findStructureEnseignementElevesListes(
securiteSession,
classe
private void verifieAutorisationModifieService(SecuriteSession securiteSession,
NotesServiceParams serviceParams)
throws AutorisationException {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- serviceParams.service.structureEnseignement.etablissement,
- Action.MODIFICATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// serviceParams.service.structureEnseignement.etablissement,
+// Action.MODIFICATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
}
/**
private void verifieAutorisationCreeService(SecuriteSession securiteSession,
NotesServiceParams notesServiceParams)
throws AutorisationException {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- notesServiceParams.structure.etablissement,
- Action.CREATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// notesServiceParams.structure.etablissement,
+// Action.CREATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
}
/**
Etablissement etablissement)
throws AutorisationException {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
- NotesFonction.DIRECTION_ASSIMILE
- )
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.ENSEIGNANT_ASSIMILE +
+// NotesFonction.DIRECTION_ASSIMILE
+// )
+// )
List<Enseignement> enseignements = notesEnseignementService.
findAllEnseignementForAutorite(
* @param typePeriode
* @return
*/
- Boolean serviceEvaluableDansAutrePeriodes(SecuriteSession securiteSesion,
- Service service,
+ Boolean serviceEvaluableDansAutrePeriodes(Service service,
NaturePeriode naturePeriodeEnum,
TypePeriode typePeriode) {
// vérifie evaluabilité du service
Long relCount = relPeriodeServiceService.
- calculeServicesEvaluablesDehorsPeriodes(securiteSesion, service,
+ calculeServicesEvaluablesDehorsPeriodes(service,
naturePeriodeEnum, typePeriode)
return relCount > 0
}
// 2) Si le service a des evaluations -> il a aussi des notes
// -> des ResultatsESP -> des ResultatsCSP
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- service.structureEnseignement.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// service.structureEnseignement.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
// vérifie sous-services
Boolean hasDonnees = service.sousServices?.size() > 0
void supprimeService(SecuriteSession securiteSession, Service service)
throws AutorisationException {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- service.structureEnseignement.etablissement,
- Action.SUPPRESSION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// service.structureEnseignement.etablissement,
+// Action.SUPPRESSION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
// marque REP, RCP pour recalcul
uptodateService.marqueDirtyService(securiteSession, service)
Etablissement etablissement = (Etablissement) mapEtabClasse.keySet().toList().first()
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.DIRECTION_ASSIMILE)
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.DIRECTION_ASSIMILE)
+// )
List<BrevetRelEpreuveMatiere> rels = BrevetRelEpreuveMatiere.createCriteria().list {
matiere {
Etablissement etablissement = (Etablissement) mapEtabClasse.keySet().toList().first()
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- (List) (NotesFonction.DIRECTION_ASSIMILE)
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// (List) (NotesFonction.DIRECTION_ASSIMILE)
+// )
return Service.createCriteria().listDistinct {
'in'('structureEnseignement', classes)
Service service) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classe.etablissement,
- Action.MODIFICATION,
- (List) (NotesFonction.DIRECTION_ASSIMILE)
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classe.etablissement,
+// Action.MODIFICATION,
+// (List) (NotesFonction.DIRECTION_ASSIMILE)
+// )
if (service && classe.id != service.structureEnseignement.id) {
throw new IllegalArgumentException(
* Retourne la liste des classes pour l'utilisateur connecté par rapport à
* l'action qu'il a le droit à effectuer sur les informations relatives à
* ces classes.
- * @param securiteSession
- * @param etablissement
- * @param action
- * @author bper
- * @return List < StructureEnseignement >
*/
List<StructureEnseignement> findAllClasseForUtilisateur(SecuriteSession securiteSession,
Etablissement etablissement,
- Action action) {
+ Action action,
+ boolean fonctionnaliteParametrable = true) {
List<StructureEnseignement> classes = []
+
Autorite autorite = securiteSession.defaultAutorite
Personne utilisateur = localPersonneService.findPersonneByAutorite(autorite)
+ /*Gestion des droits de direction*/
+ boolean hasDroitsDirection = notesDroitService.hasDroitsDirection(
+ securiteSession,
+ fonctionnaliteParametrable,
+ etablissement
+ )
+ /**/
+
switch (action) {
case (Action.CONSULTATION):
// DIRECTEUR: peut consulter les infos de toutes les classes de l'établissement
- if (
- securiteSession.hasFonctionIn(
- NotesFonction.DIRECTION_ASSIMILE,
- etablissement.id
- )
- ) {
+ if (hasDroitsDirection) {
classes = findAllClasseByEtablissement(etablissement)
}
// ENSEIGNANT: peut consulter les infos des classes de l'établissement dans
// lesquelles il enseigne ou il est prof principal
else if (
- securiteSession.hasFonctionIn(
- NotesFonction.ENSEIGNANT_ASSIMILE,
- etablissement.id
- )
+ securiteSession.hasFonctionIn(
+ NotesFonction.ENSEIGNANT_ASSIMILE,
+ etablissement.id
+ )
) {
// Les classes dans lesquelles il est enseignant
classes = findAllClasseByEnseignantAndEtablissement(
)
// Les classes dans lesquelles il est prof principal
List<StructureEnseignement> classesProfPrincipal =
- findAllClasseForProfesseurPrincipalForEtablissement(
- securiteSession,
- utilisateur,
- etablissement
- )
+ findAllClasseForProfesseurPrincipalForEtablissement(
+ securiteSession,
+ utilisateur,
+ etablissement
+ )
classes.addAll(classesProfPrincipal)
}
// RESPONSABLE: peut consulter les infos des classes des élèves dont il est responsable
else if (
- securiteSession.hasFonctionIn(
- [FonctionEnum.PERS_REL_ELEVE],
- etablissement.id
- )
+ securiteSession.hasFonctionIn(
+ [FonctionEnum.PERS_REL_ELEVE],
+ etablissement.id
+ )
) {
List<Personne> eleves =
- eleveAnnuaireService.findAllEleveFromResponsableForEtablissement(
- utilisateur,
- (Etablissement) securiteSession.etablissementCourant
- )
+ eleveAnnuaireService.findAllEleveFromResponsableForEtablissement(
+ utilisateur,
+ (Etablissement) securiteSession.etablissementCourant
+ )
eleves.each {
List<StructureEnseignement> classeEleves = findAllClasseForEleve(securiteSession, it)
classes.addAll(classeEleves)
}
// ELEVE: peut consulter uniquement les infos de ses classes (actuelles et anciennes)
else if (
- securiteSession.hasFonctionIn([FonctionEnum.ELEVE], etablissement.id)
+ securiteSession.hasFonctionIn([FonctionEnum.ELEVE], etablissement.id)
) {
classes = findAllClasseForEleve(securiteSession, utilisateur)
}
case (Action.SUPPRESSION):
// DIRECTEUR: peut créer/modifier/supprimer les infos relatives à toutes
// les classes de l'établissement
- if (
- securiteSession.hasFonctionIn(
- NotesFonction.DIRECTION_ASSIMILE,
- etablissement.id
- )
- ) {
+ if (hasDroitsDirection) {
classes = findAllClasseByEtablissement(etablissement)
}
// ENSEIGNANT: peut créer/modifier/supprimer les infos relatives aux classes
// de l'établissement dans lesquelles est prof principal
else if (
- securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT], etablissement.id)
+ securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT], etablissement.id)
) {
// Les classes dans lesquelles il est prof principal
classes = findAllClasseForProfesseurPrincipalForEtablissement(
List<StructureEnseignement> findAllClasseReportParamApplicable(SecuriteSession securiteSession,
StructureEnseignement classeSource) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- classeSource.etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// classeSource.etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
return StructureEnseignement.withCriteria {
ne('id', classeSource.id)
*/
List<StructureEnseignement> findAllClasseForEtablissementAvecPeriodes(SecuriteSession securiteSession,
Etablissement etablissement) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
StructureEnseignement.withCriteria {
eq('anneeScolaire',anneeScolaireService.anneeScolaireEnCours())
Etablissement etablissement,
NaturePeriode naturePeriode,
TypePeriode typePeriodeCherche) {
- notesDroitService.verifieAutorisationByEtablissement(
- securiteSession,
- etablissement,
- Action.CONSULTATION,
- NotesFonction.DIRECTION_ASSIMILE
- )
+// TOREFACT gérer droits pour fonctionnalités et fonctions paramétrables
+// notesDroitService.verifieAutorisationByEtablissement(
+// securiteSession,
+// etablissement,
+// Action.CONSULTATION,
+// NotesFonction.DIRECTION_ASSIMILE
+// )
return StructureEnseignement.createCriteria().listDistinct {
eq('anneeScolaire',anneeScolaireService.anneeScolaireEnCours())
//Tester si le service1classe1 est evaluable dans d'autres periodes que celles de notation {PerodeBrevet}
Boolean serviceEvaluable = notesServiceService.serviceEvaluableDansAutrePeriodes(
- securiteSessionDirecteur,
service1classe1,
natureNotation,
typePeriode)
typePeriode = periodeBrevet.typePeriode
serviceEvaluable = notesServiceService.serviceEvaluableDansAutrePeriodes(
- securiteSessionDirecteur,
service1classe1,
natureExamen,
typePeriode)
rel5.save()
typePeriode = null
serviceEvaluable = notesServiceService.serviceEvaluableDansAutrePeriodes(
- securiteSessionDirecteur,
service1classe1,
natureNotation,
typePeriode)
import org.lilie.services.eliot.scolarite.page.Page
import org.lilie.services.eliot.securite.AutorisationException
+import org.lilie.services.eliot.annuaire.EliotFonctionnalites
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.scolarite.menu.description.MenuSousMenu
+import org.lilie.services.eliot.scolarite.menu.description.MenuEntete
+/**
+ *
+ * @author othe
+ */
class ApplicationController extends AbstractScolariteController {
def index = {
return
}
- chain(controller: 'gestionSynchroEdt')
+ if (securiteSession.hasFonctionIn([FonctionEnum.DIRECTION])) {
+ chain(controller: 'gestionSynchroEdt')
+ } else {
+
+ Page page = getDefaultPage()
+
+ if (!page) {
+ throw AutorisationException.consultationContenuException()
+ }
+
+ Lien lien = getLien(page)
+
+ if (lien) {
+ chain(
+ controller: lien.controller,
+ action: lien.action
+ )
+ } else {
+ throw AutorisationException.consultationContenuException()
+ }
+ }
+
+
}
}
"Page de retour inconnue : " + params.page
)
}
+
+ Lien lien = getLien(page)
+ if (lien) {
+ redirect(
+ controller: lien.controller,
+ action: lien.action
+ )
+
+ } else {
+ redirect(
+ controller: 'gestionSynchroEdt',
+ action: 'index'
+ )
+
+ }
+ }
+
+ private Lien getLien(Page page) {
+
switch (page) {
case Page.PARAMETRAGE_NIVEAU:
- redirect(
+ return new Lien(
controller: 'niveauParametrage',
- action: 'index'
+ action: 'index'
)
break
case Page.PARAMETRAGE_MATIERES:
- redirect(
+ return new Lien(
controller: 'parametragesMatieres',
action: 'index'
)
break
case Page.IMPORT_STS:
- redirect(
+ return new Lien(
controller: 'gestionSynchroEdt',
action: 'index'
)
break
case Page.PARAMETRAGE_CALENDRIER_HEBDO:
- redirect(
+ return new Lien(
controller: 'parametrageCalendrierHebdo',
action: 'index'
)
break
case Page.PARAMETRAGE_CALENDRIER_ANNUEL:
- redirect(
+ return new Lien(
controller: 'parametrageCalendrierAnnuel',
action: 'index'
)
break
case Page.PARAMETRAGE_MODELE_DOCUMENT:
- redirect(
+ return new Lien(
controller: 'impressionEdition',
action: 'index'
)
break
case Page.PARAMETRAGE_ACCES_VIE_SCOLAIRE:
- redirect(
+ return new Lien(
controller: 'accesVieScolaire',
action: 'index'
)
break
case Page.PARAMETRAGE_NOTIFICATION:
- redirect(
+ return new Lien(
controller: 'notificationParametrage',
action: 'index'
)
break
case Page.PARAMETRAGE_TYPES_ACTIVITES_DEVOIRS:
- redirect(
+ return new Lien(
controller: 'typesActivitesDevoirs',
action: 'index'
)
break
case Page.NOTIFICATION_PREFERNCE_UTILISATEUR:
- if (droitsService.hasNotificationPreferenceUtilisateur(
- securiteSession, etablissementCourant())
- ) {
- redirect(
- controller: 'notificationPreferenceUtilisateur',
- action: 'index'
- )
- }
- break
-
- default:
- redirect(
- controller: 'gestionSynchroEdt',
+ return new Lien(
+ controller: 'notificationPreferenceUtilisateur',
action: 'index'
)
break
+
+ default:
+ return null
}
+ }
+
+ private Page getDefaultPage() {
+
+ Page page = null
+
+ List<EliotFonctionnalites> allFonctionnalite =
+ droitsService.findAllFonctionnalite(getSecuriteSession(), etablissementCourant())
+
+ MenuEntete.each {
+
+ MenuEntete menuEntete ->
+
+ if (!page) {
+ if (allFonctionnalite.find {it.getCode() == menuEntete.fonctionnalite.getCode()}) {
+ if (menuEntete.page != Page.PARAMETRAGE_ACCES_FONCTIONS) {
+ page = (Page) menuEntete.page
+ }
+
+ }
+ }
+
+ MenuSousMenu.each {MenuSousMenu menuSousMenu ->
+ if (!page) {
+
+ if (menuSousMenu.menuEnteteEnum == menuEntete) {
+
+ if (allFonctionnalite.find {it.getCode() == menuSousMenu.fonctionnalite.getCode()}) {
+
+ if (menuSousMenu.page != Page.PARAMETRAGE_ACCES_FONCTIONS) {
+ page = (Page) menuSousMenu.page
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+ return page
}
+
+
}
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
breadCrumbsInfo << new BreadCrumbsItemInfo(
- codeLabel: 'absences.breadCrumbs.preferences'
-
+ codeLabel: 'scolarite.breadCrumbs.preferences'
)
return breadCrumbsInfo
/**
* La liste des groupes de pages de l'application eliot-notes
*
- * @author jtra, ywan
+ * @author jtra, ywan
+ * @deprecated
+ * TOREFACT : (othe) à supprimer
*/
public enum GroupePage {
PARAMETRAGE,
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionParams
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnalitePersonneElement
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnalitePersonneParams
+import org.lilie.services.eliot.securite.fonctionnalite.FonctionAnnuaireService
+import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
/**
* @author bahj , othe
SaisieFonctionnaliteService saisieFonctionnaliteService
SaisieFonctionnaliteMarshallerService saisieFonctionnaliteMarshallerService
+ FonctionAnnuaireService fonctionAnnuaireService
def index = {
Map model = prepareBaseModele(Page.PARAMETRAGE_ACCES_FONCTIONS)
- Etablissement etablissement = etablissementCourant()
-
-
List<Fonction> allFonctionParametrable =
- saisieFonctionnaliteService.findAllfonction()
+ fonctionAnnuaireService.getAllFonctionParametrable()
+
List<Personne> allPersonneParametrable =
- saisieFonctionnaliteService.findAllPersonne(etablissement)
+ saisieFonctionnaliteService.findAllPersonne(etablissementCourant())
model.fonctionsData = saisieFonctionnaliteMarshallerService.
marshallAllFonctionParametrable(allFonctionParametrable) as JSON
fonctionnalite.parametrage.ABS_PUBLIPOSTAGE=Publipostage
fonctionnalite.parametrage.NOTES=Notes
fonctionnalite.parametrage.NOTES_SAISIE=Saisie
+fonctionnalite.parametrage.NOTES_SAISIE_NOTES_ENSEIGNANTS=Notes et appr\u00e9ciations Enseignants
fonctionnalite.parametrage.NOTES_SAISIE_SYNTH=Synth\u00e8ses
fonctionnalite.parametrage.NOTES_SAISIE_SYNTH_CONSEIL=Conseil de classe
fonctionnalite.parametrage.NOTES_SAISIE_BREVET=Fiches Brevet
fonctionnalite.parametrage.NOTES_CONSULT=Consultation
-fonctionnalite.parametrage.NOTES_CONSULT_NOTES=Notes et appr\u00e9ciations
-fonctionnalite.parametrage.NOTES_CONSULT_NOTES_MODIF=Modification
fonctionnalite.parametrage.NOTES_CONSULT_RELEVE_BULLETIN=Relev\u00e9s de notes/Bulletins
fonctionnalite.parametrage.NOTES_CONSULT_APPR=Appr\u00e9ciations classes
fonctionnalite.parametrage.NOTES_PARAM=Param\u00e9trages
package org.lilie.services.eliot.scolarite
-import org.lilie.services.eliot.scolarite.fonctionnalites.ScolariteFonctionnalite
-import org.lilie.services.eliot.fonctionnalites.EliotFonctionnalite
import org.lilie.services.eliot.droits.EliotDroitsService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
-import org.codehaus.groovy.grails.commons.GrailsApplication
-import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
/**
class DroitsService extends EliotDroitsService {
static transactional = true
- PreferenceEtablissementService preferenceEtablissementService
- // jcok : grailsApplication est un singleton
- @SuppressWarnings('GrailsStatelessService')
- GrailsApplication grailsApplication
- //TOIMPL: à retirer droit accès à la page de maintenance pour le directeur
public List<EliotFonctionnalites> findAllFonctionnalite(SecuriteSession securiteSession,
Etablissement etablissementCourant
) {
ScolariteFonctionnalites.each {
allFonctionnalite << it
}
+
}
return allFonctionnalite.toList()
}
-
- private Boolean isDirectionAdminLocalOuCorrespondant(SecuriteSession securiteSession,
- Etablissement etablissement) {
- return (
- securiteSession.hasFonctionIn(
- [FonctionEnum.DIRECTION],
- etablissement.id
- ) ||
- securiteSession.hasFonctionIn(
- [FonctionEnum.ADMIN_LOCAL],
- etablissement.id
- ) ||
- securiteSession.hasFonctionIn(
- [FonctionEnum.CORRESPONDANT_DEPLOIEMENT],
- etablissement.id
- )
- )
-
- }
-
- private Boolean isDirectionAdminLocalCorrespondantOuEducation(SecuriteSession securiteSession,
- Etablissement etablissement) {
-
- return (isDirectionAdminLocalOuCorrespondant(securiteSession, etablissement) ||
- (securiteSession.hasFonctionIn(
- [FonctionEnum.EDUCATION],
- etablissement.id
- ))
- )
-
- }
-
-
- protected Boolean hasNotificationPreferenceUtilisateur(SecuriteSession securiteSession,
- Etablissement etablissement) {
- if (ConfigurationHolder.config.eliot.notification.actif) {
- return securiteSession.hasFonctionIn(
- [
- FonctionEnum.EDUCATION,
- FonctionEnum.DIRECTION,
- FonctionEnum.ADMIN_LOCAL,
- FonctionEnum.CHEF_TRAVAUX,
- FonctionEnum.ENSEIGNANT,
- FonctionEnum.PERS_REL_ELEVE,
- FonctionEnum.ELEVE,
- ],
- etablissement.id
- )
- }
-
- return false
- }
-
- /**
- * Retourne la liste des fonctionnalités d'eliot-scolarite
- * @return
- */
- protected List<EliotFonctionnalite> getFonctionnalites() {
- List<EliotFonctionnalite> result = []
- result.addAll(
- ScolariteFonctionnalite.values().collect {
- (EliotFonctionnalite) it
- }
- )
- return result
- }
-
- /**
- * Indique si l'utilisateur a le droit de modifier le paramétrage
- * @param pref : la préférenceEtablissement
- * @param securiteSession : la session de sécurité
- * @return true si l'utilisateur peut modifier le paramétrage, faux sinon
- */
-// public Boolean getDroitModificationParam(PreferencesEtablissementAbsences pref,
-// SecuriteSession securiteSession
-// ) {
-// return securiteSession.hasFonctionIn(
-// [
-// FonctionEnum.EDUCATION,
-// FonctionEnum.DIRECTION
-// ],
-// pref.etablissement.id
-// )
-// }
-
}
--- /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
+
+class Lien {
+
+ String controller
+ String action
+
+}
import org.lilie.services.eliot.VerificateurDroitsAcces
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
/**
* Droits d'accès à eliot-scolarite (par rapport au profil d'utilisateur)
static scope = 'session'
+ DroitsService droitsService
+
Boolean verifieDroitsAccess(def session) {
+ boolean hasAcces = false
+
SecuriteSession securiteSession = SessionUtils.securiteSession(session)
- Long etabId = securiteSession.etablissementCourant.id
if (!securiteSession.defaultAutorite.aUnAccesRetreint()) {
- if (securiteSession.hasFonctionIn(
- [
- FonctionEnum.DIRECTION
- ],etabId)) {
- return true
- }
-
- if (securiteSession.allFonctionnalite(etabId).size()>0){
- log.debug "Autorisation accordée par les fonctionnalités paramétrables."
- return true
-
- }
+ hasAcces = droitsService.hasDroitSurFonctionnalitesParametrable(
+ securiteSession,
+ securiteSession.getEtablissementsAccessibles(),
+ ScolariteFonctionnalites.values() as List,
+ {
+ return securiteSession.hasFonctionIn([FonctionEnum.DIRECTION],
+ securiteSession.etablissementCourant.id)
+ }
+ )
}
- log.warn(
- "La session ${securiteSession} n'est pas autorisée à accéder " +
- "à l'application eliot-scolarite"
- )
-
- return false
+ return hasAcces
}
}
import org.lilie.services.eliot.menu.Entete
/**
- * Description des entêtes de menu
+ *
+ * @author othe
*/
public enum MenuEntete implements Entete{
this.menuSpecial=menuSpecial
}
- /**
- * @param pageCourante
- * @param notificationActif
- * @return l'état "sélectionné" de l'item en fonction de la page courant
- * et de l'état d'activation des notifications
- */
- Boolean isSelectionne(def pageCourante) {
- return (pageCourante == this.page)
- }
-
}
\ No newline at end of file
/**
* Décrit les items de menu
- * @author jbui
* @author othe
- * TOREFACT : réordonner items
*/
public enum MenuSousMenu implements SousMenu{
'',
'',
Page.MAGISTERE,
- ScolariteFonctionnalites.MAGISTER,
+ ScolariteFonctionnalites.SCOL_MAGISTER,
MenuEntete.PARAMETRAGE_TITRE_PRINCIPAL,
SousMenuMagister
)
this.menuSpecial = menuSpecial
}
- /**
- * @param pageCourante
- * @param notificationActif
- * @return l'état "sélectionné" de l'item en fonction de la page courant
- * et de l'état d'activation des notifications
- */
- Boolean isSelectionne(def pageCourante) {
- return (pageCourante == this.page)
-
- }
-
}
\ No newline at end of file
import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
import org.lilie.services.eliot.menu.AbstractMenu
+/**
+ *
+ * @author othe
+ */
class SousMenuLVS extends AbstractMenu {
LiaisonSSOLvsService liaisonSSOLvsService
import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
import org.lilie.services.eliot.menu.AbstractMenu
+/**
+ *
+ * @author othe
+ */
class SousMenuMagister extends AbstractMenu {
LiaisonSSOMagisterService liaisonSSOMagisterService
import org.lilie.services.eliot.menu.SousMenuNormal
+/**
+ *
+ * @author othe
+ */
class SousMenuNotification extends SousMenuNormal {
public Boolean autoriseAjoutElementMenu() {