package org.lilie.services.eliot.absences
import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.securite.impl.Autorite
class Incident {
String description
Etablissement etablissement
PreferencesEtablissementAbsences preferencesEtablissementAbsences
+ Autorite auteur
static belongsto = [preferencesEtablissementAbsences : PreferencesEtablissementAbsences]
String modifAppelPasDecompte = null
Integer modifAppelValeur = null
- // Informations sur la saisie des incidents punitions par les enseignants
+ // Droits accordés sur la saisie des incidents et punitions aux enseignants
Boolean autoriseSaisieIncident = false
Boolean autoriseSaisiePunition = false
Boolean autoriseSaisieRetenue = false
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.securite.impl.Autorite
/**
* Décrit une punition
Motif motif
Etablissement etablissement
PreferencesEtablissementAbsences preferencesEtablissementAbsences
+ Autorite auteur
static belongsto = [preferencesEtablissementAbsences : PreferencesEtablissementAbsences]
--- /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
+
+import org.lilie.services.eliot.securite.EliotDroitsService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.AutorisationException
+
+class AbsencesDroitService extends EliotDroitsService {
+
+ static transactional = false
+
+ public void verifieDroitFonctionnaliteIncidentCUD(SecuriteSession securiteSession,
+ boolean autoriseSaisieIncident){
+ Boolean hasDroitCUDIncident =
+ hasDroitFonctionnalite(securiteSession,AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD) || autoriseSaisieIncident
+
+ if (!hasDroitCUDIncident) {
+ throw AutorisationException.consultationContenuException()
+ }
+ }
+
+ public void verifieDroitFonctionnalitePunitionCUD(SecuriteSession securiteSession,
+ boolean autoriseSaisiePunition){
+ Boolean hasDroitCUDPunition =
+ hasDroitFonctionnalite(securiteSession,AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD) || autoriseSaisiePunition
+
+ if (!hasDroitCUDPunition) {
+ throw AutorisationException.consultationContenuException()
+ }
+ }
+}
--- /dev/null
+<!--
+ ~ Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ ~ This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ ~
+ ~ Lilie is free software. You can redistribute it and/or modify since
+ ~ you respect the terms of either (at least one of the both license) :
+ ~ - under the terms of the GNU Affero General Public License as
+ ~ published by the Free Software Foundation, either version 3 of the
+ ~ License, or (at your option) any later version.
+ ~ - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ ~ License, or any later version
+ ~
+ ~ There are special exceptions to the terms and conditions of the
+ ~ licenses as they are applied to this software. View the full text of
+ ~ the exception in file LICENSE.txt in the directory of this software
+ ~ distribution.
+ ~
+ ~ Lilie is distributed in the hope that it will be useful,
+ ~ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ~ Licenses for more details.
+ ~
+ ~ You should have received a copy of the GNU General Public License
+ ~ and the CeCILL-C along with Lilie. If not, see :
+ ~ <http://www.gnu.org/licenses/> and
+ ~ <http://www.cecill.info/licences.fr.html>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="agia">
+ <comment>
+ Ajout de l'auteur de la punition ou de l'incident dans les tables correspondantes
+ </comment>
+
+ <addColumn
+ schemaName="enttemps" tableName="punition">
+ <column name="auteur_id" type="bigint">
+ <constraints nullable="true"/>
+ </column>
+ </addColumn>
+
+ <addForeignKeyConstraint
+ baseTableSchemaName="enttemps"
+ baseTableName="punition"
+ baseColumnNames="auteur_id"
+ constraintName="fk_punition_auteur"
+ referencedTableSchemaName="securite"
+ referencedTableName="autorite"
+ referencedColumnNames="id" />
+
+ <addColumn
+ schemaName="enttemps" tableName="incident">
+ <column name="auteur_id" type="bigint">
+ <constraints nullable="true"/>
+ </column>
+ </addColumn>
+
+ <addForeignKeyConstraint
+ baseTableSchemaName="enttemps"
+ baseTableName="incident"
+ baseColumnNames="auteur_id"
+ constraintName="fk_incident_auteur"
+ referencedTableSchemaName="securite"
+ referencedTableName="autorite"
+ referencedColumnNames="id" />
+
+ </changeSet>
+
+</databaseChangeLog>
+
<include file="changelogs/scolarite/2014-10-08-0039599.xml"/>
<include file="changelogs/scolarite/2014-10-09-0039604.xml"/>
<include file="changelogs/scolarite/2014-10-09-0039332.xml"/>
+ <include file="changelogs/scolarite/2014-10-15-0039332.xml"/>
<include file="changelogs/scolarite/2014-10-20-0039940.xml"/>
<include file="changelogs/scolarite/2014-10-21-0039942.xml"/>
-
+
</databaseChangeLog>
import org.lilie.services.eliot.absences.menu.description.MenuSousMenu
import org.lilie.services.eliot.absences.securite.DroitsService
import org.lilie.services.eliot.constantes.ConstDate
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.annuaire.FonctionEnum
/**
* Classe ancêtre embarquant des traitements génériques à tous les controleurs d'absences
final static Long VALEUR_TOUS = -1
+ final static String INCIDENT = 'incident'
+ final static String PUNITION = 'punition'
+ final static String RETENUE = 'retenue'
+
private MenuApplication getMenuApplication() {
return new MenuApplication(
return result
}
+ protected boolean isAutoriseSaisieIncident(SecuriteSession securiteSession,
+ Boolean activeCUD = null) {
+ return isAutoriseSaisieIncidentPunitionRetenue(securiteSession, activeCUD, INCIDENT)
+ }
+
+ protected boolean isAutoriseSaisiePunition(SecuriteSession securiteSession,
+ Boolean activeCUD = null) {
+ return isAutoriseSaisieIncidentPunitionRetenue(securiteSession, activeCUD, PUNITION)
+ }
+
+ protected boolean isAutoriseSaisieRetenue(SecuriteSession securiteSession,
+ Boolean activeCUD = null) {
+ return isAutoriseSaisieIncidentPunitionRetenue(securiteSession, activeCUD, RETENUE)
+ }
+
+
+
+ protected boolean isAutoriseUDIncident(SecuriteSession securiteSession,
+ Incident incident,
+ Boolean activeCUD = null) {
+ return isAutoriseUDIncidentPunitionRetenue(securiteSession, activeCUD, INCIDENT, incident)
+ }
+
+ protected boolean isAutoriseUDPunition(SecuriteSession securiteSession,
+ Punition punition,
+ Boolean activeCUD = null) {
+ return isAutoriseUDIncidentPunitionRetenue(securiteSession, activeCUD, PUNITION, punition)
+ }
+
+ protected boolean isAutoriseUDRetenue(SecuriteSession securiteSession,
+ Punition punition,
+ Boolean activeCUD = null) {
+ return isAutoriseUDIncidentPunitionRetenue(securiteSession, activeCUD, RETENUE, punition)
+ }
+
+
+ /*
+ Vérifie le droit de création d'un incident, d'une punition ou d'une retenue
+ */
+ private boolean isAutoriseSaisieIncidentPunitionRetenue(SecuriteSession securiteSession,
+ Boolean activeCUD,
+ String typeSaisie) {
+ if (typeSaisie != INCIDENT && typeSaisie != PUNITION && typeSaisie != RETENUE){
+ throw new IllegalStateException("""Cette méthode est destinée à retourner l'état des droits de saisie
+ des incidents, des punitions et des retenues.""")
+ }
+
+ if (activeCUD == null) {
+ activeCUD = droitsService.hasDroitFonctionnalite(
+ securiteSession,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
+ )
+ }
+ Boolean isEnseignant = securiteSession.hasFonctionIn(
+ [
+ FonctionEnum.ENSEIGNANT
+ ],
+ etablissementCourantId()
+ )
+ // si l'utilisateur n'a pas le droit de création des incidents mais qu'il
+ // est enseignant,
+ // on vérifie si les paramétrages généraux ne lui donnent pas le droit de
+ // création
+ if (!activeCUD && isEnseignant) {
+ PreferencesEtablissementAbsences preferences =
+ getPreferencesEtablissementCourant()
+ if (typeSaisie == INCIDENT){
+ return preferences.autoriseSaisieIncident
+ } else if (typeSaisie == PUNITION){
+ return preferences.autoriseSaisiePunition
+ } else if (typeSaisie == RETENUE){
+ return (preferences.autoriseSaisiePunition && preferences.autoriseSaisieRetenue)
+ }
+ }
+ return activeCUD
+ }
+
+ /*
+ Vérifie le droit de modification/suppression d'un incident, d'une punition ou d'une retenue
+ */
+ private boolean isAutoriseUDIncidentPunitionRetenue(SecuriteSession securiteSession,
+ Boolean activeCUD,
+ String typeSaisie,
+ def objet) {
+ if (typeSaisie != INCIDENT && typeSaisie != PUNITION && typeSaisie != RETENUE &&
+ (objet instanceof Incident || objet instanceof Punition)){
+ throw new IllegalStateException("""Cette méthode est destinée à retourner l'état des droits de
+ modification/suppression des incidents, des punitions et des retenues.""")
+ }
+
+ if (activeCUD == null) {
+ activeCUD = droitsService.hasDroitFonctionnalite(
+ securiteSession,
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
+ )
+ }
+ Boolean isEnseignant = securiteSession.hasFonctionIn(
+ [
+ FonctionEnum.ENSEIGNANT
+ ],
+ etablissementCourantId()
+ )
+ boolean isUtilisateurCourantAuteur = (securiteSession.defaultAutorite.id == objet.auteur?.id)
+ // si l'utilisateur n'a pas le droit de création des incidents mais qu'il
+ // est enseignant,
+ // on vérifie si les paramétrages généraux ne lui donnent pas le droit de
+ // création
+ if (!activeCUD && isEnseignant && isUtilisateurCourantAuteur) {
+ PreferencesEtablissementAbsences preferences =
+ getPreferencesEtablissementCourant()
+ if (typeSaisie == INCIDENT){
+ return preferences.autoriseSaisieIncident
+ } else if (typeSaisie == PUNITION){
+ return preferences.autoriseSaisiePunition
+ } else if (typeSaisie == RETENUE){
+ return (preferences.autoriseSaisiePunition && preferences.autoriseSaisieRetenue)
+ }
+ }
+ return activeCUD
+ }
+
/**
* Gestion du breadCrumbs : Les classes descendantes peuvent surcharger cette
* partie pour implémenter leur propre gestion.
int gravite
String partenairePrevenus
List protagonistes
+ Boolean isUtilisateurCourantAuteur
public String listeProtagonistes() {
String resultat = ""
String description
List<ProtagonisteModificationInfo> protagonistesModInfo = []
String idPartenaires
+ Boolean isUtilisateurCourantAuteur
}
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.constantes.ConstController
import org.lilie.services.eliot.absences.AbstractIncidentPunitionSanctionController
+import org.lilie.services.eliot.absences.AbsencesDroitService
/**
* @author bahj
AffichageIncidentService affichageIncidentService
EnumMarshallerService enumMarshallerService
LocalStructureEnseignementService localStructureEnseignementService
+ AbsencesDroitService absencesDroitService
/**
* Page de consultations des incidents
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
// construction du modèle
Map modele = prepareBaseModele(Page.SAISIE_INCIDENTS)
- modele.activeCRUD = droitsService.hasDroitFonctionnalite(
+ modele.activeCUD = droitsService.hasDroitFonctionnalite(
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
+ modele.autoriseSaisieIncident = isAutoriseSaisieIncident(securiteSession, modele.activeCUD)
+
if (params.criteres != null) {
modele.criteres = params.criteres
}
)
}
-
private void addFilterData(Map modele) {
PreferencesEtablissementAbsences preferences =
getPreferencesEtablissementCourant()
List<IncidentConsultationInfo> incidentInfos =
affichageIncidentService.getIncidentConsultationsInfos(
+ getSecuriteSession().defaultAutorite.id,
listeIncidents.incidents,
nomsAffichageByIdExterne
)
* Affiche la page de création d'un nouvel incident
*/
def afficheCreation = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnaliteIncidentCUD(
+ getSecuriteSession(),
+ isAutoriseSaisieIncident(getSecuriteSession())
+ )
+
+ // construction du modèle
+ Map modele = prepareBaseModele(Page.SAISIE_INCIDENTS)
Boolean isAnnuler = null
if (params.isAnnuler) {
isAnnuler = Boolean.parseBoolean(params.isAnnuler)
}
- // construction du modèle
- Map modele = prepareBaseModele(Page.SAISIE_INCIDENTS)
if (isAnnuler) {
modele.message = message(
modele.message = getMessageModification(isModeModification, isAnnuler)
}
- modele.incidentAModifieInfo = getIncidentModificationInfo(incident) as JSON
+ modele.incidentAModifieInfo = getIncidentModificationInfo(incident, getSecuriteSession().defaultAutorite.id) as JSON
PreferencesEtablissementAbsences preferences = getPreferencesEtablissementCourant()
modele.dataNaturesIncident = getAllTypesIncident() as JSON
modele.dataPartenairesAPrevenir = getAllPartenairesAPrevenir() as JSON
- modele.activeCRUD = droitsService.hasDroitFonctionnalite(
+ modele.activeCUD = droitsService.hasDroitFonctionnalite(
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
- if (params.criteres != null) {
+ modele.autoriseSaisieIncident = isAutoriseSaisieIncident(securiteSession, modele.activeCUD)
+
+ if(params.criteres != null) {
modele.criteres = params.criteres
}
* @author bahj
*/
def enregistreIncident = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnaliteIncidentCUD(
+ getSecuriteSession(),
+ isAutoriseSaisieIncident(getSecuriteSession())
+ )
Map resultats = [:]
Map incidentInfo = JSON.parse(params.incidentInfo) as Map
String identifiant = incidentInfo.idIncident
preferences: preferences
)
- verifieDroitAccesObjetDomaine(preferences.etablissement)
-
if (identifiant) {
// Mode Modification
- resultats = modifieIncident(incidentParams, Long.parseLong(identifiant))
+
+ Incident incident = Incident.get(Long.parseLong(identifiant))
+ // vérifie les droits de modification de l'incident
+ absencesDroitService.verifieDroitFonctionnaliteIncidentCUD(
+ getSecuriteSession(),
+ isAutoriseUDIncident(getSecuriteSession(), incident)
+ )
+ resultats = modifieIncident(incidentParams, incident)
}
else {
// Mode création
+ incidentParams.auteur = getSecuriteSession().defaultAutorite
resultats = creeIncident(incidentParams)
}
* Modifie un incident
*/
private Map modifieIncident(IncidentParams incidentAModifierDto,
- Long idIncident) {
+ Incident incident) {
Map resultats = [:]
-
- Incident incident = Incident.get(idIncident)
if (incident) {
try {
absencesIncidentService.modifieIncident(
def supprimeIncident = {
// Vérifie les droits d'accès à la page
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnaliteIncidentCUD(
+ getSecuriteSession(),
+ isAutoriseSaisieIncident(getSecuriteSession())
+ )
Incident incident = Incident.get(Long.parseLong(params.id))
if (incident) {
try {
- verifieDroitAccesObjetDomaine(incident.etablissement)
+ // vérifie les droits de modification de l'incident
+ absencesDroitService.verifieDroitFonctionnaliteIncidentCUD(
+ getSecuriteSession(),
+ isAutoriseUDIncident(getSecuriteSession(), incident)
+ )
absencesIncidentService.supprimeIncident(incident)
* Construit un incidentModificationInfo, utilisé dans la vue de modification
* @author bahj
*/
- private IncidentModificationInfo getIncidentModificationInfo(Incident incident) {
+ private IncidentModificationInfo getIncidentModificationInfo(Incident incident,
+ Long defaultAutoriteId) {
+
+ Boolean isUtilisateurCourantAuteur = null
+ if (incident.auteur){
+ isUtilisateurCourantAuteur = (defaultAutoriteId == incident.auteur.id)
+ }
return new IncidentModificationInfo(
idIncident: incident.id,
idLieuIncident: incident.lieuId,
protagonistesModInfo: getProtagonistesModificationInfo(incident),
idPartenaires: getPartenairesPrevenusModification(incident),
- description: incident.description
+ description: incident.description,
+ isUtilisateurCourantAuteur: isUtilisateurCourantAuteur
)
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.punition
/**
String classe
String type
def statut
+ Boolean isUtilisateurCourantAuteur
Boolean absenceLiee
// rajoutés pour archivage
import org.lilie.services.eliot.absences.Motif
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.absences.consultation.ConsultationService
+import org.lilie.services.eliot.absences.AbsencesDroitService
/**
* @author ywan
EnumMarshallerService enumMarshallerService
PlageHoraireService plageHoraireService
ConsultationService consultationService
+ AbsencesDroitService absencesDroitService
/**
* Page de consultations des punitions
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
+ modele.autoriseSaisiePunition = isAutoriseSaisiePunition(securiteSession, modele.activeCUD)
if (params.criteres != null) {
modele.criteres = params.criteres
*/
def afficheCreation = {
// Vérifie les drois d'accès à la page
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseSaisiePunition(getSecuriteSession())
+ )
Boolean isAnnuler = null
if (params.isAnnuler) {
]
} as JSON
+ modele.activeCUD = droitsService.hasDroitFonctionnalite(
+ getSecuriteSession(),
+ AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
+ )
+ modele.autoriseSaisiePunition = isAutoriseSaisiePunition(securiteSession, modele.activeCUD)
+ modele.autoriseSaisieRetenue = isAutoriseSaisieRetenue(securiteSession, modele.activeCUD)
+
if (params.criteres != null) {
modele.criteres = params.criteres
}
Punition punition = Punition.get(Long.parseLong(params.id))
+ Boolean isUtilisateurCourantAuteur = null
+ if (punition.auteur){
+ isUtilisateurCourantAuteur = (getSecuriteSession().defaultAutorite.id == punition.auteur.id)
+ }
+
Map punitionAModifierInfo = [
id: isDupliquer == true ? null : punition.id,
date: formateDate(punition.date),
censeurNom: punition.censeur.nomAffichage(),
description: punition.description ?: '',
incidentId: isDupliquer == true ? null : (punition.incidentId ?: null),
- isAbsenceLiee: punition.absenceLiee
+ isAbsenceLiee: punition.absenceLiee,
+ isUtilisateurCourantAuteur: isUtilisateurCourantAuteur
]
if (punition.absenceLiee) {
modele.punitionAModifierInfo = punitionAModifierInfo as JSON
- modele.activeCRUD = droitsService.hasDroitFonctionnalite(
+ modele.activeCUD = droitsService.hasDroitFonctionnalite(
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
+ modele.autoriseSaisiePunition = isAutoriseSaisiePunition(securiteSession, modele.activeCUD)
+ modele.autoriseSaisieRetenue = isAutoriseSaisieRetenue(securiteSession, modele.activeCUD)
if (params.criteres != null) {
modele.criteres = params.criteres
def supprimePunition = {
// Vérifie les droits d'accès à la page
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseSaisiePunition(getSecuriteSession())
+ )
Map resultats = [:]
Punition punition = Punition.get(Long.parseLong(params.id))
verifieDroitAccesObjetDomaine(punition.eleve)
if (punition) {
+ // vérifie les droits de suppression de la punition
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseUDPunition(getSecuriteSession(), punition)
+ )
try {
absencesPunitionService.supprimePunition(punition)
*/
@SuppressWarnings('CatchException')
def enregistrePunition = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseSaisiePunition(getSecuriteSession())
+ )
Map resultat
Punition punition
Long punitionId = null
punition = Punition.get(punitionParams.id)
punitionId = punition.id
- verifieDroitAccesObjetDomaine(punition.eleve)
+ // vérifie les droits de modification de la punition
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseUDPunition(getSecuriteSession(), punition)
+ )
+ boolean isAutoriseUDRetenue = isAutoriseUDRetenue(getSecuriteSession(), punition)
+
+ Punition punitionAModifier = absencesPunitionService.modifiePunition(punition, punitionParams, isAutoriseUDRetenue)
+
+ if (isAutoriseUDRetenue){
+ absencesPunitionService.modifieAbsences(punitionAModifier, punitionParams)
+ }
- absencesPunitionService.modifiePunition(punition, punitionParams)
}
else {
- verifieDroitAccesObjetDomaine(punitionParams.eleve)
-
- punition = absencesPunitionService.creePunition(punitionParams)
+ boolean isAutoriseSaisieRetenue = isAutoriseSaisieRetenue(getSecuriteSession())
+ punition = absencesPunitionService.creePunition(punitionParams, isAutoriseSaisieRetenue)
if (punitionId == null) {
punitionId = punition.id
}
def isEleveAbsent = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseSaisiePunition(getSecuriteSession())
+ )
Map absenceInfo = (Map) JSON.parse(params.absenceInfo)
Personne eleve = getPersonneForIdAutorite(absenceInfo.autoriteEleveId)
Date dateDebut = Date.parse(ConstDate.DATE_JJMMAAA, absenceInfo.dateDebut)
}
def changeStatutPunition = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
-
Map resultat
try {
- absencesPunitionService.changeStatutPunition(Long.parseLong(params.punitionId), Boolean.parseBoolean(params.statut))
+ Punition punition = Punition.findById(Long.parseLong(params.punitionId))
+
+ absencesDroitService.verifieDroitFonctionnalitePunitionCUD(
+ getSecuriteSession(),
+ isAutoriseUDPunition(getSecuriteSession(), punition)
+ )
+
+ absencesPunitionService.changeStatutPunition(punition, Boolean.parseBoolean(params.statut))
resultat = [
success: true,
message: message(code: 'absences.saisie.punitions.modification.succes')
String libelleNonEffectue = message(code: 'absences.data.nonEffectuee')
punitionsInfo.each { def punitionInfo ->
+
+ Boolean isUtilisateurCourantAuteur = null
+ if (punitionInfo[0].auteur){
+ isUtilisateurCourantAuteur = (getSecuriteSession().defaultAutorite.id == punitionInfo[0].auteur.id)
+ }
+
punitionsConsultationInfo.add(
new PunitionConsultationInfo(
id: punitionInfo[0].id,
censeur: punitionInfo[3],
statut: punitionInfo[0].effectue ?
(activeCUD ? true : libelleEffectue) : (activeCUD ? false : libelleNonEffectue),
- absenceLiee: punitionInfo[0].absenceLiee
+ absenceLiee: punitionInfo[0].absenceLiee,
+ isUtilisateurCourantAuteur: isUtilisateurCourantAuteur
)
)
}
finAbsence: punitionParams.finAbsence,
etablissement: punitionParams.etablissement,
operateurSaisie: punitionParams.operateurSaisie,
- preferences: punitionParams.preferences,
+ preferences: punitionParams.preferences
))
}
modele.sanctionAModifierInfo = getSanctionAModifierInfo(identifiant) as JSON
- modele.activeCRUD = droitsService.hasDroitFonctionnalite(
+ modele.activeCUD = droitsService.hasDroitFonctionnalite(
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
import org.lilie.services.eliot.absences.ScolariteService
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.CodeComparator
+import org.lilie.services.eliot.absences.AbsencesDroitService
class JsonScolariteController extends AbstractAbsencesController {
LocalStructureEnseignementService localStructureEnseignementService
EleveAnnuaireService eleveAnnuaireService
ScolariteService scolariteService
+ AbsencesDroitService absencesDroitService
/**
* Retourne la liste des enseignants de l'établissement courant
* Retourne une liste de personne correspondant au profil sélectionné
*/
def getAllPersonneProfil = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
ProfilCenseur profil = ProfilCenseur.parseByCode(
Integer.parseInt(params.idProfil)
)
* Retourne la liste des structures d'enseignement de l'établissement
*/
def getAllClasseByEtablissement = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
List result = []
Etablissement etablissement = Etablissement.get(
Long.parseLong(params.idEtablissement)
* d'enseignement
*/
def getAllAutoriteEleveByStructureEnseignement = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
List result = []
StructureEnseignement structureEnseignement = StructureEnseignement.get(
Long.parseLong(params.idStructureEnseignement)
* structure d'enseignement
*/
def getAllParentByStructureEnseignement = {
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
+ verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
List result = []
StructureEnseignement structureEnseignement = StructureEnseignement.get(
Long.parseLong(params.idStructureEnseignement)
absences.parametrage.general.libelle.jour.minuscule=jour(s)
absences.parametrage.general.libelle.typePlageHoraire=Durée d'une plage horaire
absences.parametrage.general.libelle.tauxAbsencesModeCalcul=Calcul du taux d'absentéisme en fonction
-absences.parametrage.general.libelle.interdieModifAppel=Intérdire la modification des appels après
+absences.parametrage.general.libelle.interdieModifAppel=Interdire la modification des appels après
absences.parametrage.general.libelle.longueur.heure=1 heure
absences.parametrage.general.libelle.longueur.demiheure=1/2 heure
absences.parametrage.general.message.enregistrerSucces=Les paramétrages généraux ont été enregistrés avec succès.
}
preferences.autoriseSaisieIncident = command.autoriseSaisieIncident
-
preferences.autoriseSaisiePunition = command.parseSaisiePunitionsInfo.saisie
-
preferences.autoriseSaisieRetenue = command.parseSaisiePunitionsInfo.avecRetenu
* Met à jour la ou les absences associées à la punition
* @return la liste des appelLigne associée à la punition
*/
- protected void internalModifieAbsencesForPunition(Autorite operateurSaisie,
- Punition punition
+ public void internalModifieAbsencesForPunition(Autorite operateurSaisie,
+ Punition punition
) {
//on récupère les appelLigne associés
List<AppelLigne> appelLignes = AppelLigne.findAllByPunition(punition)
lieu: incidentParams.lieu,
etablissement: incidentParams.etablissement,
description: incidentParams.description,
- preferencesEtablissementAbsences: incidentParams.preferences)
+ preferencesEtablissementAbsences: incidentParams.preferences,
+ auteur: incidentParams.auteur)
// Création des protagonistes
protagonisteIncidentService.creeProtagonistesIncident(
* @return un IncidentConsultationInfo
* @author jbui
*/
- private IncidentConsultationInfo getIncidentConsultationInfo(Incident incident,
+ private IncidentConsultationInfo getIncidentConsultationInfo(Long defaultAutoriteId,
+ Incident incident,
Map nomAffichageByIdExterne) {
List protagonistes = []
protagonistes << protagoniste
}
+ Boolean isUtilisateurCourantAuteur = null
+ if (incident.auteur){
+ isUtilisateurCourantAuteur = (defaultAutoriteId == incident.auteur.id)
+ }
+
return new IncidentConsultationInfo(
id: incident.id,
date: formateDateHeure(incident.date),
lieu: incident.lieu.libelle,
gravite: incident.gravite,
partenairePrevenus: partenaires,
- protagonistes: protagonistes
+ protagonistes: protagonistes,
+ isUtilisateurCourantAuteur: isUtilisateurCourantAuteur
)
}
* @param incidents : les incidents source
* @return une List<IncidentConsultationInfo>
*/
- public List<IncidentConsultationInfo> getIncidentConsultationsInfos(List<Incident> incidents,
+ public List<IncidentConsultationInfo> getIncidentConsultationsInfos(Long defaultAutoriteId,
+ List<Incident> incidents,
Map nomAffichageByIdExterne) {
List<IncidentConsultationInfo> result = []
incidents.each {
- result << getIncidentConsultationInfo(it, nomAffichageByIdExterne)
+ result << getIncidentConsultationInfo(defaultAutoriteId, it, nomAffichageByIdExterne)
}
return result
import org.lilie.services.eliot.absences.TypeIncident
import org.lilie.services.eliot.absences.GraviteIncident
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
+import org.lilie.services.eliot.securite.impl.Autorite
/**
* Représente un Incident
Etablissement etablissement
List<ProtagonisteIncidentParams> protagonistesParams = []
List<PartenaireAPrevenirIncidentParams> partenairesParams = []
- PreferencesEtablissementAbsences preferences
+ PreferencesEtablissementAbsences preferences
+ Autorite auteur
}
static transactional = true
+ private static String MODE_CREATION = 'creation'
+ private static String MODE_MODIFICATION = 'modification'
+
private static final String SQL_PUNITION_TOUS = """
with pps_dernier_debut as (
* Crée une nouvelle punition en vérifiant les droits
* @return une Punition
*/
- Punition creePunition(PunitionParams punitionParams) throws PunitionException {
+ Punition creePunition(PunitionParams punitionParams,
+ boolean isAutoriseSaisieRetenue) throws PunitionException {
Punition punition = new Punition()
- initialisePunition(punition, punitionParams)
+ initialisePunition(punition, punitionParams, MODE_CREATION, isAutoriseSaisieRetenue)
internalSave(punition)
internalSupprimeAbsencesExistantes(punition)
* @return la Punition
*/
Punition modifiePunition(Punition punitionAModifier,
- PunitionParams punitionParams) throws PunitionException {
+ PunitionParams punitionParams,
+ boolean isAutoriseUDRetenue) throws PunitionException {
- initialisePunition(punitionAModifier, punitionParams)
+ initialisePunition(punitionAModifier, punitionParams, MODE_MODIFICATION, isAutoriseUDRetenue)
internalSave(punitionAModifier)
+ return punitionAModifier
+ }
+
+ public modifieAbsences(Punition punitionAModifier,
+ PunitionParams punitionParams) {
internalSupprimeAbsencesExistantes(punitionAModifier)
// TOREFACT : appel méthode protected à partir d'une classe externe
punitionParams.operateurSaisie,
punitionAModifier
)
-
- return punitionAModifier
}
private initialisePunition(Punition punitionAModifier,
- PunitionParams punitionParams) {
+ PunitionParams punitionParams,
+ String mode,
+ Boolean isAutorisationAccordeeRetenue) {
punitionAModifier.date = punitionParams.date
punitionAModifier.typePunition = punitionParams.type
punitionAModifier.effectue = punitionParams.isPunitionEffectuee
punitionAModifier.etablissement = punitionParams.etablissement
punitionAModifier.preferencesEtablissementAbsences = punitionParams
.preferences
- punitionAModifier.absenceLiee = punitionParams.isAbsenceLiee
- punitionAModifier.debutAbsence = punitionParams.debutAbsence
- punitionAModifier.finAbsence = punitionParams.finAbsence
- punitionAModifier.motif = punitionParams.motif
+ punitionAModifier.absenceLiee =
+ isAutorisationAccordeeRetenue ? punitionParams.isAbsenceLiee : (punitionAModifier.absenceLiee != null ? punitionAModifier.absenceLiee : false)
+ punitionAModifier.debutAbsence =
+ isAutorisationAccordeeRetenue ? punitionParams.debutAbsence : punitionAModifier.debutAbsence
+ punitionAModifier.finAbsence =
+ isAutorisationAccordeeRetenue ? punitionParams.finAbsence : punitionAModifier.finAbsence
+ punitionAModifier.motif =
+ isAutorisationAccordeeRetenue ? punitionParams.motif : punitionAModifier.motif
+ punitionAModifier.auteur =
+ (mode == MODE_CREATION) ? punitionParams.operateurSaisie : punitionAModifier.auteur
}
/**
punition.save(flush: true, failOnError: true)
}
catch (Exception e) {
+ log.error(e.message)
throw new PunitionException(e.message)
}
}
}
}
- public void changeStatutPunition(Long punitionId, Boolean effectuee){
- Punition punition = Punition.findById(punitionId)
+ public void changeStatutPunition(Punition punition, Boolean effectuee){
punition.effectue = effectuee
punition.save(failOnError:true)
}
<eliotjs:ns name="data">
<eliotjs:varNumeric name="nombreLignesParPage" value="${ConfigurationHolder.config.eliot.absences.incident.consultation.nombreLignesParPage ?: 100}"/>
- <eliotjs:varBoolean name="activeCUD" value="${activeCRUD}"/>
+ <eliotjs:varBoolean name="activeCUD" value="${activeCUD}"/>
+ <g:if test="${autoriseSaisieIncident != null}">
+ <eliotjs:varBoolean name="autoriseSaisieIncident" value="${autoriseSaisieIncident}"/>
+ </g:if>
</eliotjs:ns>
<eliotjs:ns name="header">
<eliotjs:varString name="gravite" value="${ConsultationIncidentNomColonnes.GRAVITE}"/>
<eliotjs:varString name="partenairesPrevenus" value="${ConsultationIncidentNomColonnes.PARTENAIRES_PREVENUS}"/>
<eliotjs:varString name="protagonistes" value="${ConsultationIncidentNomColonnes.PROTAGONISTES}"/>
+ <eliotjs:varString name="isUtilisateurCourantAuteur" value="isUtilisateurCourantAuteur"/>
</eliotjs:ns>
<eliotjs:ns name="message">
</eliotjs:ns>
- <eliotjs:ns name="eliot.absences.commons.CUDToolbarViewModele">
+ <eliotjs:ns name="eliot.absences.saisie.incidents.IncidentCUDToolbarViewModele">
<eliotjs:ns name="libelle">
<eliotjs:varI18n name="creer" code="absences.libelle.creer"/>
%{-- Fichiers à charger avant le modèle--}%
<g:javascript library="src/views/commons/Utils"/>
<g:javascript library="src/views/commons/Constantes"/>
- <g:javascript library="src/views/commons/CUDToolbarView"/>
+ <g:javascript library="src/views/saisie/incident/consultation/IncidentCUDToolbarView"/>
<g:javascript library="src/views/commons/GridConsultationView"/>
<g:render template="/commons/ficheeleve/ficheEleve" plugin="eliot-app-plugin"/>
<eliotjs:varJson name="incidentAModifieInfo"
value="${incidentAModifieInfo ?: 'undefined'}"/>
<eliotjs:varJson name="criteres" value="${criteres}" nullable="true"/>
- <g:if test="${activeCRUD != null}">
- <eliotjs:varBoolean name="activeCRUD" value="${activeCRUD}"/>
+ <g:if test="${activeCUD != null}">
+ <eliotjs:varBoolean name="activeCUD" value="${activeCUD}"/>
+ </g:if>
+ <g:if test="${autoriseSaisieIncident != null}">
+ <eliotjs:varBoolean name="autoriseSaisieIncident" value="${autoriseSaisieIncident}"/>
</g:if>
</eliotjs:ns>
<eliotjs:ns name="data">
<eliotjs:varBoolean name="activeCUD" value="${activeCUD}"/>
<eliotjs:varNumeric name="nombreLignesParPage" value="${ConfigurationHolder.config.eliot.absences.punition.consultation.nombreLignesParPage ?: 100}"/>
+ <g:if test="${autoriseSaisiePunition != null}">
+ <eliotjs:varBoolean name="autoriseSaisiePunition" value="${autoriseSaisiePunition}"/>
+ </g:if>
+ <g:if test="${autoriseSaisieRetenue != null}">
+ <eliotjs:varBoolean name="autoriseSaisieRetenue" value="${autoriseSaisieRetenue}"/>
+ </g:if>
</eliotjs:ns>
<eliotjs:ns name="header">
<eliotjs:varString name="type" value="${ConsultationPunitionSanctionNomColonnes.TYPE}"/>
<eliotjs:varString name="censeur" value="${ConsultationPunitionSanctionNomColonnes.CENSEUR}"/>
<eliotjs:varString name="statut" value="${ConsultationPunitionSanctionNomColonnes.STATUT}"/>
+ <eliotjs:varString name="isUtilisateurCourantAuteur" value="isUtilisateurCourantAuteur"/>
</eliotjs:ns>
<eliotjs:ns name="message">
</eliotjs:ns>
- <eliotjs:ns name="eliot.absences.commons.CUDToolbarViewModele">
+ <eliotjs:ns name="eliot.absences.saisie.punitions.PunitionCUDToolbarViewModele">
<eliotjs:ns name="libelle">
<eliotjs:varI18n name="creer" code="absences.libelle.creer"/>
%{-- Fichiers à charger avant le modèle--}%
<g:javascript library="src/views/commons/Utils"/>
<g:javascript library="src/views/commons/Constantes"/>
- <g:javascript library="src/views/commons/CUDToolbarView"/>
+ <g:javascript library="src/views/saisie/punition/consultation/PunitionCUDToolbarView"/>
<g:javascript library="src/views/commons/GridConsultationView"/>
<g:render template="/commons/ficheeleve/ficheEleve"
<eliotjs:varJson name="dataMotifs" value="${dataMotifs}"/>
<eliotjs:varString name="messageSuccess" value="${message ?: ''}"/>
- <g:if test="${activeCRUD != null}">
- <eliotjs:varBoolean name="activeCRUD" value="${activeCRUD}"/>
+ <g:if test="${activeCUD != null}">
+ <eliotjs:varBoolean name="activeCUD" value="${activeCUD}"/>
+ </g:if>
+ <g:if test="${autoriseSaisiePunition != null}">
+ <eliotjs:varBoolean name="autoriseSaisiePunition" value="${autoriseSaisiePunition}"/>
+ </g:if>
+ <g:if test="${autoriseSaisieRetenue != null}">
+ <eliotjs:varBoolean name="autoriseSaisieRetenue" value="${autoriseSaisieRetenue}"/>
</g:if>
</eliotjs:ns>
<eliotjs:varJson name="dataTypesSanction" value="${dataTypesSanction}"/>
<eliotjs:varJson name="dataMotifs" value="${dataMotifs}"/>
<eliotjs:varString name="messageSuccess" value="${message ?: ''}"/>
- <g:if test="${activeCRUD != null}">
- <eliotjs:varBoolean name="activeCRUD" value="${activeCRUD}"/>
+ <g:if test="${activeCUD != null}">
+ <eliotjs:varBoolean name="activeCUD" value="${activeCUD}"/>
</g:if>
</eliotjs:ns>
store : undefined,
libelle : undefined,
width : undefined,
- isComboDansGrid : false
+ isComboDansGrid : false,
+ disabled:false
};
Ext.apply(cfg, config);
displayField:'libelle',
editable : false,
value : cfg.valeurInitiale,
- lazyRender : cfg.isComboDansGrid
+ lazyRender : cfg.isComboDansGrid,
+ disabled:cfg.disabled
});
this.observeComboBox();
champObligatoir : undefined,
disabledDates : undefined,
disabledDays : undefined,
- activeValidationParSemaine : false
+ activeValidationParSemaine : false,
+ disabled:false
};
Ext.apply(cfg, config);
maxValue : maxDate,
minValue : minDate,
disabledDates: cfg.disabledDates,
- disabledDays: cfg.disabledDays
+ disabledDays: cfg.disabledDays,
+ disabled:cfg.disabled
});
this.observeDateField();
// ToolBar qui contient les 3 boutons suivants:
// - Créer un nouvel incident
// - Modifier l'incident
- // -Supprimer l'incident
- var cudToolbarView = new eliot.absences.commons.CUDToolbarView({
- activeCUD : Modele.data.activeCUD,
+ // - Supprimer l'incident
+ var isSaisieAutorisee = false;
+ var activeCUD = Modele.data.activeCUD;
+ var autoriseSaisieIncident = Modele.data.autoriseSaisieIncident;
+ if (activeCUD == true || activeCUD == undefined){
+ isSaisieAutorisee = true
+ } else {
+ isSaisieAutorisee = (autoriseSaisieIncident == true)
+ }
+
+ var incidentCudToolbarView = new eliot.absences.saisie.incidents.IncidentCUDToolbarView({
+ isSaisieAutorisee : isSaisieAutorisee,
boutonsAAJouter : new Array(boutonExporterView.bouton)
});
var incidentView = new eliot.absences.commons.GridConsultationView({
store : incidentController.store,
- toolBar :cudToolbarView.cudToolbar,
+ toolBar :incidentCudToolbarView.cudToolbar,
columns : incidentController.getColonnesGrilleConsultationIncidents(),
nombreLignesParPage : Modele.data.nombreLignesParPage,
enableHDMenu : true
// On branche l'observation du controller seulement si
// l'utilisateur a le droit aux actions de
// création/modification/suppression des incidents
- if (Modele.data.activeCUD) {
- cudToolbarView.observeController(incidentController);
- incidentController.observeCUDToolBarView(cudToolbarView);
+ if (isSaisieAutorisee) {
+ incidentCudToolbarView.observeController(incidentController);
+ incidentController.observeCUDToolBarView(incidentCudToolbarView);
}
incidentController.observeIncidentView(incidentView);
--- /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>.
+ */
+
+/**
+ * Classe graphique construit un toolBar avec les composants suivants:
+ * - Bouton Création
+ * - Bouton Modification
+ * - Bouton Suppression
+ *
+ * Il faut définir les libellés et les icons dans la page qui utilise
+ * le composant
+ * @libelle :- creer - modifier -supprimer et à chacun son image
+ *
+ * @Config
+ * @params activeCUD : paramétrage par défaut qui permet d'active/désactive
+ * tous les boutons de la toolBar
+ *
+ * Le toollBar déclenche les événements suivants:
+ * @events déclenchés:
+ * - @event actionCreer déclenché lorsque le bouton 'Créer' est choisi
+ * - @event actionModifier déclenché lorsque le bouton 'Modifier' est choisi
+ * - @event actionSupprimer déclenché lorsque le bouton 'Supprimer' est choisi
+ *
+ * @events écoutés :
+ * - @event changeEtatBtnModifier, @params : active flag qui indique l'état de bouton
+ * - @event changeEtatBtnSupprimer, @params : active flag qui indique l'état de bouton
+ *
+ * @author bahj
+ */
+
+Ext.ns('eliot.absences.saisie.incidents');
+
+eliot.absences.saisie.incidents.IncidentCUDToolbarViewConstantes = {
+ eventId : {
+ actionCreer : 'actionCreer',
+ actionModifier : 'actionModifier',
+ actionSupprimer : 'actionSupprimer',
+ changeEtatBtnModifier : 'changeEtatBtnModifier',
+ changeEtatBtnSupprimer : 'changeEtatBtnSupprimer'
+ }
+};
+
+eliot.absences.saisie.incidents.IncidentCUDToolbarViewModele = {
+ libelle: {
+ creer : undefined,
+ modifier : undefined,
+ supprimer : undefined
+ },
+
+ icon : {
+ creation : undefined,
+ modification : undefined,
+ suppression : undefined
+ }
+
+};
+
+eliot.absences.saisie.incidents.IncidentCUDToolbarView = Ext.extend(Ext.util.Observable, {
+ /**
+ * Construction d'un toolbar
+ */
+ constructor: function(config) {
+ this.constantes = eliot.absences.saisie.incidents.IncidentCUDToolbarViewConstantes;
+ var Modele = eliot.absences.saisie.incidents.IncidentCUDToolbarViewModele;
+
+ // Config par défaut
+ var cfg = {
+ boutonsAAJouter : []
+ };
+
+ // Charge la config fournie
+ Ext.apply(cfg, config);
+
+ this.addEvents(
+ /**
+ * @event actionCreer déclenché lorsque le bouton
+ * 'Créer' est choisi
+ */
+ this.constantes.eventId.actionCreer,
+
+ /**
+ * @event actionModifier déclenché lorsque le
+ * bouton 'Modifier' est choisi
+ */
+ this.constantes.eventId.actionModifier,
+
+ /**
+ * @event actionSupprimer déclenché lorsque le
+ * bouton 'Supprimer' est choisi
+ */
+ this.constantes.eventId.actionSupprimer
+ );
+
+ // Bouton "Créer"
+ this.btnCreer = new Ext.Button({
+ xtype: 'tbbutton',
+ text: Modele.libelle.creer,
+ icon: Modele.icon.creation,
+ listeners: {
+ click : function() {
+ this.actionCreer();
+ },
+ scope : this
+
+ },
+ disabled: !config.isSaisieAutorisee
+ });
+
+ // Bouton "Modifer"
+ this.btnModifier = new Ext.Button({
+ xtype: 'tbbutton',
+ text: Modele.libelle.modifier,
+ icon: Modele.icon.modification,
+ disabled : true,
+ listeners: {
+ click : function() {
+ this.actionModifier();
+ },
+ scope : this
+ }
+ });
+
+ // Bouton "Supprimer"
+ this.btnSupprimer = new Ext.Button({
+ xtype: 'tbbutton',
+ text : Modele.libelle.supprimer,
+ icon : Modele.icon.suppression,
+ disabled : true,
+ listeners: {
+ click : function() {
+ this.actionSupprimer()
+ },
+ scope : this
+ }
+ });
+
+ // Construction de toolbar
+ this.cudToolbar = new Ext.Toolbar({
+ border: true,
+ autoWidth:true,
+ height: 35
+// ,
+// disabled : !config.activeCUD
+ });
+
+ var separator = {
+ xtype: 'tbseparator'
+ };
+
+ this.cudToolbar.add(
+ this.btnCreer,
+ separator,
+ this.btnModifier,
+ separator,
+ this.btnSupprimer
+ );
+
+ // Ajout d'éventuels boutons
+ var nombreDeBoutonAAjouter = cfg.boutonsAAJouter.length;
+ if (nombreDeBoutonAAjouter > 0) {
+ for (var i = 0; i < nombreDeBoutonAAjouter; i++) {
+ this.cudToolbar.add(
+ separator,
+ cfg.boutonsAAJouter[i]
+ );
+ }
+ }
+
+ },
+
+ /**
+ * Déclenche l'évènement actionCreer
+ */
+ actionCreer: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionCreer
+ );
+ },
+
+ /**
+ * Déclenche l'évènement actionModifier
+ */
+ actionModifier: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionModifier
+ );
+ },
+
+ /**
+ * Déclenche l'évènement actionSupprimer
+ */
+ actionSupprimer: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionSupprimer
+ );
+ },
+
+ /**
+ * Observe le controller afin de mettre à jour
+ * l'état des boutons suivants : - Bouton de modification
+ * - Bouton de suppression
+ *
+ * @param controller
+ */
+ observeController : function(controller) {
+ controller.addListener(
+ this.constantes.eventId.changeEtatBtnModifier,
+ this.changeEtatBtnModifier,
+ this
+ );
+ controller.addListener(
+ this.constantes.eventId.changeEtatBtnSupprimer,
+ this.changeEtatBtnSupprimer,
+ this
+ );
+ },
+
+ /**
+ * Change l'état de bouton supprimer (activé/désactivé)
+ * @param active flag
+ */
+ changeEtatBtnSupprimer : function(active) {
+ if (active) {
+ this.btnSupprimer.enable();
+ }
+ else {
+ this.btnSupprimer.disable();
+ }
+ },
+
+ /**
+ * Change l'état de bouton modifier (activé/désactivé)
+ * @param active flag
+ */
+ changeEtatBtnModifier : function(active) {
+ if (active) {
+ this.btnModifier.enable();
+ }
+ else {
+ this.btnModifier.disable();
+ }
+ }
+
+
+});
\ No newline at end of file
eliot.absences.saisie.incidents.IncidentController = Ext.extend(Ext.util.Observable, {
constructor: function(filter) {
this.NameSpace = eliot.absences.saisie.incidents;
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.eventId;
+ var toolBarEventsId = this.NameSpace.IncidentCUDToolbarViewConstantes.eventId;
this.BoutonExportEventsId = eliot.exportdonnees.BoutonExportControllerConstantes.eventId;
this.idIncidentSelectionne = undefined;
this.addEvents(
- /**
- * @event changeEtatBtnModifier déclenché afin de changer
- * l'état de bouton modifier
- * @params active flag qui indique si le bouton doit être activé
- */
+ /**
+ * @event changeEtatBtnModifier déclenché afin de changer
+ * l'état de bouton modifier
+ * @params active flag qui indique si le bouton doit être activé
+ */
toolBarEventsId.changeEtatBtnModifier,
- /**
- * @event changeEtatBtnSupprimer déclenché afin de changer
- * l'état de bouton supprimer
- * @params active flag qui indique si le bouton doit être activé
- */
+ /**
+ * @event changeEtatBtnSupprimer déclenché afin de changer
+ * l'état de bouton supprimer
+ * @params active flag qui indique si le bouton doit être activé
+ */
toolBarEventsId.changeEtatBtnSupprimer,
- /**
- * @event donneesPretesAExporter déclanché afin de changer l'état de bouton exporter
- */
+ /**
+ * @event donneesPretesAExporter déclanché afin de changer l'état de bouton exporter
+ */
this.BoutonExportEventsId.donneesPretesAExporter,
- /**
- * @event donneesPretesAExporter déclanché afin de changer l'état de bouton exporter
- */
+ /**
+ * @event donneesPretesAExporter déclanché afin de changer l'état de bouton exporter
+ */
this.BoutonExportEventsId.aucuneDonneesAExporter
- );
+ );
// Paramètre de classement de la consultation
},
{
name: this.NameSpace.Modele.dataIndex.protagonistes
+ },
+ {
+ name: this.NameSpace.Modele.dataIndex.isUtilisateurCourantAuteur
}
],
root:'data',
// Observe les actions de la toolbar (Création/Modification/Suppression)
observeCUDToolBarView : function(CUDToolBarView) {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.
+ var toolBarEventsId = eliot.absences.saisie.incidents.IncidentCUDToolbarViewConstantes.
eventId;
CUDToolBarView.addListener(
toolBarEventsId.actionCreer,
this.actionCreerIncident,
this
- );
+ );
CUDToolBarView.addListener(
toolBarEventsId.actionModifier,
this.actionModifierIncident,
this
- );
+ );
CUDToolBarView.addListener(
toolBarEventsId.actionSupprimer,
this.actionSupprimerIncident,
this
- );
+ );
},
// Observe la grille afin de mettre les variables à jours
grilleConsultationEventId.actionSelection,
this.actionSelectionIncident,
this
- );
+ );
incidentView.addListener(
grilleConsultationEventId.actionDbClick,
this.actionDbClickIncident,
this
- );
+ );
incidentView.addListener(
grilleConsultationEventId.actionClassementChange,
this.executeClassementChange,
this
- );
+ );
},
/**
* @param recordSelectionne le record seléctionné
*/
actionSelectionIncident : function(recordSelectionne) {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.eventId;
+ var toolBarEventsId = eliot.absences.saisie.incidents.IncidentCUDToolbarViewConstantes.eventId;
this.idIncidentSelectionne = recordSelectionne.id;
// Mise à jour de l'état des boutons
- this.fireEvent(toolBarEventsId.changeEtatBtnModifier, true);
- this.fireEvent(toolBarEventsId.changeEtatBtnSupprimer, true);
+ var activeBoutonsModifierSupprimer = false;
+ var activeCUD = this.NameSpace.Modele.data.activeCUD;
+ var autoriseSaisieIncident = this.NameSpace.Modele.data.autoriseSaisieIncident;
+ var isAuteurIncident = recordSelectionne.get('isUtilisateurCourantAuteur');
+ if (activeCUD == true || activeCUD == undefined){
+ activeBoutonsModifierSupprimer = true;
+ } else {
+ activeBoutonsModifierSupprimer = (autoriseSaisieIncident == true && isAuteurIncident == true)
+ }
+
+ this.fireEvent(toolBarEventsId.changeEtatBtnModifier, activeBoutonsModifierSupprimer);
+ this.fireEvent(toolBarEventsId.changeEtatBtnSupprimer, activeBoutonsModifierSupprimer);
},
/**
message,
this.executeIsIncidentUtilise.createDelegate(this),
this.annuleSuppressionIncident.createDelegate(this)
- )
+ )
},
/**
failure : function(response, request) {
eliot.absences.Message.showErreur(
this.NameSpace.Modele.message.erreurInconnue
- );
+ );
}
})
},
this.NameSpace.Modele.message.confirmationIncidentreference,
this.executeSupprimerIncident.createDelegate(this),
this.annuleSuppressionIncident.createDelegate(this)
- )
+ )
},
/**
// Affichage du message de réussite
eliot.absences.Message.showConfirmation(
resultats.message
- );
+ );
// Désactive le bouton exporter si aucune sanction
this.changeEtatBoutonExport();
failure : function(response, request) {
eliot.absences.Message.showErreur(
this.NameSpace.Modele.message.erreurInconnue
- );
+ );
}
});
},
if (this.store.getCount() <= 0) {
this.fireEvent(
this.BoutonExportEventsId.aucuneDonneesAExporter
- );
+ );
}
},
*
*/
changeEtatToolBarApresSuppression : function() {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.
+ var toolBarEventsId = eliot.absences.saisie.incidents.IncidentCUDToolbarViewConstantes.
eventId;
this.fireEvent(
toolBarEventsId.changeEtatBtnModifier,
false
- );
+ );
this.fireEvent(
toolBarEventsId.changeEtatBtnSupprimer,
false
- )
+ )
}
,
lieu : undefined,
gravite : undefined,
partenairesPrevenus : undefined,
- protagonistes : undefined
+ protagonistes : undefined,
+ isUtilisateurCourantAuteur : undefined
},
message : {
});
/********************* Toolbar tout en haut *********************/
+ // gestion des droits de modification de l'incident
+ var boutonsActifs = false;
+ var activeCUD = NameSpace.Modele.data.activeCUD;
+ if (activeCUD == true || activeCUD == undefined){
+ boutonsActifs = true;
+ } else if (isModeModification) {
+ boutonsActifs = (NameSpace.Modele.data.autoriseSaisieIncident == true && incidentData.isUtilisateurCourantAuteur == true);
+ } else {
+ boutonsActifs = (NameSpace.Modele.data.autoriseSaisieIncident == true);
+ }
+ //
+
this.toolbarView = new eliot.absences.commons.SaveCancelToolBarView({
- enregistrerActive:NameSpace.Modele.data.activeCRUD,
- annulerActive:NameSpace.Modele.data.activeCRUD
+ enregistrerActive:boutonsActifs,
+ annulerActive:boutonsActifs
});
this.toolbarController = new NameSpace.ToolBarController({
application:this,
isAnnulerTrue:undefined,
isAnnulerFalse:undefined,
criteres:undefined,
- activeCRUD:undefined
+ activeCUD:undefined,
+ autoriseSaisieIncident:undefined
},
icon:{
// - Créer un nouvelle punition
// - Modifier la punition
// -Supprimer la punition
- var cudToolbarView = new eliot.absences.commons.CUDToolbarView({
- activeCUD:this.NameSpace.Modele.data.activeCUD,
+ var isSaisieAutorisee = false;
+ var activeCUD = this.NameSpace.Modele.data.activeCUD;
+ var autoriseSaisiePunition = this.NameSpace.Modele.data.autoriseSaisiePunition;
+ if (activeCUD == true || activeCUD == undefined){
+ isSaisieAutorisee = true
+ } else {
+ isSaisieAutorisee = (autoriseSaisiePunition == true)
+ }
+
+ var punitionCudToolbarView = new eliot.absences.saisie.punitions.PunitionCUDToolbarView({
+ isSaisieAutorisee : isSaisieAutorisee,
boutonsAAJouter:new Array(boutonExporterView.bouton)
});
// Création de la grille qui contient la toolBar de CUD
var punitionView = new eliot.absences.commons.GridConsultationView({
store:punitionController.store,
- toolBar:cudToolbarView.cudToolbar,
+ toolBar:punitionCudToolbarView.cudToolbar,
columns:punitionController.getColonnesGrilleConsultationPunitions(),
plugins:punitionController.checkColumn,
nombreLignesParPage:this.NameSpace.Modele.data.nombreLignesParPage
callbackGetParametres1:punitionController.getParametresRecherche.createDelegate(punitionController),
callbackGetParametres2:punitionView.getParamsViewColonnesVisbles.createDelegate(punitionView)
});
- cudToolbarView.cudToolbar.add(boutonImprimer);
+ punitionCudToolbarView.cudToolbar.add(boutonImprimer);
boutonExportController.setColonnesVisiblesFonction(
punitionView.getViewColonnesVisbles.createDelegate(punitionView)
// On branche l'observation du controller seulement si
// l'utilisateur a le droit aux actions de
// création/modification/suppression des incidents
- if (this.NameSpace.Modele.data.activeCUD) {
- punitionController.observeCUDToolBarView(cudToolbarView);
- cudToolbarView.observeController(punitionController);
+ if (isSaisieAutorisee) {
+ punitionController.observeCUDToolBarView(punitionCudToolbarView);
+ punitionCudToolbarView.observeController(punitionController);
}
punitionController.observePunitionView(punitionView);
data : {
nombreLignesParPage : undefined,
- activeCUD : undefined
+ activeCUD : undefined,
+ autoriseSaisiePunition : undefined,
+ autoriseSaisieRetenue : undefined
},
header : {
classe : undefined,
type : undefined,
censeur : undefined,
- statut : undefined
+ statut : undefined,
+ isUtilisateurCourantAuteur : undefined
},
icon : {
--- /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>.
+ */
+
+/**
+ * Classe graphique construit un toolBar avec les composants suivants:
+ * - Bouton Création
+ * - Bouton Modification
+ * - Bouton Suppression
+ *
+ * Il faut définir les libellés et les icons dans la page qui utilise
+ * le composant
+ * @libelle :- creer - modifier -supprimer et à chacun son image
+ *
+ * @Config
+ * @params activeCUD : paramétrage par défaut qui permet d'active/désactive
+ * tous les boutons de la toolBar
+ *
+ * Le toollBar déclenche les événements suivants:
+ * @events déclenchés:
+ * - @event actionCreer déclenché lorsque le bouton 'Créer' est choisi
+ * - @event actionModifier déclenché lorsque le bouton 'Modifier' est choisi
+ * - @event actionSupprimer déclenché lorsque le bouton 'Supprimer' est choisi
+ *
+ * @events écoutés :
+ * - @event changeEtatBtnModifier, @params : active flag qui indique l'état de bouton
+ * - @event changeEtatBtnSupprimer, @params : active flag qui indique l'état de bouton
+ *
+ * @author bahj
+ */
+
+Ext.ns('eliot.absences.saisie.punitions');
+
+eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes = {
+ eventId : {
+ actionCreer : 'actionCreer',
+ actionModifier : 'actionModifier',
+ actionSupprimer : 'actionSupprimer',
+ changeEtatBtnModifier : 'changeEtatBtnModifier',
+ changeEtatBtnSupprimer : 'changeEtatBtnSupprimer'
+ }
+};
+
+eliot.absences.saisie.punitions.PunitionCUDToolbarViewModele = {
+ libelle: {
+ creer : undefined,
+ modifier : undefined,
+ supprimer : undefined
+ },
+
+ icon : {
+ creation : undefined,
+ modification : undefined,
+ suppression : undefined
+ }
+
+};
+
+eliot.absences.saisie.punitions.PunitionCUDToolbarView = Ext.extend(Ext.util.Observable, {
+ /**
+ * Construction d'un toolbar
+ */
+ constructor: function(config) {
+ this.constantes = eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes;
+ var Modele = eliot.absences.saisie.punitions.PunitionCUDToolbarViewModele;
+
+ // Config par défaut
+ var cfg = {
+ boutonsAAJouter : []
+ };
+
+ // Charge la config fournie
+ Ext.apply(cfg, config);
+
+ this.addEvents(
+ /**
+ * @event actionCreer déclenché lorsque le bouton
+ * 'Créer' est choisi
+ */
+ this.constantes.eventId.actionCreer,
+
+ /**
+ * @event actionModifier déclenché lorsque le
+ * bouton 'Modifier' est choisi
+ */
+ this.constantes.eventId.actionModifier,
+
+ /**
+ * @event actionSupprimer déclenché lorsque le
+ * bouton 'Supprimer' est choisi
+ */
+ this.constantes.eventId.actionSupprimer
+ );
+
+ // Bouton "Créer"
+ this.btnCreer = new Ext.Button({
+ xtype: 'tbbutton',
+ text: Modele.libelle.creer,
+ icon: Modele.icon.creation,
+ listeners: {
+ click : function() {
+ this.actionCreer();
+ },
+ scope : this
+
+ },
+ disabled: !config.isSaisieAutorisee
+ });
+
+ // Bouton "Modifer"
+ this.btnModifier = new Ext.Button({
+ xtype: 'tbbutton',
+ text: Modele.libelle.modifier,
+ icon: Modele.icon.modification,
+ disabled : true,
+ listeners: {
+ click : function() {
+ this.actionModifier();
+ },
+ scope : this
+ }
+ });
+
+ // Bouton "Supprimer"
+ this.btnSupprimer = new Ext.Button({
+ xtype: 'tbbutton',
+ text : Modele.libelle.supprimer,
+ icon : Modele.icon.suppression,
+ disabled : true,
+ listeners: {
+ click : function() {
+ this.actionSupprimer()
+ },
+ scope : this
+ }
+ });
+
+ // Construction de toolbar
+ this.cudToolbar = new Ext.Toolbar({
+ border: true,
+ autoWidth:true,
+ height: 35
+// ,
+// disabled : !config.activeCUD
+ });
+
+ var separator = {
+ xtype: 'tbseparator'
+ };
+
+ this.cudToolbar.add(
+ this.btnCreer,
+ separator,
+ this.btnModifier,
+ separator,
+ this.btnSupprimer
+ );
+
+ // Ajout d'éventuels boutons
+ var nombreDeBoutonAAjouter = cfg.boutonsAAJouter.length;
+ if (nombreDeBoutonAAjouter > 0) {
+ for (var i = 0; i < nombreDeBoutonAAjouter; i++) {
+ this.cudToolbar.add(
+ separator,
+ cfg.boutonsAAJouter[i]
+ );
+ }
+ }
+
+ },
+
+ /**
+ * Déclenche l'évènement actionCreer
+ */
+ actionCreer: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionCreer
+ );
+ },
+
+ /**
+ * Déclenche l'évènement actionModifier
+ */
+ actionModifier: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionModifier
+ );
+ },
+
+ /**
+ * Déclenche l'évènement actionSupprimer
+ */
+ actionSupprimer: function() {
+ this.fireEvent(
+ this.constantes.eventId.actionSupprimer
+ );
+ },
+
+ /**
+ * Observe le controller afin de mettre à jour
+ * l'état des boutons suivants : - Bouton de modification
+ * - Bouton de suppression
+ *
+ * @param controller
+ */
+ observeController : function(controller) {
+ controller.addListener(
+ this.constantes.eventId.changeEtatBtnModifier,
+ this.changeEtatBtnModifier,
+ this
+ );
+ controller.addListener(
+ this.constantes.eventId.changeEtatBtnSupprimer,
+ this.changeEtatBtnSupprimer,
+ this
+ );
+ },
+
+ /**
+ * Change l'état de bouton supprimer (activé/désactivé)
+ * @param active flag
+ */
+ changeEtatBtnSupprimer : function(active) {
+ if (active) {
+ this.btnSupprimer.enable();
+ }
+ else {
+ this.btnSupprimer.disable();
+ }
+ },
+
+ /**
+ * Change l'état de bouton modifier (activé/désactivé)
+ * @param active flag
+ */
+ changeEtatBtnModifier : function(active) {
+ if (active) {
+ this.btnModifier.enable();
+ }
+ else {
+ this.btnModifier.disable();
+ }
+ }
+
+
+});
\ No newline at end of file
constructor:function (filter) {
this.Constantes = eliot.absences.saisie.punitions.Constantes;
this.Modele = eliot.absences.saisie.punitions.Modele;
- var toolBarEventsId = eliot.absences.commons.
- CUDToolbarViewConstantes.eventId;
+ var toolBarEventsId = eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes.eventId;
this.BoutonExportEventsId = eliot.exportdonnees.
BoutonExportControllerConstantes.eventId;
},
{
name:'absenceLiee'
+ },
+ {
+ name: this.Modele.dataIndex.isUtilisateurCourantAuteur
}
],
root:'data',
// Observe les actions de la toolbar (Création/Modification/Suppression)
observeCUDToolBarView:function (CUDToolBarView) {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.
+ var toolBarEventsId = eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes.
eventId;
CUDToolBarView.addListener(
toolBarEventsId.actionCreer,
* @param recordSelectionne le record seléctionné
*/
actionSelectionPunition:function (recordSelectionne) {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.eventId;
+ var toolBarEventsId = eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes.eventId;
this.idPunitionSelectionne = recordSelectionne.id;
// Mise à jour de l'état des boutons
- this.fireEvent(toolBarEventsId.changeEtatBtnModifier, true);
- this.fireEvent(toolBarEventsId.changeEtatBtnSupprimer, true);
+ var activeBoutonsModifierSupprimer = false;
+ var activeCUD = this.Modele.data.activeCUD;
+ var autoriseSaisiePunition = this.Modele.data.autoriseSaisiePunition;
+ var isAuteurPunition = recordSelectionne.get('isUtilisateurCourantAuteur');
+ if (activeCUD == true || activeCUD == undefined){
+ activeBoutonsModifierSupprimer = true;
+ } else {
+ activeBoutonsModifierSupprimer = (autoriseSaisiePunition == true && isAuteurPunition == true)
+ }
+
+ this.fireEvent(toolBarEventsId.changeEtatBtnModifier, activeBoutonsModifierSupprimer);
+ this.fireEvent(toolBarEventsId.changeEtatBtnSupprimer, activeBoutonsModifierSupprimer);
},
/**
*
*/
changeEtatToolBarApresSuppression:function () {
- var toolBarEventsId = eliot.absences.commons.CUDToolbarViewConstantes.
+ var toolBarEventsId = eliot.absences.saisie.punitions.PunitionCUDToolbarViewConstantes.
eventId;
this.fireEvent(
toolBarEventsId.changeEtatBtnModifier,
}
// le zone des absences liée
+ var isSaisieRetenueAutorisee = false;
+ var activeCUD = NameSpace.Modele.data.activeCUD;
+ var autoriseSaisieRetenue = NameSpace.Modele.data.autoriseSaisieRetenue;
+ if (activeCUD == true || activeCUD == undefined){
+ isSaisieRetenueAutorisee = true
+ } else {
+ isSaisieRetenueAutorisee = (autoriseSaisieRetenue == true)
+ }
+
this.absenceLieePunitionView = new eliot.absences.saisie.punition.
creermodifier.FieldSetView({
isAbsenceLiee:isAbsenceLiee,
absenceInfo:absenceInfo,
- isModeModification:isModeModification
+ isModeModification:isModeModification,
+ disabled:!isSaisieRetenueAutorisee
});
/********************* Toolbar tout en haut *********************/
- // Toolbar View
+ // gestion des droits de modification de la punition
+ var boutonsActifs = false;
+ if (activeCUD == true || activeCUD == undefined){
+ boutonsActifs = true;
+ } else if (isModeModification) {
+ boutonsActifs = (NameSpace.Modele.data.autoriseSaisiePunition == true && punitionData.isUtilisateurCourantAuteur == true);
+ } else {
+ boutonsActifs = (NameSpace.Modele.data.autoriseSaisiePunition == true);
+ }
+ //
+
this.toolbarView = new eliot.absences.commons.SaveCancelToolBarView({
- enregistrerActive:NameSpace.Modele.data.activeCRUD,
- annulerActive:NameSpace.Modele.data.activeCRUD
+ enregistrerActive:boutonsActifs,
+ annulerActive:boutonsActifs
});
var motifIdParDefault = this.absenceLieePunitionView.motifController.store.
// Définition de la configuration par défaut
var defaultConfig = {
isAbsenceLiee : false,
- absenceInfo : absenceInfo
+ absenceInfo : absenceInfo,
+ disabled:undefined
};
// Charge la config passée en paramètre
// Evénements
this.addEvents(
- /**
- * @event actionCliqueAbsencesLieePunition déclenché quand le
- * checkBox est chroché ou décroché
- * @param isAbsenceLiee true : checked; false : unchecked
- */
- eliot.absences.saisie.punition.creermodifier.Constantes.
- eventId.actionCliqueAbsencesLieePunition
- );
+ /**
+ * @event actionCliqueAbsencesLieePunition déclenché quand le
+ * checkBox est chroché ou décroché
+ * @param isAbsenceLiee true : checked; false : unchecked
+ */
+ eliot.absences.saisie.punition.creermodifier.Constantes.
+ eventId.actionCliqueAbsencesLieePunition
+ );
// Variable
// this.Namespace = eliot.absences.saisie.punition.creermodifier;
/********************* Date début *********************/
- // Date controller
+ // Date controller
this.dateDebutController = new eliot.absences.commons.DateController({
date : config.absenceInfo.dateDebut
});
this.dateDebutView = new eliot.absences.commons.DateView({
date : config.absenceInfo.dateDebut,
anneeScolaire : Ext.decode(
- eliot.absences.saisie.punition.creermodifier.Modele.
- data.anneeScolaire
- ),
+ eliot.absences.saisie.punition.creermodifier.Modele.
+ data.anneeScolaire
+ ),
fieldLabel : eliot.absences.saisie.punition.creermodifier.Modele.
- libelle.libelleDateDebut,
- champObligatoir : true
+ libelle.libelleDateDebut,
+ champObligatoir : true,
+ disabled : config.disabled
});
this.dateDebutController.observeDateView(this.dateDebutView);
/************************* Heure début ***********************/
- // Heure controller
+ // Heure controller
this.heureDebutController = new eliot.absences.commons.ComboBoxController({
selectFirst : true,
heureCombo : true,
store : this.heureDebutController.store,
libelle : '',
champsObligatoire : false,
- width :60
+ width :60,
+ disabled : config.disabled
});
this.heureDebutController.observeComboBoxView(this.heureDebutView);
/********************* Date fin *********************/
- // Date controller
+ // Date controller
this.dateFinController = new eliot.absences.commons.DateController({
date : config.absenceInfo.dateFin
});
this.dateFinView = new eliot.absences.commons.DateView({
date : config.absenceInfo.dateFin,
anneeScolaire : Ext.decode(
- eliot.absences.saisie.punition.creermodifier.Modele.
- data.anneeScolaire
- ),
+ eliot.absences.saisie.punition.creermodifier.Modele.
+ data.anneeScolaire
+ ),
fieldLabel : eliot.absences.saisie.punition.creermodifier.Modele.
- libelle.libelleDateFin,
- champObligatoir : true
+ libelle.libelleDateFin,
+ champObligatoir : true,
+ disabled : config.disabled
});
this.dateFinController.observeDateView(this.dateFinView);
/************************* Heure fin ***********************/
- // Heure controller
+ // Heure controller
this.heureFinController = new eliot.absences.commons.ComboBoxController({
selectFirst : true,
heureCombo : true,
store : this.heureFinController.store,
libelle : '',
champsObligatoire : false,
- width :60
+ width :60,
+ disabled : config.disabled
});
this.heureFinController.observeComboBoxView(this.heureFinView);
valeurInitiale : this.motifController.valeurInitiale,
store : this.motifController.store,
libelle : eliot.absences.saisie.punition.creermodifier.Modele.
- libelle.motifCombo,
+ libelle.motifCombo,
champsObligatoire : true,
- width : 270
+ width : 270,
+ disabled : config.disabled
});
this.motifController.observeComboBoxView(this.motifView);
this.fieldSet = new Ext.form.FieldSet({
- checkboxToggle:true,
+ checkboxToggle:!config.disabled,
title: eliot.absences.saisie.punition.creermodifier.Modele.
- libelle.absenceLiePunition,
+ libelle.absenceLiePunition,
width: 620,
height : 90,
collapsed: !this.isAbsenceLiee,
// ce qui déclenche des actions non souhaitables.
// cette événement est réinscrit dans l'action 'afterrender'
this.fieldSet.removeListener(
- 'collapse',
- this.actionCollapseAbsence,
- this
- );
+ 'collapse',
+ this.actionCollapseAbsence,
+ this
+ );
this.observeFieldSet();
},
this.isAbsenceLiee = true;
this.fireEvent(
- eliot.absences.saisie.punition.creermodifier.Constantes.
- eventId.actionCliqueAbsencesLieePunition,
- this.isAbsenceLiee
- );
+ eliot.absences.saisie.punition.creermodifier.Constantes.
+ eventId.actionCliqueAbsencesLieePunition,
+ this.isAbsenceLiee
+ );
},
scope: this
}
afterRender : {
fn : function() {
this.fieldSet.addListener(
- 'collapse',
- this.actionCollapseAbsence,
- this
- );
+ 'collapse',
+ this.actionCollapseAbsence,
+ this
+ );
},
scope :this
}
*/
actionDecocheAbsenceLiee : function() {
eliot.absences.Message.afficherDialogConfirmation(
- eliot.absences.saisie.punition.creermodifier.Modele.titre.changementAbsenceLiee,
- eliot.absences.saisie.punition.creermodifier.Modele.message.confirmationChangementParams,
- this.actionDecocheAbsence.createDelegate(this),
- this.cocheAbsenceLiee.createDelegate(this)
- );
+ eliot.absences.saisie.punition.creermodifier.Modele.titre.changementAbsenceLiee,
+ eliot.absences.saisie.punition.creermodifier.Modele.message.confirmationChangementParams,
+ this.actionDecocheAbsence.createDelegate(this),
+ this.cocheAbsenceLiee.createDelegate(this)
+ );
},
/**
eliot.absences.Message.resetMessages();
this.isAbsenceLiee = false;
this.fireEvent(
- eliot.absences.saisie.punition.creermodifier.Constantes.
- eventId.actionCliqueAbsencesLieePunition,
- this.isAbsenceLiee
- )
+ eliot.absences.saisie.punition.creermodifier.Constantes.
+ eventId.actionCliqueAbsencesLieePunition,
+ this.isAbsenceLiee
+ )
}
});
\ No newline at end of file
listeHeureDebut:undefined,
listeHeureFin:undefined,
criteres: undefined,
- activeCRUD: undefined,
+ activeCUD: undefined,
+ autoriseSaisiePunition: undefined,
+ autoriseSaisieRetenue: undefined,
dataMotifs:undefined
},
/********************* Toolbar tout en haut *********************/
// Toolbar View
this.toolbarView = new eliot.absences.commons.SaveCancelToolBarView({
- enregistrerActive:NameSpace.Modele.data.activeCRUD,
- annulerActive:NameSpace.Modele.data.activeCRUD
+ enregistrerActive:NameSpace.Modele.data.activeCUD,
+ annulerActive:NameSpace.Modele.data.activeCUD
});
var motifIdParDefault = this.absenceLieeSanctionView.motifController.store.
listeHeureDebut:undefined,
listeHeureFin:undefined,
criteres:undefined,
- activeCRUD:undefined
+ activeCUD:undefined
},
icon:{