static mapping = {
table('ent.structure_enseignement')
id column: 'id', generator: 'sequence', params: [sequence: 'ent.structure_enseignement_id_seq']
- groupes joinTable: [name: 'ent.rel_classe_groupe', key: 'classe_id', column: 'groupe_id']
- classes joinTable: [name: 'ent.rel_classe_groupe', key: 'groupe_id', column: 'classe_id']
- filieres joinTable: [name: 'ent.rel_classe_filiere', key: 'classe_id', column: 'filiere_id']
+ groupes joinTable: [name: 'ent.rel_classe_groupe', key: 'classe_id', column: 'groupe_id'], batchSize: 50
+ classes joinTable: [name: 'ent.rel_classe_groupe', key: 'groupe_id', column: 'classe_id'], batchSize: 50
+ filieres joinTable: [name: 'ent.rel_classe_filiere', key: 'classe_id', column: 'filiere_id'], batchSize: 50
}
/**
}
Closure action = {
- return internalCreeTypeIncident(pref, libelle)
+ return creeTypeIncident(pref, libelle)
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
* @throws org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
* @throws org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
*/
- protected TypeIncident internalCreeTypeIncident(PreferencesEtablissementAbsences pref,
- String libelle
+ TypeIncident creeTypeIncident(PreferencesEtablissementAbsences pref,
+ String libelle
) throws LibelleLongException,
CreationContraintException {
}
Closure action = {
- return internalCreeTypePunition(pref, libelle)
+ return creeTypePunition(pref, libelle)
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
return GormUtils.withSavepoint(action, onDataIntegrityViolation)
}
- protected TypePunition internalCreeTypePunition(PreferencesEtablissementAbsences pref,
- String libelle
+ TypePunition creeTypePunition(PreferencesEtablissementAbsences pref,
+ String libelle
) throws LibelleLongException,
CreationContraintException {
return type
}
-/**
- * vérifie les propriétés du type
- * - le nombre de caractères mpax
- * - l'unicité
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
+ /**
+ * vérifie les propriétés du type
+ * - le nombre de caractères mpax
+ * - l'unicité
+ * @throws LibelleLongException
+ * @throws CreationContraintException
+ */
void save(TypePunition type)
throws LibelleLongException,
CreationContraintException {
return GormUtils.withSavepoint(action, onDataIntegrityViolation)
}
- protected TypeSanction internalCreeTypeSanction(PreferencesEtablissementAbsences pref,
- String libelle
+ TypeSanction creeTypeSanction(PreferencesEtablissementAbsences pref,
+ String libelle
) throws LibelleLongException,
CreationContraintException {
import org.lilie.services.eliot.absences.GroupeMotif
import org.lilie.services.eliot.absences.Motif
import org.lilie.services.eliot.parametrages.motifs.GroupeMotifService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.AnneeScolaire
return getPreferencesEtablissementForEtablissement(etab)
}
- /**
- * Modification des préférences d'un établissement par un utilisateur
- * @param identifiant : identifiant de la préférence établissement
- * @param pas_decompte : pas de décompte des absences
- * @param securiteSession : session de l'utilisateur
- * @return les préférences modifiées
- */
- PreferencesEtablissementAbsences modifiePreferencesEtablissement(Long identifiant,
- String pasDecompte,
- SecuriteSession securiteSession) {
- PreferencesEtablissementAbsences pref =
- PreferencesEtablissementAbsences.get(identifiant)
-
- return internalModifiePreferencesEtablissement(pref, pasDecompte)
- }
/**
* Modification interne des préférences d'un établissement par un utilisateur
* @param pas_decompte : pas de décompte des absences
* @return les préférences modifiées
*/
- private PreferencesEtablissementAbsences internalModifiePreferencesEtablissement(
+ PreferencesEtablissementAbsences modifiePreferencesEtablissement(
PreferencesEtablissementAbsences pref, String pasDecompte) {
pref.pasDecompte = pasDecompte
pref.validate()
import org.lilie.services.eliot.securite.perimetre.PerimetreEleve
import org.lilie.services.eliot.securite.perimetre.PerimetreEnseignement
import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
+import org.lilie.services.eliot.scolarite.PreferencesEtablissement
+import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
class EliotDroitsService {
}
break
+ case (PreferencesEtablissement):
+ PreferencesEtablissement pref = (PreferencesEtablissement) obj
+ if (hasDroitAccesEtablissement(securiteSession, pref.etablissement)) {
+ return
+ }
+ break
+
+ case (PreferencesEtablissementAbsences):
+ PreferencesEtablissementAbsences pref = (PreferencesEtablissementAbsences) obj
+ if (hasDroitAccesEtablissement(securiteSession, pref.etablissement)) {
+ return
+ }
+ break
+
case (Service):
if (hasDroitAccesService(securiteSession, (Service) obj)) {
return
driverClassName = "org.postgresql.Driver"
username = "eliot"
password = "eliot"
- loggingSql = true
+ loggingSql = false
}
hibernate {
cache.use_second_level_cache=true
package org.lilie.services.eliot.absences
import org.lilie.services.eliot.absences.page.Page
-import org.lilie.services.eliot.annuaire.SecuriteSession
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
return (Calendrier.findByEtablissement(pref.etablissement))
}
-
}
/**
*/
protected Object getDefaultPage(Object pageSouhaitee) {
- Page page = null
-
List<Object> allPageAccessibles = findAllPageAccessibles(Page)
if (allPageAccessibles.find {it == Page.CONSULTATION_PAR_PARENT}) {
}
}
- List<EliotFonctionnalites> allFonctionnalite = findAllFonctionnaliteCourante()
-
- MenuEntete.each {
+ return getPremierePageAccessible()
+ }
- MenuEntete menuEntete ->
- MenuSousMenu.each {MenuSousMenu menuSousMenu ->
+ private Page getPremierePageAccessible() {
+ List<EliotFonctionnalites> allFonctionnalite = findAllFonctionnaliteCourante()
- if (menuSousMenu.menuEnteteEnum.toString() == menuEntete.toString()) {
+ for (MenuEntete menuEntete : MenuEntete.values()) {
- if (allFonctionnalite.find {it.getCode() == menuSousMenu.page.fonctionnalite.getCode()}) {
+ for (MenuSousMenu menuSousMenu : MenuSousMenu.values()) {
- if (!page) {
- if (menuSousMenu.page != Page.NOTIFICATION_PREFERNCE_UTILISATEUR) {
- page = (Page) menuSousMenu.page
- }
- }
+ if (menuSousMenu.menuEnteteEnum.toString() == menuEntete.toString() &&
+ allFonctionnalite.find {it.getCode() == menuSousMenu.page.fonctionnalite.getCode()}) {
+ if (menuSousMenu.page != Page.NOTIFICATION_PREFERNCE_UTILISATEUR) {
+ return (Page) menuSousMenu.page
}
}
}
-
}
- return page
+
+ return null
}
import org.lilie.services.eliot.scolarite.Etablissement
import java.text.SimpleDateFormat
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.securite.impl.Autorite
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.SessionUtils
import org.lilie.services.eliot.scolarite.Calendrier
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.temps.DateUtil
import org.lilie.services.eliot.absences.AppelLigne
return criteria
}
-/**
- * Retourne les infos sur les classe de l'établissement du CPE
- * @return une liste de Map
- */
- private List getClassesForEtablissement() {
- List resultat = []
- List<StructureEnseignement> structures = []
-
- structures +=
- localStructureEnseignementService.findAllClasseByEtablissement(
- etablissementCourant()
- )
-
- structures.each {
- StructureEnseignement struct ->
- resultat << new HashMap([
- id: struct.id,
- libelle: struct.code
- ])
- }
- return resultat
- }
-
-/**
- * Retourne les infos sur les structures d'enseignements dans lesquels l'enseignant enseigne
- * @return une liste de Map
- */
- private List getStructuresEnseignementForEnseignant(Etablissement etablissement) {
- SecuriteSession securiteSession = SessionUtils.securiteSession(session)
-
- List resultat = []
- List<StructureEnseignement> structures =
- localStructureEnseignementService.findAllStructureEnseignementByEnseignantAndEtablissement(
- (Autorite) securiteSession.defaultAutorite,
- etablissement
- )
-
- structures.each {
- StructureEnseignement struct ->
- resultat << new HashMap([
- id: struct.id,
- libelle: struct.code
- ])
- }
- return resultat
- }
private List formateStructureEnseignement(List<StructureEnseignement> structures){
return structures.collect {StructureEnseignement struct ->
criteria.dateFin.setTime(DateUtil.parseDateJavascript(dateFin))
}
- protected void parseBilanCriteraiDatesJSFormat(Map params,
- BasicCriteresRecherche criteria) {
- Calendar dateDebut = Calendar.getInstance()
- dateDebut.setTime(DateUtil.parseDateJavascript(params.dateDebut))
- DateUtil.setDebutJour(dateDebut)
- criteria.dateDebut = dateDebut
-
- Calendar dateFin = Calendar.getInstance()
- dateFin.setTime(DateUtil.parseDateJavascript(params.dateFin))
- DateUtil.setFinJour(dateFin)
- criteria.dateFin = dateFin
- }
/**
* traduit les codes I18n correspondant à profilAppelant
String libelle = params.libelle
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+
+ verifieDroitAccesObjetDomaine(pref)
+
try {
- absencesTypeIncidentService.creeTypeIncident(
- getSecuriteSession(),
- pref,
- libelle
- )
+ absencesTypeIncidentService.creeTypeIncident(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
TypeIncident type = TypeIncident.get(identifiant)
+
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
if (type) {
try {
- absencesTypeIncidentService.modifieTypeIncident(
- getSecuriteSession(),
- type,
- libelle
- )
+ absencesTypeIncidentService.modifieTypeIncident(type, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
TypeIncident type = TypeIncident.get(identifiant)
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
if (type) {
try {
- absencesTypeIncidentService.supprimeTypeIncident(getSecuriteSession(), type)
+ absencesTypeIncidentService.supprimeTypeIncident(type)
}
catch (SuppressionContraintException e) {
render getResultError(
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+
+ verifieDroitAccesObjetDomaine(pref)
+
try {
- absencesTypeSanctionService.creeTypeSanction(
- getSecuriteSession(),
- pref,
- libelle
- )
+ absencesTypeSanctionService.creeTypeSanction(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
TypeSanction type = TypeSanction.get(identifiant)
+
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
if (type) {
try {
- absencesTypeSanctionService.modifieTypeSanction(
- getSecuriteSession(),
- type,
- libelle
- )
+ absencesTypeSanctionService.modifieTypeSanction(type, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
TypeSanction type = TypeSanction.get(identifiant)
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
if (type) {
try {
absencesTypeSanctionService.supprimeTypeSanction(getSecuriteSession(), type)
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+
+ verifieDroitAccesObjetDomaine(pref)
+
try {
- absencesTypePunitionService.creeTypePunition(
- getSecuriteSession(),
- pref,
- libelle
- )
+ absencesTypePunitionService.creeTypePunition(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
TypePunition type = TypePunition.get(identifiant)
+
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
if (type) {
try {
- absencesTypePunitionService.modifieTypePunition(
- getSecuriteSession(),
- type,
- libelle
- )
+ absencesTypePunitionService.modifieTypePunition(type, libelle)
}
catch (LibelleLongException e) {
render getResultError(
if (type) {
+ verifieDroitAccesObjetDomaine(type.preferencesEtablissement)
+
try {
- absencesTypePunitionService.supprimeTypePunition(getSecuriteSession(), type)
+ absencesTypePunitionService.supprimeTypePunition(type)
}
catch (SuppressionContraintException e) {
render getResultError(
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+ verifieDroitAccesObjetDomaine(pref)
+
try {
- qualiteProtagonisteService.creeQualiteProtagoniste(
- getSecuriteSession(),
- pref,
- libelle
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
QualiteProtagoniste protagoniste = QualiteProtagoniste.get(identifiant)
if (protagoniste) {
+
+ verifieDroitAccesObjetDomaine(protagoniste.preferencesEtablissement)
+
try {
- qualiteProtagonisteService.modifieQualiteProtagoniste(
- getSecuriteSession(),
- protagoniste,
- libelle
- )
+ qualiteProtagonisteService.modifieQualiteProtagoniste(protagoniste, libelle)
}
catch (LibelleLongException e) {
render getResultError(
if (protagoniste) {
+ verifieDroitAccesObjetDomaine(protagoniste.preferencesEtablissement)
+
try {
- qualiteProtagonisteService.supprimeQualiteProtagoniste(
- getSecuriteSession(),
- protagoniste
- )
+ qualiteProtagonisteService.supprimeQualiteProtagoniste(protagoniste)
}
catch (SuppressionContraintException e) {
render getResultError(
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+ verifieDroitAccesObjetDomaine(pref)
+
try {
- partenaireAPrevenirService.creePartenaireAPrevenir(
- getSecuriteSession(),
- pref,
- libelle
- )
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
PartenaireAPrevenir partenaire = PartenaireAPrevenir.get(identifiant)
if (partenaire) {
+
+ verifieDroitAccesObjetDomaine(partenaire.preferencesEtablissement)
+
try {
- partenaireAPrevenirService.modifiePartenaireAPrevenir(
- getSecuriteSession(),
- partenaire,
- libelle
- )
+ partenaireAPrevenirService.modifiePartenaireAPrevenir(partenaire, libelle)
}
catch (LibelleLongException e) {
render getResultError(
PartenaireAPrevenir partenaire = PartenaireAPrevenir.get(identifiant)
if (partenaire) {
+
+ verifieDroitAccesObjetDomaine(partenaire.preferencesEtablissement)
+
try {
- partenaireAPrevenirService.supprimePartenaireAPrevenir(
- getSecuriteSession(),
- partenaire
- )
+ partenaireAPrevenirService.supprimePartenaireAPrevenir(partenaire)
}
catch (SuppressionContraintException e) {
render getResultError(
Map resultats
PreferencesEtablissementAbsences pref = getPreferencesEtablissementCourant()
+ verifieDroitAccesObjetDomaine(pref.etablissement)
+
try {
- lieuIncidentService.creeLieuIncident(
- getSecuriteSession(),
- pref,
- libelle
- )
+ lieuIncidentService.creeLieuIncident(pref, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
LieuIncident lieu = LieuIncident.get(identifiant)
+
+ verifieDroitAccesObjetDomaine(lieu.preferencesEtablissement)
+
if (lieu) {
try {
- lieuIncidentService.modifieLieuIncident(
- getSecuriteSession(),
- lieu,
- libelle
- )
+ lieuIncidentService.modifieLieuIncident(lieu, libelle)
}
catch (LibelleLongException e) {
render getResultError(
Map resultats
LieuIncident lieu = LieuIncident.get(identifiant)
+ verifieDroitAccesObjetDomaine(lieu.preferencesEtablissement)
+
if (lieu) {
try {
- lieuIncidentService.supprimeLieuIncident(
- getSecuriteSession(),
- lieu
- )
+ lieuIncidentService.supprimeLieuIncident(lieu)
}
catch (SuppressionContraintException e) {
render getResultError(
SaisieCollectiveParams saisieCollectiveParams = parseSaisieCollective(paramInfo)
if (saisieCollectiveParams.eleves) {
+ saisieCollectiveParams.eleves.each {
+ verifieDroitAccesObjetDomaine(it)
+ }
+
CalendrierHebdo calendrierHebdo = saisieCollectiveService.enregistre(
securiteSession,
saisieCollectiveParams
Map map = plageHoraireInfoMarshallerService.marshallPlageHoraireInfo(
plage
)
- fermeJoursFeries(joursFeries, calendar, map, {rang -> map["jour${rang}"].etatJour = EtatJourEnum.JOURNEE.valeur})
+
+ fermeJoursFeries(joursFeries, calendar, map) {
+ rang -> map["jour${rang}"].etatJour = EtatJourEnum.JOURNEE.valeur
+ }
+
result << map
}
return result
Calendar calendar = Calendar.getInstance(locale)
- fermeJoursFeries(joursFeries, calendar, ligneCalendrier, {rang -> ligneCalendrier.jours[rang - 1].plageOuverte = false})
-
+ fermeJoursFeries(joursFeries, calendar, ligneCalendrier) {
+ rang -> ligneCalendrier.jours[rang - 1].plageOuverte = false
+ }
ligneCalendrierMarshallerService.marshall(ligneCalendrier, sdf)
}
import org.springframework.context.ApplicationContextAware
import org.springframework.context.ApplicationContext
import java.text.SimpleDateFormat
-import org.lilie.services.eliot.absences.saisie.dispense.DispensesMarshallerReferentiel
/**
* Service de marshalling pour les dates
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.demipensioninternat
import org.lilie.services.eliot.absences.AbstractAbsencesController
* @author ywan
* @author bahj
*/
-
class SaisieDemiPensionInternatController extends AbstractAbsencesController {
CalendrierService calendrierService
lignes: getLignesParamsACreer(parametres.aCreer)
)
- List<AppelLigne> lignesCrees = demiPensionInternatService.creeAbsences(
- session,
- pensionParams
- )
+ pensionParams.lignes.each {
+ verifieDroitAccesObjetDomaine(it.eleve)
+ }
+
+ List<AppelLigne> lignesCrees = demiPensionInternatService.creeAbsences(pensionParams)
// Modification des absences à modifier
List<DemiPensionInternatLigneParams> lignesAModifier = getLignesParamsAModifier(
parametres.aModifier
)
- demiPensionInternatService.modifieAbsences(session,
- etablissement,
- lignesAModifier
- )
+
+ demiPensionInternatService.modifieAbsences(lignesAModifier)
// Suppression des absences à supprimer
- demiPensionInternatService.supprimeAbsences(session,
- etablissement,
- parametres.aSupprimer
- )
+ demiPensionInternatService.supprimeAbsences(parametres.aSupprimer)
Map result = [
success: true,
import groovy.time.TimeCategory
import org.lilie.services.eliot.absences.AbstractAbsencesController
-import org.lilie.services.eliot.absences.TypeSanction
import org.lilie.services.eliot.absences.page.Page
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import grails.converters.JSON
ConfigurationHolder.config.eliot.absences.incident.consultation.
nombreLignesParPage ?: 100
+
/**
* Page de consultations des incidents
* @author bahj
)
}
+
private void addFilterData(Map modele) {
PreferencesEtablissementAbsences preferences =
getPreferencesEtablissementCourant()
return responsables
}
+
/**
* Alimente la page de consultation des incidents
*/
render resultats as JSON
}
- Map parseCriteres(def jsonCriteres) {
+
+ private Map parseCriteres(def jsonCriteres) {
Map result = [:]
if (jsonCriteres != null) {
Integer limit) {
Map criteres = parseCriteres(jsonCriteres)
+ verifieDroitAccesObjetDomaine(getPreferencesEtablissementCourant())
+
ListeIncidentsInfo listeIncidents = absencesIncidentService.findIncidents(
securiteSession,
securiteSession.personne,
[incidents : incidentInfos, nbr : listeIncidents.nbIncidents]
}
+
def findIncidentsCSV = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
donneesPourExportCSV,
"incidents"
)
-
}
+
/**
* Affiche la page de création d'un nouvel incident
*/
)
}
+
/**
* Affiche l'incident en mode modification
*/
// pas la fonctionnalité ABS_SAISIE_INC_PUN_SAN_CUD car les enseignants
// ont le doit d'accèder à cette page sans pour autant pouvoir modifier les données.
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN)
- Map resultats = [:]
- Long idIncident = Long.parseLong(params.id)
+
+ Incident incident = Incident.get(params.id)
+
+ if (incident) {
+ affichePageModification(incident)
+ } else {
+ Map resultats = [
+ success: false,
+ message: message(
+ code: 'absences.saisie.incidents.incident.modification.inexistant'
+ )
+ ]
+ render resultats as JSON
+ }
+
+ }
+
+
+ private void affichePageModification(Incident incident) {
Boolean isModeModification = null
Boolean isAnnuler = null
isAnnuler = Boolean.parseBoolean(params.isAnnuler)
}
- Incident incident = Incident.get(idIncident)
-
- if (!incident) {
- resultats = [
- success: false,
- message: message(
- code: 'absences.saisie.incidents.incident.modification.inexistant'
- )
- ]
- render resultats as JSON
- return
- }
-
// construction du modèle
Map modele = prepareBaseModele(Page.SAISIE_INCIDENTS)
if (isModeModification != null) {
- if (isModeModification) {
- if (isAnnuler) {
- modele.message = message(
- code: 'absences.saisie.incidents.modification.annuler.succes'
- )
- }
- else {
- modele.message = message(
- code: 'absences.saisie.incidents.modification.succes'
- )
- }
- }
- else {
- if (!isAnnuler) {
- modele.message = message(
- code: 'absences.saisie.incidents.creation.succes'
- )
- }
- }
+ modele.message = getMessageModification(isModeModification, isAnnuler)
}
- modele.incidentAModifieInfo = getIncidentModificationInfo(
- incident
- ) as JSON
-
+ modele.incidentAModifieInfo = getIncidentModificationInfo(incident) as JSON
- PreferencesEtablissementAbsences preferences =
- getPreferencesEtablissementCourant()
+ PreferencesEtablissementAbsences preferences = getPreferencesEtablissementCourant()
Calendrier calendrier =
calendrierService.getCalendrierForEtablissement(preferences.etablissement)
debutAnneeScolaire: formateDate(calendrier.premierJour),
finAnneeScolaire: formateDate(calendrier.dernierJour)
] as JSON
+
Locale locale = RCU.getLocale(request)
modele.dataTypesProtagoniste = enumMarshallerService.getEnumData(
TypeProtagonisteIncident,
locale
) as JSON
+
modele.profils = enumMarshallerService.getEnumData(ProfilCenseur, locale) as JSON
modele.etablissements = getEtablissementsAccessiblesInfo() as JSON
modele.etablissementCourant = preferences.etablissementId
modele.dataLieuxIncident = getAllLieuxIncident() as JSON
modele.dataNaturesIncident = getAllTypesIncident() as JSON
modele.dataPartenairesAPrevenir = getAllPartenairesAPrevenir() as JSON
+
modele.activeCRUD = droitsService.hasDroitFonctionnalite(
getSecuriteSession(),
AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD
)
}
+
+ private String getMessageModification(Boolean isModeModification, Boolean isAnnuler) {
+ String msg = null
+
+ if (isModeModification) {
+ if (isAnnuler) {
+ msg = message(code: 'absences.saisie.incidents.modification.annuler.succes')
+ }
+ else {
+ msg = message(code: 'absences.saisie.incidents.modification.succes')
+ }
+ }
+ else {
+ if (!isAnnuler) {
+ msg = message(code: 'absences.saisie.incidents.creation.succes')
+ }
+ }
+
+ return msg
+ }
+
/**
* Vérifie si l'incident est référencié ou pas dans
* les punitions et les sanctions
render resultats as JSON
}
+
/**
* Switch la création et la modification d'un incident
* @author bahj
preferences: preferences
)
+ verifieDroitAccesObjetDomaine(preferences.etablissement)
if (identifiant) {
// Mode Modification
- resultats = modifieIncident(incidentParams,
- Long.parseLong(identifiant)
- )
+ resultats = modifieIncident(incidentParams, Long.parseLong(identifiant))
}
else {
// Mode création
render resultats as JSON
}
+
/**
* Cree un incident
*/
Incident incident = null
try {
- incident = absencesIncidentService.creeIncident(getSecuriteSession(),
- incidentACreerParams
- )
+ incident = absencesIncidentService.creeIncident(incidentACreerParams)
resultats = [
success: true,
return resultats
}
+
/**
* Modifie un incident
*/
Incident incident = Incident.get(idIncident)
if (incident) {
try {
- absencesIncidentService.modifieIncident(getSecuriteSession(),
+ absencesIncidentService.modifieIncident(
incident,
incidentAModifierDto
)
return resultats
}
+
def supprimeIncident = {
// Vérifie les droits d'accès à la page
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
Incident incident = Incident.get(Long.parseLong(params.id))
+
Map resultats
+
if (incident) {
try {
- absencesIncidentService.supprimeIncident(
- securiteSession,
- incident
- )
+ verifieDroitAccesObjetDomaine(incident.etablissement)
+
+ absencesIncidentService.supprimeIncident(incident)
+
resultats = [
success: true,
message: message(
}
}
-
return partenairesDto
}
return protagonistesDto
}
-/**
- * Construit un incidentModificationInfo, utilisé dans la vue de modification
- * @author bahj
- */
+
+ /**
+ * Construit un incidentModificationInfo, utilisé dans la vue de modification
+ * @author bahj
+ */
private IncidentModificationInfo getIncidentModificationInfo(Incident incident) {
return new IncidentModificationInfo(
idPartenaires: getPartenairesPrevenusModification(incident),
description: incident.description
)
-
}
-/**
- * Construit la liste des partenaires à prévenir de l'incident à modifier
- * @author bahj
- */
+
+ /**
+ * Construit la liste des partenaires à prévenir de l'incident à modifier
+ * @author bahj
+ */
private String getPartenairesPrevenusModification(Incident incident) {
String idPartenaires = ''
return idPartenaires
}
-/**
- * Construit la liste des protagonistes de l'incident à modifier
- * @author bahj
- */
+
+ /**
+ * Construit la liste des protagonistes de l'incident à modifier
+ * @author bahj
+ */
private List<ProtagonisteModificationInfo> getProtagonistesModificationInfo(
Incident incident
) {
return protagonistesModInfo
}
-/**
- * Gestion du breadCrumbs
- */
+
+ /**
+ * Gestion du breadCrumbs
+ */
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
breadCrumbsInfo << new BreadCrumbsItemInfo(
import groovy.time.TimeCategory
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
-import org.lilie.services.eliot.absences.TypeProtagonisteIncident
-import org.lilie.services.eliot.absences.TypeSanction
import org.lilie.services.eliot.scolarite.Calendrier
import grails.converters.JSON
import org.lilie.services.eliot.absences.page.Page
modele.dateDebut = formateDate(dateDebut)
modele.dateFin = formateDate(dateFin)
- Locale locale = RCU.getLocale(request)
-
modele.etablissementId = etablissementCourantId()
modele.types = getAllTypesPunition() as JSON
modele.classes = getAllClassesAccessibles() as JSON
render resultatsJson as JSON
}
- Map parseCriteres(def jsonCriteres) {
+ private Map parseCriteres(def jsonCriteres) {
Map result = [:]
if (jsonCriteres != null) {
Punition punition = Punition.get(Long.parseLong(params.id))
+ verifieDroitAccesObjetDomaine(punition.eleve)
+
if (punition) {
try {
- absencesPunitionService.supprimePunition(getSecuriteSession(), punition)
+ absencesPunitionService.supprimePunition(punition)
resultats = [
success: true,
def enregistrePunition = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
Map resultat
- String msg = ''
Punition punition
Long punitionId = null
try {
if (punitionParams.id) {
punition = Punition.get(punitionParams.id)
punitionId = punition.id
- absencesPunitionService.modifiePunition(
- getSecuriteSession(),
- punition,
- punitionParams
- )
+
+ verifieDroitAccesObjetDomaine(punition.eleve)
+
+ absencesPunitionService.modifiePunition(punition, punitionParams)
}
else {
- punition = absencesPunitionService.creePunition(
- getSecuriteSession(),
- punitionParams
- )
+ verifieDroitAccesObjetDomaine(punitionParams.eleve)
+
+ punition = absencesPunitionService.creePunition(punitionParams)
+
if (punitionId == null) {
punitionId = punition.id
}
import org.lilie.services.eliot.absences.Sanction
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.temps.DateUtil
import java.text.SimpleDateFormat
import org.lilie.services.eliot.securite.impl.Autorite
modele.dateDebut = formateDate(dateDebut)
modele.dateFin = formateDate(dateFin)
- Locale locale = RCU.getLocale(request)
-
modele.etablissementId = etablissementCourantId()
modele.types = getAllTypesSanction() as JSON
modele.classes = getAllClassesAccessibles() as JSON
render resultatsJson as JSON
}
- Map parseCriteres(def jsonCriteres) {
+ private Map parseCriteres(def jsonCriteres) {
Map result = [:]
if (jsonCriteres != null) {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
Map resultats = [:]
- Sanction sanction = Sanction.get(Long.parseLong(params.id))
+ Sanction sanction = Sanction.get(params.id)
+
+ verifieDroitAccesObjetDomaine(sanction.eleve)
if (sanction) {
try {
- absencesSanctionService.supprimeSanction(getSecuriteSession(), sanction)
+ absencesSanctionService.supprimeSanction(sanction)
resultats = [
success: true,
def enregistreSanction = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
Map resultat
- String msg = ''
Sanction sanction = null
Long sanctionId = null
Boolean modification = false
sanctionsParams.each {SanctionParams sanctionParams ->
+ verifieDroitAccesObjetDomaine(sanctionParams.eleve)
+
if (sanctionParams.id) {
sanction = Sanction.get(sanctionParams.id)
sanctionId = sanction.id
modification = true
absencesSanctionService.modifieSanction(
- getSecuriteSession(),
sanction,
sanctionParams
)
}
else {
- sanction = absencesSanctionService.creeSanction(
- getSecuriteSession(),
- sanctionParams
- )
+ sanction = absencesSanctionService.creeSanction(sanctionParams)
if (sanctionId == null) {
sanctionId = sanction.id
}
package org.lilie.services.eliot.absences.saisie.dispense
-import java.text.SimpleDateFormat
import org.lilie.services.eliot.temps.DateUtil
-import org.lilie.services.eliot.absences.Motif
/**
* Service de marshalling des dispenses
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_ABS_RETARDS_DEPARTS)
List<AbsenceJourneeParams> absenceJourneeParams = parseParams(params.data)
+
+ List<Personne> eleves = absenceJourneeParams*.lignes*.personne.flatten().unique()
+
+ eleves.each {
+ verifieDroitAccesObjetDomaine(it)
+ }
+
List<AbsenceJourneeLigneInfo> lignesCreees = saisieHebdomadaireService.
- enregistreSaisieHebdo(securiteSession, absenceJourneeParams)
+ enregistreSaisieHebdo(absenceJourneeParams)
def result = [
data: lignesCreees.collect { it.getInfos() },
lstLignes.each { Map lig ->
- if (log.debugEnabled) log.debug lig
+ if (log.debugEnabled) {log.debug lig}
LigneResultatRequeteConsultation ligneRes = new LigneResultatRequeteConsultation(lig)
* qui sont définis par les constantes dans AbstractSqlBuilder : ALIAS_*
* @author jbui
*/
+@SuppressWarnings("AbcComplexity")
class LigneResultatRequeteConsultation {
Long appelLigneId
Boolean retard
import org.lilie.services.eliot.applications.absences.BasicCriteresRecherche
import org.lilie.services.eliot.impression.requetage.PublipostageCriteresRecherche
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.impression.ImpressionSuiviEleveService
-import org.lilie.services.eliot.impression.requetage.ImpressionRequetageAbsencesService
-import org.lilie.services.eliot.impression.ImpressionMoteurService
import org.lilie.services.eliot.impression.donnees.eleve.SelectionAdresseResponsableEnum
import org.lilie.services.eliot.impression.donnees.eleve.EleveImpressionInfo
import org.lilie.services.eliot.impression.ImpressionRequetageService
import org.lilie.services.eliot.DateConstantes
import org.lilie.services.eliot.absences.AbsencesDateUtil
import org.lilie.services.eliot.export.DonneesPourExportCSV
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.absences.saisie.discipline.sanction.AbsencesSanctionService
+
import org.lilie.services.eliot.absences.Sanction
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBord
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordLigne
-import org.lilie.services.eliot.absences.saisie.discipline.punition.AbsencesPunitionService
import org.lilie.services.eliot.absences.Punition
-import org.lilie.services.eliot.absences.saisie.discipline.incident.ListeIncidentsInfo
-
-import org.lilie.services.eliot.securite.Autorite
-import org.lilie.services.eliot.absences.Incident
-import org.lilie.services.eliot.absences.ProtagonisteIncident
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveRecupService
-import org.lilie.services.eliot.absences.saisie.discipline.incident.AffichageIncidentService
import org.lilie.services.eliot.absences.saisie.discipline.incident.IncidentConsultationInfo
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordTotaux
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
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
-import org.lilie.services.eliot.securite.perimetre.PerimetreEnseignement
-import org.lilie.services.eliot.scolarite.Enseignement
/**
* Preparation des donnees pour l'export CSV
*/
class AbsencesPreparationExportCSVService {
- enum OuiNon {
- OUI('Oui'), NON('Non')
- OuiNon(String value) { this.value = value }
- private final String value
- public String value() { return value }
- }
-
-
-
static transactional = true
- AbsencesSanctionService absencesSanctionService
- AbsencesPunitionService absencesPunitionService
- EleveAnnuaireService eleveAnnuaireService
DroitsService droitsService
- AffichageIncidentService affichageIncidentService
- EleveRecupService eleveRecupService
private static final DecimalFormat DF = new DecimalFormat("###.##")
- private static final FIND_INCIDENTS = """
- select distinct incident from Incident as incident
- inner join fetch incident.protagonistes as protagoniste_incident
- inner join fetch protagoniste_incident.autorite
- inner join fetch protagoniste_incident.qualite
- left join fetch incident.partenairesAPrevenir as partenaire_incident
- left join fetch partenaire_incident.partenaireAPrevenir
- inner join fetch incident.type as typeIncident
- inner join fetch incident.lieu as lieuIncident
- where incident.etablissement.id = :etablissementId
-"""
/**
* L'export de resultat de la recherche avec une liste multicritere
sanction?.eleve?.nomAffichage(),
structureEnseignement.getNomAffichage(),
sanction?.censeur?.nomAffichage(),
- sanction.effectue ? OuiNon.OUI.value() : OuiNon.NON.value()
+ sanction.effectue ? OuiNon.OUI.getValue() : OuiNon.NON.getValue()
]
}
structureEnseignement.getNomAffichage(),
punition.typePunition.libelle,
punition?.censeur?.nomAffichage(),
- punition.effectue ? OuiNon.OUI.value() : OuiNon.NON.value()
+ punition.effectue ? OuiNon.OUI.getValue() : OuiNon.NON.getValue()
]
}
return donneesPourExportCSV
}
- /**
- * Retourne une liste d'Incident correspondant aux critères
- * @param etablissement : l'établissement dont on veut les incidents
- * @param champOrdre : l'ordre de classement des incidents
- * @param ascendant : indique si le classement est croissant
- * @param start : l'indice du premier enregistrement à retourner
- * @param limit : le nombre d'enregistrement à retourner
- * @return une List<Incident>
- */
- private ListeIncidentsInfo findListeIncidentsInfo(SecuriteSession securiteSession,
- Personne personne,
- Etablissement etablissement
- ) {
-
- List<Autorite> eleves = []
- ListeIncidentsInfo result = new ListeIncidentsInfo(
- nbIncidents: 0,
- incidents: []
- )
- Map hqlParams = [etablissementId: etablissement.id]
- String hql = FIND_INCIDENTS
- Boolean aQuePermietreService = droitsService.hasOnlyPerimetreEnseignement(
- securiteSession
- )
-
- if (aQuePermietreService) {
- List<Enseignement> enseignements =
- droitsService.getAllObjetDuPerimetre(securiteSession, PerimetreEnseignement)
-
- eleves = eleveAnnuaireService.findAllEleveByService(
- securiteSession,
- enseignements*.service*.id
- )?.collect { it.autorite }
-
-
- if (eleves.size() == 0) {
- return result
- }
- hql += ' and protagoniste_incident.autorite in (:eleves)'
- hqlParams.eleves = eleves
- result.nbIncidents =
- (Integer) ProtagonisteIncident.createCriteria().get {
- 'in'('autorite', eleves)
- incident {
- eq('etablissement', etablissement)
- }
- projections {
- 'countDistinct'('incident')
- }
- }
- }
- else {
- result.nbIncidents = Incident.countByEtablissement(etablissement)
- }
-
- result.incidents = Incident.executeQuery(
- hql,
- hqlParams
- )
-
- return result
- }
/**
* Recherche les données des incidents pour générer un fichier csv
--- /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.export
+
+/**
+ * @author bper
+ */
+public enum OuiNon {
+ OUI('Oui'), NON('Non')
+ OuiNon(String value) { this.value = value }
+ private final String value
+ public String getValue() { return value }
+}
\ No newline at end of file
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 {
* <http://www.cecill.info/licences.fr.html>.
*/
-
package org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction
import org.lilie.services.eliot.absences.TypeIncident
-import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.securite.AutorisationException
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
DroitsService droitsService
- /**
- * Permet de créer un type d'incident
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé du type d'incident
- * @return type : type d'incident
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- TypeIncident creeTypeIncident(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalCreeTypeIncident(pref, libelle)
- }
/**
* Permet de supprimer un type d'incident
* Vérifie les droits de suppression
*/
- void supprimeTypeIncident(SecuriteSession securiteSession,
- TypeIncident type
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimeTypeIncident(TypeIncident type) throws SuppressionContraintException {
try {
type.delete(flush: true)
}
}
- /**
- * Permet de modifier un type d'incident
- * Vérifie les droits de modification
- * @param securiteSession la session courante
- * @param type le type à modifier
- * @param libelle le libelle du type
- * @return type le type d'incident modifié
- * @throws AutorisationException
- */
- TypeIncident modifieTypeIncident(SecuriteSession securiteSession,
- TypeIncident type,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalModifieTypeIncident(type, libelle)
- }
-
/**
* permet de modifier un type d'incident
* @return type le type d'incident modifié
*/
- TypeIncident internalModifieTypeIncident(TypeIncident type, String libelle)
+ TypeIncident modifieTypeIncident(TypeIncident type, String libelle)
throws LibelleLongException,
CreationContraintException {
package org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
+
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
-import org.lilie.services.eliot.securite.AutorisationException
import org.springframework.dao.DataIntegrityViolationException
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
DroitsService droitsService
- /**
- * Permet de créer un type de punition
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé du type de la punition
- * @return type : type de punition crée
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- TypePunition creeTypePunition(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalCreeTypePunition(pref, libelle)
- }
-
- /**
+ /**
* Permet de supprimer un type de punition
* Vérifie les droits de suppression
*/
- void supprimeTypePunition(SecuriteSession securiteSession,
- TypePunition type
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimeTypePunition(TypePunition type) throws SuppressionContraintException {
try {
type.delete(flush: true)
}
}
-/**
- * Permet de modifier un type de punition
- * Vérifie les droits de modification
- * @param securiteSession la session courante
- * @param type le type à modifier
- * @param libelle le libelle du type
- * @return type le type de punition modifié
- * @throws AutorisationException
- */
- TypePunition modifieTypePunition(SecuriteSession securiteSession,
- TypePunition type,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalModifieTypePunition(type, libelle)
- }
-
/**
* permet de modifier un type de punition
* @return type le type de punition modifié
*/
- TypePunition internalModifieTypePunition(TypePunition type, String libelle)
+ TypePunition modifieTypePunition(TypePunition type, String libelle)
throws LibelleLongException,
CreationContraintException {
package org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
-import org.lilie.services.eliot.securite.AutorisationException
import org.springframework.dao.DataIntegrityViolationException
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
DroitsService droitsService
- /**
- * Permet de créer un type de sanction
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé du type de la sanction
- * @return type : type de sanction crée
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- TypeSanction creeTypeSanction(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalCreeTypeSanction(pref, libelle)
- }
-
/**
* Permet de supprimer un type de sanction
- * Vérifie les droits de suppression
*/
- void supprimeTypeSanction(SecuriteSession securiteSession,
- TypeSanction type
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimeTypeSanction(TypeSanction type)
+ throws SuppressionContraintException {
try {
type.delete(flush: true)
/**
* Permet de modifier un type de sanction
- * Vérifie les droits de modification
- * @param securiteSession la session courante
- * @param type le type à modifier
- * @param libelle le libelle du type
- * @return type le type de sanction modifié
- * @throws AutorisationException
- */
- TypeSanction modifieTypeSanction(SecuriteSession securiteSession,
- TypeSanction type,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
-
- return internalModifieTypeSanction(type, libelle)
- }
-
- /**
- * permet de modifier un type de sanction
- * @return type le type de sanction modifié
*/
- TypeSanction internalModifieTypeSanction(TypeSanction type, String libelle)
+ TypeSanction modifieTypeSanction(TypeSanction type,
+ String libelle)
throws LibelleLongException,
CreationContraintException {
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.LieuIncident
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
public final static String ELEMENT = "lieu d'incident"
- /**
- * Permet de créer un lieu d'incident
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé du lieu d'incident
- * @return lieu : lieu crée
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- LieuIncident creeLieuIncident(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
- return internalCreeLieuIncident(pref, libelle)
- }
-
- private LieuIncident internalCreeLieuIncident(
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws LibelleLongException,
- CreationContraintException {
+ LieuIncident creeLieuIncident(PreferencesEtablissementAbsences pref,
+ String libelle)
+ throws LibelleLongException,
+ CreationContraintException {
LieuIncident lieu = new LieuIncident(
- preferencesEtablissement: pref,
- libelle: libelle
+ preferencesEtablissement: pref,
+ libelle: libelle
)
save(lieu)
* Permet de supprimer un lieu d'incident
* Vérifie les droits de suppression
*/
- void supprimeLieuIncident(SecuriteSession securiteSession,
- LieuIncident lieu
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimeLieuIncident(LieuIncident lieu) throws SuppressionContraintException {
try {
lieu.delete(flush: true)
* @return lieu le lieu d'incident modifié
* @throws AutorisationException
*/
- LieuIncident modifieLieuIncident(SecuriteSession securiteSession,
- LieuIncident lieu,
+ LieuIncident modifieLieuIncident(LieuIncident lieu,
String libelle
) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
+ LibelleLongException,
+ CreationContraintException {
return internalModifieLieuIncident(lieu, libelle)
}
* @return lieu le lieu d'incident modifiée
*/
LieuIncident internalModifieLieuIncident(
- LieuIncident lieu,
- String libelle
+ LieuIncident lieu,
+ String libelle
)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
lieu.libelle = libelle
save(lieu)
*/
void save(LieuIncident lieu)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
// Validation du nombre de caractères [max 30]
if (!lieu.validate(["libelle"])) {
// Lève une exception
* @return lieu : la liste des lieux d'incident
*/
List<LieuIncident> getLieuxIncident(
- PreferencesEtablissementAbsences pref
+ PreferencesEtablissementAbsences pref
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
List<LieuIncident> lieux = LieuIncident.withCriteria {
eq('preferencesEtablissement.id', pref.id)
List<LieuIncident> lieux = []
for (DefaultsLieuIncident lieu: DefaultsLieuIncident.values()) {
lieux.add(getLieuIncident(pref,
- messageSource.getMessage(lieu.libelle, null, null))
+ messageSource.getMessage(lieu.libelle, null, null))
)
}
throws LibelleLongException, CreationContraintException {
LieuIncident lieu = LieuIncident.
- findByLibelleAndPreferencesEtablissement(libelle, pref)
+ findByLibelleAndPreferencesEtablissement(libelle, pref)
if (lieu != null) {
return lieu
}
// Création à la volée (avec gestion de la concurrence)
Closure action = {
- return internalCreeLieuIncident(pref, libelle)
+ return creeLieuIncident(pref, libelle)
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
-import org.lilie.services.eliot.securite.AutorisationException
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.PartenaireAPrevenir
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
public final static String ELEMENT = "partenir à prévenir"
- /**
- * Permet de créer un partenaire à prévenir
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé du partenaire à prévenir
- * @return partenaire : partenaire crée
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- PartenaireAPrevenir creePartenaireAPrevenir(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalCreePartenaireAPrevenir(pref, libelle)
- }
- private PartenaireAPrevenir internalCreePartenaireAPrevenir(
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws LibelleLongException,
+ PartenaireAPrevenir creePartenaireAPrevenir(PreferencesEtablissementAbsences pref,
+ String libelle)
+ throws LibelleLongException,
CreationContraintException {
PartenaireAPrevenir partenaire = new PartenaireAPrevenir(
* Permet de supprimer un partenaire à prévenir
* Vérifie les droits de suppression
*/
- void supprimePartenaireAPrevenir(SecuriteSession securiteSession,
- PartenaireAPrevenir partenaire
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimePartenaireAPrevenir(PartenaireAPrevenir partenaire)
+ throws SuppressionContraintException {
try {
partenaire.delete(flush: true)
}
- /**
- * Permet de modifier un partenir à prévenir
- * Vérifie les droits de modification
- * @param securiteSession la session courante
- * @param partenaire le partenaire à modifier
- * @param libelle le libelle du partenaire
- * @return partenaire le partenaire à prévenir modifié
- * @throws AutorisationException
- */
- PartenaireAPrevenir modifiePartenaireAPrevenir(SecuriteSession securiteSession,
- PartenaireAPrevenir partenaire,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalModifiePartenaireAPrevenir(partenaire, libelle)
- }
-
/**
* permet de modifier un partenir à prévenir
* @return partenaire le partenaire à prévenir modifiée
*/
- PartenaireAPrevenir internalModifiePartenaireAPrevenir(
- PartenaireAPrevenir partenaire,
- String libelle
- )
+ PartenaireAPrevenir modifiePartenaireAPrevenir(PartenaireAPrevenir partenaire,
+ String libelle)
throws LibelleLongException,
CreationContraintException {
// Création à la volée (avec gestion de la concurrence)
Closure action = {
- return internalCreePartenaireAPrevenir(pref, libelle)
+ return creePartenaireAPrevenir(pref, libelle)
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
-
-
-
-
package org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction
import org.lilie.services.eliot.absences.securite.DroitsService
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
-import org.lilie.services.eliot.securite.AutorisationException
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.QualiteProtagoniste
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
public final static String ELEMENT = "qualité protagoniste"
- /**
- * Permet de créer une qualité de protagoniste
- * Vérifie les droits de création
- * @param securiteSession : la session courante
- * @param pref : la préfénerence de l'établissement
- * @param libelle : le libellé de la qualité de protagoniste
- * @return protagoniste : protagoniste crée
- * @throws LibelleLongException
- * @throws CreationContraintException
- */
- QualiteProtagoniste creeQualiteProtagoniste(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalCreeQualiteProtagoniste(pref, libelle)
- }
- private QualiteProtagoniste internalCreeQualiteProtagoniste(
- PreferencesEtablissementAbsences pref,
- String libelle
- ) throws LibelleLongException,
- CreationContraintException {
+ QualiteProtagoniste creeQualiteProtagoniste(PreferencesEtablissementAbsences pref,
+ String libelle)
+ throws LibelleLongException,
+ CreationContraintException {
QualiteProtagoniste protagoniste = new QualiteProtagoniste(
- preferencesEtablissement: pref,
- libelle: libelle
+ preferencesEtablissement: pref,
+ libelle: libelle
)
save(protagoniste)
* Permet de supprimer une qualité de protagoniste
* Vérifie les droits de suppression
*/
- void supprimeQualiteProtagoniste(SecuriteSession securiteSession,
- QualiteProtagoniste protagoniste
- ) throws AutorisationException,
- SuppressionContraintException {
+ void supprimeQualiteProtagoniste(QualiteProtagoniste protagoniste)
+ throws SuppressionContraintException {
try {
protagoniste.delete(flush: true)
}
}
- /**
- * Permet de modifier une qualité de protagoniste
- * Vérifie les droits de modification
- * @param securiteSession la session courante
- * @param protagoniste la qualité de protagoniste à modifier
- * @param libelle le libelle du protagoniste
- * @return protagoniste la qualité de protagoniste modifié
- * @throws AutorisationException
- */
- QualiteProtagoniste modifieQualiteProtagoniste(SecuriteSession securiteSession,
- QualiteProtagoniste protagoniste,
- String libelle
- ) throws AutorisationException,
- LibelleLongException,
- CreationContraintException {
-
- return internalModifieQualiteProtagoniste(protagoniste, libelle)
- }
-
/**
* permet de modifier une qualité de protagoniste
* @return protagoniste la qualité de protagoniste modifiée
*/
- QualiteProtagoniste internalModifieQualiteProtagoniste(
- QualiteProtagoniste protagoniste,
- String libelle
- )
+ QualiteProtagoniste modifieQualiteProtagoniste(QualiteProtagoniste protagoniste,
+ String libelle)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
protagoniste.libelle = libelle
save(protagoniste)
*/
void save(QualiteProtagoniste protagoniste)
throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
// Validation du nombre de caractères [max 30]
if (!protagoniste.validate(["libelle"])) {
* @return protagonistes : la liste des qualités de protagoniste
*/
List<QualiteProtagoniste> getQualitesProtagoniste(
- PreferencesEtablissementAbsences pref
+ PreferencesEtablissementAbsences pref
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
List<QualiteProtagoniste> protagonistes = QualiteProtagoniste.withCriteria {
eq('preferencesEtablissement.id', pref.id)
}
private List<QualiteProtagoniste> creeQualitesProtagonisteParDefaut(
- PreferencesEtablissementAbsences pref
+ PreferencesEtablissementAbsences pref
) throws LibelleLongException,
- CreationContraintException {
+ CreationContraintException {
List<QualiteProtagoniste> protagonistes = []
for (DefaultsQualiteProtagoniste protagonisteEnum: DefaultsQualiteProtagoniste.values()) {
protagonistes.add(getQualiteProtagoniste(pref,
- messageSource.getMessage(protagonisteEnum.libelle, null, null))
+ messageSource.getMessage(protagonisteEnum.libelle, null, null))
)
}
// Classement
throws LibelleLongException, CreationContraintException {
QualiteProtagoniste protagoniste = QualiteProtagoniste.
- findByLibelleAndPreferencesEtablissement(libelle, pref)
+ findByLibelleAndPreferencesEtablissement(libelle, pref)
if(protagoniste != null) {
return protagoniste
// Création à la volée (avec gestion de la concurrence)
Closure action = {
- return internalCreeQualiteProtagoniste(pref, libelle)
+ return creeQualiteProtagoniste(pref, libelle)
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
return QualiteProtagoniste.
- findByLibelleAndPreferencesEtablissement(libelle, pref)
+ findByLibelleAndPreferencesEtablissement(libelle, pref)
}
return GormUtils.withSavepoint(action, onDataIntegrityViolation)
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.absencejournee
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.absences.saisie.absencejournee.exceptions.AbsenceJourneeException
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.absences.Motif
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.temps.Time
import org.lilie.services.eliot.GormUtils
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 {
* @param params : décrit l'absence journée à enregistrer
* @return une List<AbsenceJourneeLigneInfo>
*/
- List<AbsenceJourneeLigneInfo> enregistreAbsenceJournee(
- SecuriteSession securiteSession,
- AbsenceJourneeParams params) throws AutorisationException {
+ List<AbsenceJourneeLigneInfo> enregistreAbsenceJournee(AbsenceJourneeParams params)
+ throws AutorisationException {
+
List<AbsenceJourneeLigneInfo> result = []
//on régularise l'heure à 0:00
List<AbsenceJourneeLigneParams> lignesASupprimer = params.lignes.findAll {
it.aSupprimer
}.toList()
- internalSupprimeLignesAbsenceJournee(securiteSession, lignesASupprimer, params.etablissement)
+ internalSupprimeLignesAbsenceJournee(lignesASupprimer)
return result
}
- private void internalSupprimeLignesAbsenceJournee(SecuriteSession securiteSession,
- List<AbsenceJourneeLigneParams> absenceJourneeLigneParams,
- Etablissement etablissement
- ) {
+ private void internalSupprimeLignesAbsenceJournee(List<AbsenceJourneeLigneParams> absenceJourneeLigneParams) {
absenceJourneeLigneParams.each {
if (it.appelLigne.appel) {
it.appelLigne.appel.appelLignes.remove(it.appelLigne)
}
}
+ @SuppressWarnings('AbcComplexity')
private void internalModifieLignesAbsenceJournee(
List<AbsenceJourneeLigneParams> absenceJourneeLigneParams) {
* Crée la ou les absences associées à une sanction
* @return une liste d'appelLigne
*/
- protected void internalCreeAbsencesForSanction(Autorite operateurSaisie,
- Sanction sanction
+ void creeAbsencesForSanction(Autorite operateurSaisie,
+ Sanction sanction
) throws AbsenceJourneeException {
if (sanction.absenceLiee) {
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneService
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneCreationInfo
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
-import org.lilie.services.eliot.annuaire.TypeStructureEnum
/**
* @author jbui
return appelsEleveInfo
}
-/**
- * Retourne la liste ordonnée des autorités des élèves de la structure
- * @return une List<Autorite>
- */
- private List<Autorite> getListeAutoriteEleves(
- StructureEnseignement structureEnseignement, SecuriteSession securiteSession) {
-
-
- List<Personne> personnesEleve = eleveAnnuaireService.findAllEleveByStructureEnseignementFetchAutorite(
- structureEnseignement
- )
- personnesEleve.sort {Personne eleve1, Personne eleve2 ->
- eleve1.nomAffichage() <=> eleve2.nomAffichage()
- }
- return personnesEleve*.autorite
- }
-
-/**
- * Retourne l'heure de fin d'un appel
- */
+ /**
+ * Retourne l'heure de fin d'un appel
+ */
private Time getFinAppel(Appel appel, PlageHoraire plage) {
if (appel) {
Time time = new Time(new Date());
}
}
-/**
- * Retourne la liste des plages horaires avec les informations concernant leur ouverture
- * et les appels associés
- */
+ /**
+ * Retourne la liste des plages horaires avec les informations concernant leur ouverture
+ * et les appels associés
+ */
public List<PlageAppelInfo> getGrilleHoraire(SecuriteSession securiteSession,
PreferencesEtablissementAbsences pref,
StructureEnseignement structureEnseignement,
return result
}
-/**
- * Teste s'il y a des absences prévisionnelles sur la plage horaire
- * @return un Boolean
- */
+ /**
+ * Teste s'il y a des absences prévisionnelles sur la plage horaire
+ * @return un Boolean
+ */
Boolean plagePossedeAbsencesPrev(AbsenceJourneeInfo absenceJourneeInfo,
PlageHoraire plageHoraire) {
Boolean result = false
return result
}
-/**
- * Retourne la liste des appels du jour
- */
+ /**
+ * Retourne la liste des appels du jour
+ */
private List<Appel> getAppelsDuJour(Date date, StructureEnseignement structureEnseignement) {
Calendar calDebutJour = Calendar.getInstance()
calDebutJour.setTime(date)
)
}
List<AbsenceJourneeLigneInfo> resultat = saisieHebdomadaireService.enregistreSaisieHebdo(
- securiteSession,
listeAbsenceJourneeParams
)
CalendrierHebdo result = getCalendrierHebdo(resultat)
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
*
*/
- List<AppelLigne> creeAbsences(SecuriteSession securiteSession,
- DemiPensionInternatParams params
- ) throws AutorisationException {
+ List<AppelLigne> creeAbsences(DemiPensionInternatParams params)
+ throws AutorisationException {
// On régularise l'heure à 0:00
params.date = AbsencesDateUtil.getDay(params.date)
getPreferencesEtablissementForEtablissement(params.etablissement)
)
- return internalCreeAbsences(params, absenceJournee)
+ return creeAbsences(params, absenceJournee)
}
- /**
- * Permet de modifier un ensemble d'absences de demi-internat ou de l'internat
- * @author bahj
- * @param securiteSession la session en court
- * @param etablissement établissement courant
- * @return appelLignesModifies la liste des appels lignes modifiés
- * @throws AutorisationException
- *
- */
- List<AppelLigne> modifieAbsences(SecuriteSession securiteSession,
- Etablissement etablissement,
- List<DemiPensionInternatLigneParams> lignes
- ) throws AutorisationException {
-
- return internalModifieAbsences(lignes)
- }
-
- /**
- * Permet de supprimer un ensemble d'absences de demi-internat ou de l'internat
- * @author bahj
- * @param securiteSession la session en court
- * @param etablissement établissement courant
- * @return appelLignesModifies la liste des appels lignes modifiés
- * @throws AutorisationException
- *
- */
- void supprimeAbsences(SecuriteSession securiteSession,
- Etablissement etablissement,
- List<Long> idsAppelLignes
- ) throws AutorisationException {
-
- internalSupprimeAbsences(idsAppelLignes)
- }
/**
* Retourne l'ensemble des absences internat ou demi-internat
* @return appelLignesCrees la liste des appels lignes crées
*
*/
- private List<AppelLigne> internalCreeAbsences(DemiPensionInternatParams params,
- AbsenceJournee absenceJournee
- ) {
+ private List<AppelLigne> creeAbsences(DemiPensionInternatParams params,
+ AbsenceJournee absenceJournee) {
List<AppelLigne> appelLignesCrees = []
StructureEnseignement structureEnseignement = null // anti N+1 select
* @return appelLignesModifies la liste des appels lignes modifiés
*
*/
- private List<AppelLigne> internalModifieAbsences(List<DemiPensionInternatLigneParams> lignes) {
+ List<AppelLigne> modifieAbsences(List<DemiPensionInternatLigneParams> lignes) {
List<AppelLigne> appelLignesModifies = []
* Permet de supprimer un ensemble d'absences de demi-internat ou de l'internat
* @author bahj
* @return appelLignesModifies la liste des appels lignes modifiés
- *
*/
- private void internalSupprimeAbsences(List<Long> idsAppelLignes) {
+ void supprimeAbsences(List<Long> idsAppelLignes) {
idsAppelLignes.each { Long id ->
AppelLigne ligne = AppelLigne.get(id)
ligne.delete()
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.incident
import groovy.time.TimeCategory
import org.lilie.services.eliot.absences.Incident
import org.lilie.services.eliot.absences.ScolariteService
import org.lilie.services.eliot.absences.TypeProtagonisteIncident
-import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.personne.PersonneAnnuaireService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.absences.ProtagonisteIncident
import org.lilie.services.eliot.absences.PartenaireAPrevenirIncident
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.saisie.discipline.incident.exceptions.SuppressionIncidentContrainteException
inner join fetch incident.type as typeIncident
inner join fetch incident.lieu as lieuIncident
where incident.etablissement.id = :etablissementId
-"""
+ """
/**
* Crée un nouvel incident
- * Vérifie les droits
- * @param securiteSesion : la session courante
- * @param incidentParams : les params de l'incidents
- * @throws AutorisationException
* @author bahj
*/
- Incident creeIncident(SecuriteSession securiteSession,
- IncidentParams incidentParams
- ) throws IncidentException {
+ Incident creeIncident(IncidentParams incidentParams) throws IncidentException {
// Création de l'objet incident
Incident incident = new Incident(
/**
* Supprime un incident
- * vérifie les droits
- * @param securiteSession : la session courante
- * @param incident : l'incident à supprimer
- * @throws AutorisationException
* @author bahj
*/
- void supprimeIncident(SecuriteSession securiteSession,
- Incident incident)
+ void supprimeIncident(Incident incident)
throws IncidentException, SanctionException, PunitionException {
// supprime punitions + sanctions
- absencesSanctionService.internalSupprimeSanctions(securiteSession,incident)
+ absencesSanctionService.internalSupprimeSanctions(incident)
absencesPunitionService.internalSupprimePunitions(incident)
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
/**
* Modifie un incident, vérifie les droits
- * @param securiteSession : la session courante
- * @param incident : l'incident à modifier
- * @param incidentParams : les nouvelles données de l'incident
- * @return un Incident
- * @throws AutorisationException
* @throws IncidentException
* @author bahj
*/
- Incident modifieIncident(SecuriteSession securiteSession,
- Incident incident,
+ Incident modifieIncident(Incident incident,
IncidentParams incidentParams) throws IncidentException {
// modification de l'incident
// modification des partenaires à prévenir
misAjourPartenairesAPrevenir(incident, incidentParams)
+ // Enregistrement
+ internalSave(incident)
+
return incident
}
incident.save(flush: true, failOnError: true)
}
catch (Exception e) {
+ log.error("Erreur lors d'enregistrement d'un incident", e)
throw new IncidentException(null)
}
}
else if ((criteres.typesProtagoniste == null) ||
criteres.typesProtagoniste.contains(TypeProtagonisteIncident.CENSEUR)) {
-
if (((criteres.typesProtagoniste != null) && (criteres.typesProtagoniste.size() > 0)) ||
((criteres.profils != null) && (criteres.profils.size() > 0))) {
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.incident
import org.lilie.services.eliot.scolarite.Etablissement
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
-
-
package org.lilie.services.eliot.absences.saisie.discipline.incident
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.absences.securite.DroitsService
import org.lilie.services.eliot.absences.saisie.discipline.punition.exceptions.PunitionException
import org.lilie.services.eliot.absences.saisie.discipline.punition.exceptions.PunitionDescriptionLongueException
-import org.lilie.services.eliot.securite.AutorisationException
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.saisie.discipline.punition.exceptions.SuppressionPunitionContrainteException
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.securite.perimetre.PerimetreEnseignement
-import org.lilie.services.eliot.absences.AbsencesFonctionnalite
/**
* @author bahj
* Crée une nouvelle punition en vérifiant les droits
* @return une Punition
*/
- Punition creePunition(SecuriteSession securiteSession,
- PunitionParams punitionParams)
- throws PunitionException {
+ Punition creePunition(PunitionParams punitionParams) throws PunitionException {
+
Punition result = new Punition(
date: punitionParams.date,
typePunition: punitionParams.type,
* @param punitionParams : les nouvelles données de la punition
* @return la Punition
*/
- Punition modifiePunition(SecuriteSession securiteSession,
- Punition punitionAModifier,
- PunitionParams punitionParams
- ) throws PunitionException {
+ Punition modifiePunition(Punition punitionAModifier,
+ PunitionParams punitionParams) throws PunitionException {
+
punitionAModifier.date = punitionParams.date
punitionAModifier.typePunition = punitionParams.type
punitionAModifier.effectue = punitionParams.isPunitionEffectuee
return punitionAModifier
}
- /**
- * Supprime une punition en vérifiant les droits
- * @throws AutorisationException
- * @throws PunitionException
- */
- void supprimePunition(SecuriteSession securiteSession,
- Punition punitionASupprimer)
- throws AutorisationException, PunitionException {
- droitsService.verifieDroitFonctionnalite(
- securiteSession,
- AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN
- )
-
- droitsService.verifieDroitAccesObjetDomaine(
- securiteSession,
- punitionASupprimer.etablissement
- )
-
- internalSupprimePunition(punitionASupprimer)
- }
-
/**
* Supprime la punition.
* Ne fait pas de vérification de droits
*/
- void internalSupprimePunition(Punition punition)
- throws PunitionException {
+ void supprimePunition(Punition punition) throws PunitionException {
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
throw new SuppressionPunitionContrainteException(punition, e)
// se permettre de faire un each - ca coute moins que les problemes avec
// la suppression par executeUpdate()
punitions.each { Punition punition ->
- internalSupprimePunition(punition)
+ supprimePunition(punition)
}
}
etablissementId: etablissement.id,
typeClasse: StructureEnseignement.TYPE_CLASSE
]
- List<Personne> eleves = []
String hqlFromPunition = findPunitionHqlFromPunition()
boolean personneIsEnseignant = droitsService.hasOnlyPerimetreEnseignement(
import org.lilie.services.eliot.absences.Sanction
import org.lilie.services.eliot.absences.ScolariteService
-import org.lilie.services.eliot.absences.TypeSanction
import org.lilie.services.eliot.absences.saisie.discipline.sanction.exceptions.SanctionException
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.saisie.discipline.sanction.exceptions.SanctionDescriptionLongueException
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.absences.saisie.discipline.sanction.exceptions.SuppressionSanctionContrainteException
* Crée une nouvelle sanction
* Vérifie les droits
* @return la sanction crée
- * @throws AutorisationException
* @throws SanctionException
- *
*/
- Sanction creeSanction(SecuriteSession securiteSession,
- SanctionParams sanctionParams)
+ Sanction creeSanction(SanctionParams sanctionParams)
throws SanctionException {
Sanction sanction = new Sanction()
internalSave(sanction)
internalSupprimeAbsencesExistantes(sanction)
// TOREFACT : appel méthode protected à partir d'une classe externe
- absenceJourneeService.internalCreeAbsencesForSanction(
+ absenceJourneeService.creeAbsencesForSanction(
sanctionParams.operateurSaisie,
sanction
)
/**
* Permet de modifier une sanction
* Vérifie les droits
- * @rern
- * @throws AutorisationException
* @throws SanctionException
- *
*/
- Sanction modifieSanction(SecuriteSession securiteSession,
- Sanction sanctionAModifier,
- SanctionParams sanctionParams
- ) throws SanctionException {
+ Sanction modifieSanction(Sanction sanctionAModifier,
+ SanctionParams sanctionParams) throws SanctionException {
initialiseSanction(sanctionAModifier, sanctionParams)
/**
* Permet de supprimer une sanction
* vérife les droits
- * @throws AutorisationException
- *
*/
- void supprimeSanction(SecuriteSession securiteSession, Sanction sanction)
+ void supprimeSanction(Sanction sanction)
throws SanctionException {
absenceJourneeService.internalSupprimeAbsencesForSanction(sanction)
* Supprime les sanctions d'un incident
* @throws SanctionException
*/
- public void internalSupprimeSanctions(SecuriteSession securiteSession,
- Incident incident) throws SanctionException {
+ public void internalSupprimeSanctions(Incident incident) throws SanctionException {
List<Sanction> sanctions = Sanction.findAllByIncident(incident)
// on n'attend pas trop des sanctions liees a un incident, donc on peut
// se permettre de faire un each - ca coute moins que les problemes avec
// la suppression par executeUpdate()
sanctions.each { Sanction sanction ->
- supprimeSanction(securiteSession, sanction)
+ supprimeSanction(sanction)
}
}
StructureEnseignement classe,
Matiere matiere,
Date dateDebut,
- Date dateFin
- ) {
+ Date dateFin) {
+
SaisieDispenseReferentiel referentiel = saisieDispenseReferentielService.creeReferentiel(
securiteSession,
dateDebut,
)
}
saisieHebdomadaireService.enregistreSaisieHebdo(
- securiteSession,
listeAbsenceJourneeParams
)
}
* Enregistre les données de la saisie hebdomadaire
* @return une List<AbsenceJourneeLigneInfo>
*/
- List<AbsenceJourneeLigneInfo> enregistreSaisieHebdo(
- SecuriteSession securiteSession,
- List<AbsenceJourneeParams> absenceJournees) {
+ List<AbsenceJourneeLigneInfo> enregistreSaisieHebdo(List<AbsenceJourneeParams> absenceJournees) {
+
List<AbsenceJourneeLigneInfo> result = []
absenceJournees.each { AbsenceJourneeParams absenceJourneeParams ->
List<AbsenceJourneeLigneInfo> lignes = absenceJourneeService.
- enregistreAbsenceJournee(
- securiteSession,
- absenceJourneeParams
- )
+ enregistreAbsenceJournee(absenceJourneeParams)
//on complète le résultat en injectant le numéro du jour
lignes.each {
it.jourId = absenceJourneeParams.numJour
import org.lilie.services.eliot.absences.statistiques.StatsParams
import org.lilie.services.eliot.absences.statistiques.Type
import org.lilie.services.eliot.absences.statistiques.mensuelle.ModeCalcul
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.securite.Autorite
import java.math.RoundingMode
import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTempsService
import org.lilie.services.eliot.temps.DateUtil
-import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class StatsHebdosService extends AbstractConsultationService {
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.absences.AppelLigne
import org.lilie.services.eliot.absences.saisie.demipensioninternat.DemiPensionInternatService
-import org.lilie.services.eliot.absences.Motif
/**
* @author jbui
lignes: [ligne1]
)
- return demiPensionInternatService.creeAbsences(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
- params
- )
+ return demiPensionInternatService.creeAbsences(params)
}
}
import org.lilie.services.eliot.absences.Motif
import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeService
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
-import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.codehaus.groovy.runtime.DateGroovyMethods
import org.lilie.services.eliot.temps.Agenda
import org.lilie.services.eliot.temps.TempsAgendaService
-import org.lilie.services.eliot.temps.TempsEvenementService
import org.lilie.services.eliot.absences.Motif
-import org.lilie.services.eliot.parametrages.motifs.GroupeMotifService
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.parametrages.motifs.MotifService
import org.lilie.services.eliot.absences.saisie.appel.AppelInfo
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.absences.saisie.appel.AppelAvecLignesInfo
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneInfo
-import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeService
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordParams
import org.lilie.services.eliot.annuaire.SecuriteSession
-
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.PartenaireAPrevenirService
-
import org.lilie.services.eliot.absences.saisie.appel.AppelTemporaire
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import java.text.DateFormat
import java.text.SimpleDateFormat
-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.absences.saisie.discipline.incident.AbsencesIncidentService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypePunitionService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBord
/**
* Donnees pour les tests d'integration specifiques a Absence
+ * @author sdim
*/
-/*
-@author sdim
-*/
-
class InitDonneesCommunesTestAbsenceService extends LocalInitDonneesCommunesTestService {
TempsAgendaService tempsAgendaService
- TempsEvenementService tempsEvenementService
- GroupeMotifService groupeMotifService
MotifService motifService
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AppelService appelService
- AbsenceJourneeService absenceJourneeService
- AbsencesTypeIncidentService absencesTypeIncidentService
- LieuIncidentService lieuIncidentService
- QualiteProtagonisteService qualiteProtagonisteService
- PartenaireAPrevenirService partenaireAPrevenirService
- AbsencesIncidentService absencesIncidentService
- AbsencesSanctionService absencesSanctionService
- AbsencesTypeSanctionService absencesTypeSanctionService
- AbsencesTypePunitionService absencesTypePunitionService
- AbsencesPunitionService absencesPunitionService
InitDonneesCommunesTestPreferencesAbsencesService initDonneesCommunesTestPreferencesAbsencesService
- public static final CLASS_CODE_1 = 'CLASSE'
private static final String PATTERN_DATE_LONGUE = "MM/dd/yyyy"
/**
pref
)
return appelId
-
}
/**
DateFormat format = new SimpleDateFormat(PATTERN_DATE_LONGUE, Locale.FRANCE)
Date date = format.parse(chaineDate)
return date
-
}
-
}
package org.lilie.services.eliot.test
import org.lilie.services.eliot.absences.Incident
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.absences.saisie.discipline.incident.IncidentParams
import org.lilie.services.eliot.absences.GraviteIncident
import org.lilie.services.eliot.absences.QualiteProtagoniste
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypePunitionService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
+import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
class InitDonneesCommunesTestDisciplineService extends InitDonneesCommunesTestAbsenceService {
- org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
+ PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AbsencesIncidentService absencesIncidentService
AbsencesTypeIncidentService absencesTypeIncidentService
LieuIncidentService lieuIncidentService
* @return un Incident
*/
Incident getIncident_1_protagoniste_classe_1() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(
getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1))
IncidentParams incidentParams = new IncidentParams(
date: Date.parse('dd/MM/yyyy', '15/10/2010'),
gravite: GraviteIncident.NIVEAU_3,
- type: getTypeIncident1(securiteSession, pref),
- lieu: getLieuIncident1(securiteSession, pref),
+ type: getTypeIncident1(pref),
+ lieu: getLieuIncident1(pref),
description: 'test--description de test',
etablissement: pref.etablissement,
preferences: pref
)
- QualiteProtagoniste qualite = getQualiteProtagoniste1(securiteSession, pref)
+ QualiteProtagoniste qualite = getQualiteProtagoniste1(pref)
incidentParams.protagonistesParams << new ProtagonisteIncidentParams(
id: null,
type: TypeProtagonisteIncident.ELEVE,
incidentParams.partenairesParams << new PartenaireAPrevenirIncidentParams(
id: null,
- partenaireAPrevenir: getPartenaireAPrevenir1(securiteSession, pref)
+ partenaireAPrevenir: getPartenaireAPrevenir1(pref)
)
- return absencesIncidentService.creeIncident(
- securiteSession,
- incidentParams
- )
+ return absencesIncidentService.creeIncident(incidentParams)
}
/**
* Crée un incident avec 2 protagonistes sur la classe 1 et 1 sur la classe_1_2
*/
Incident getIncident_3_protagonistes_classe_1_et_classe_1_2() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(
getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1))
IncidentParams incidentParams = new IncidentParams(
date: Date.parse('dd/MM/yyyy', '15/10/2010'),
gravite: GraviteIncident.NIVEAU_3,
- type: getTypeIncident1(securiteSession, pref),
- lieu: getLieuIncident1(securiteSession, pref),
+ type: getTypeIncident1(pref),
+ lieu: getLieuIncident1(pref),
description: 'test--description de test',
etablissement: pref.etablissement,
preferences: pref
)
- QualiteProtagoniste qualite1 = getQualiteProtagoniste1(securiteSession, pref)
- QualiteProtagoniste qualite2 = getQualiteProtagoniste2(securiteSession, pref)
- QualiteProtagoniste qualite3 = getQualiteProtagoniste3(securiteSession, pref)
+ QualiteProtagoniste qualite1 = getQualiteProtagoniste1(pref)
+ QualiteProtagoniste qualite2 = getQualiteProtagoniste2(pref)
+ QualiteProtagoniste qualite3 = getQualiteProtagoniste3(pref)
incidentParams.protagonistesParams << new ProtagonisteIncidentParams(
id: null,
type: TypeProtagonisteIncident.ELEVE,
incidentParams.partenairesParams << new PartenaireAPrevenirIncidentParams(
id: null,
- partenaireAPrevenir: getPartenaireAPrevenir1(securiteSession, pref)
+ partenaireAPrevenir: getPartenaireAPrevenir1(pref)
)
- return absencesIncidentService.creeIncident(
- securiteSession,
- incidentParams
- )
+ return absencesIncidentService.creeIncident(incidentParams)
}
- TypeIncident getTypeIncident1(SecuriteSession securiteSession, PreferencesEtablissementAbsences pref) {
- return getTypeIncidentForIndice(securiteSession, pref, 1)
+ TypeIncident getTypeIncident1(PreferencesEtablissementAbsences pref) {
+ return getTypeIncidentForIndice(pref, 1)
}
- TypeIncident getTypeIncident2(SecuriteSession securiteSession, PreferencesEtablissementAbsences pref) {
- return getTypeIncidentForIndice(securiteSession, pref, 2)
+ TypeIncident getTypeIncident2(PreferencesEtablissementAbsences pref) {
+ return getTypeIncidentForIndice(pref, 2)
}
- private TypeIncident getTypeIncidentForIndice(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
+ private TypeIncident getTypeIncidentForIndice(PreferencesEtablissementAbsences pref,
Integer indice) {
- TypeIncident result = TypeIncident.findByLibelleAndPreferencesEtablissement(PREFIXE_TYPE_INCIDENT_TEST + indice.toString(), pref)
+ TypeIncident result = TypeIncident.findByLibelleAndPreferencesEtablissement(
+ PREFIXE_TYPE_INCIDENT_TEST + indice.toString(), pref)
+
if (!result) {
result = absencesTypeIncidentService.creeTypeIncident(
- securiteSession,
pref,
PREFIXE_TYPE_INCIDENT_TEST + indice.toString()
)
return result
}
- LieuIncident getLieuIncident1(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- getLieuIncidentForIndice(securiteSession, pref, 1)
+ LieuIncident getLieuIncident1(PreferencesEtablissementAbsences pref) {
+
+ getLieuIncidentForIndice(pref, 1)
}
- private getLieuIncidentForIndice(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
+ private getLieuIncidentForIndice(PreferencesEtablissementAbsences pref,
Integer indice) {
LieuIncident result = LieuIncident.findByLibelleAndPreferencesEtablissement(
PREFIXE_LIEU_TEST + indice.toString(),
)
if (!result) {
result = lieuIncidentService.creeLieuIncident(
- securiteSession,
pref,
PREFIXE_LIEU_TEST + indice.toString()
)
return result
}
- private QualiteProtagoniste getQualiteProtagonisteForIndice(
- SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- Integer indice) {
+ QualiteProtagoniste getQualiteProtagonisteForIndice(PreferencesEtablissementAbsences pref,
+ Integer indice) {
QualiteProtagoniste result = QualiteProtagoniste.
findByLibelleAndPreferencesEtablissement(
PREFIXE_QUALITE_TEST + indice.toString(),
)
if (!result) {
result = qualiteProtagonisteService.creeQualiteProtagoniste(
- securiteSession,
pref,
PREFIXE_QUALITE_TEST + indice.toString()
)
return result
}
- QualiteProtagoniste getQualiteProtagoniste1(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- getQualiteProtagonisteForIndice(securiteSession, pref, 1)
+ QualiteProtagoniste getQualiteProtagoniste1(PreferencesEtablissementAbsences pref) {
+ getQualiteProtagonisteForIndice(pref, 1)
}
- QualiteProtagoniste getQualiteProtagoniste2(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- getQualiteProtagonisteForIndice(securiteSession, pref, 2)
+ QualiteProtagoniste getQualiteProtagoniste2(PreferencesEtablissementAbsences pref) {
+ getQualiteProtagonisteForIndice(pref, 2)
}
- QualiteProtagoniste getQualiteProtagoniste3(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- getQualiteProtagonisteForIndice(securiteSession, pref, 3)
+ QualiteProtagoniste getQualiteProtagoniste3(PreferencesEtablissementAbsences pref) {
+ getQualiteProtagonisteForIndice(pref, 3)
}
- private PartenaireAPrevenir getPartenaireAPrevenirForIndice(
- SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
- Integer indice) {
+ PartenaireAPrevenir getPartenaireAPrevenirForIndice(PreferencesEtablissementAbsences pref,
+ Integer indice) {
PartenaireAPrevenir result = PartenaireAPrevenir.
findByLibelleAndPreferencesEtablissement(
PREFIXE_PARTENAIRE_TEST + indice.toString(),
)
if (!result) {
result = partenaireAPrevenirService.creePartenaireAPrevenir(
- securiteSession,
pref,
PREFIXE_PARTENAIRE_TEST + indice.toString()
)
return result
}
- PartenaireAPrevenir getPartenaireAPrevenir1(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getPartenaireAPrevenirForIndice(securiteSession, pref, 1)
+ PartenaireAPrevenir getPartenaireAPrevenir1(PreferencesEtablissementAbsences pref) {
+ return getPartenaireAPrevenirForIndice(pref, 1)
}
- PartenaireAPrevenir getPartenaireAPrevenir2(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getPartenaireAPrevenirForIndice(securiteSession, pref, 2)
+ PartenaireAPrevenir getPartenaireAPrevenir2(PreferencesEtablissementAbsences pref) {
+ return getPartenaireAPrevenirForIndice(pref, 2)
}
- PartenaireAPrevenir getPartenaireAPrevenir3(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getPartenaireAPrevenirForIndice(securiteSession, pref, 3)
+ PartenaireAPrevenir getPartenaireAPrevenir3(PreferencesEtablissementAbsences pref) {
+ return getPartenaireAPrevenirForIndice(pref, 3)
}
- PartenaireAPrevenir getPartenaireAPrevenir4(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getPartenaireAPrevenirForIndice(securiteSession, pref, 4)
+ PartenaireAPrevenir getPartenaireAPrevenir4(PreferencesEtablissementAbsences pref) {
+ return getPartenaireAPrevenirForIndice(pref, 4)
}
/**
* @return une Sanction
*/
Sanction getSanction1_eleve1_classe1() {
- SecuriteSession securiteSessionDirecteur = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
operateurSaisie: getAutorite(PopulationTestActeur.DIRECTION_1),
date: Date.parse('dd/MM/yyyy', '15/09/2010'),
typeSanction: getTypeSanction1(
- securiteSessionDirecteur,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
effectue: false,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- params
- )
+
+ return absencesSanctionService.creeSanction(params)
}
/**
* @return une Sanction
*/
Sanction getSanction2_eleve1_classe1() {
- SecuriteSession securiteSessionDirecteur = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
operateurSaisie: getAutorite(PopulationTestActeur.DIRECTION_1),
date: Date.parse('dd/MM/yyyy', '10/10/2010'),
typeSanction: getTypeSanction2(
- securiteSessionDirecteur,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
effectue: false,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- params
- )
+
+ return absencesSanctionService.creeSanction(params)
}
/**
* @return une Sanction
*/
Sanction getSanction1_eleve2_classe1() {
- SecuriteSession securiteSessionDirecteur = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
operateurSaisie: getAutorite(PopulationTestActeur.DIRECTION_1),
date: Date.parse('dd/MM/yyyy', '20/09/2010'),
typeSanction: getTypeSanction2(
- securiteSessionDirecteur,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
effectue: false,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- params
- )
+
+ return absencesSanctionService.creeSanction(params)
}
/**
* @return une Sanction
*/
Sanction getSanction1_eleve1_classe1_2() {
- SecuriteSession securiteSessionDirecteur = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
operateurSaisie: getAutorite(PopulationTestActeur.DIRECTION_1),
date: Date.parse('dd/MM/yyyy', '15/09/2010'),
typeSanction: getTypeSanction1(
- securiteSessionDirecteur,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
effectue: false,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- params
- )
+
+ return absencesSanctionService.creeSanction(params)
}
- TypeSanction getTypeSanction2(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getTypeSanctionForIndice(securiteSession, pref, 1)
+ TypeSanction getTypeSanction2(PreferencesEtablissementAbsences pref) {
+ return getTypeSanctionForIndice(pref, 1)
}
- TypeSanction getTypeSanction1(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getTypeSanctionForIndice(securiteSession, pref, 1)
+ TypeSanction getTypeSanction1(PreferencesEtablissementAbsences pref) {
+ return getTypeSanctionForIndice(pref, 1)
}
- private TypeSanction getTypeSanctionForIndice(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
+ TypeSanction getTypeSanctionForIndice(PreferencesEtablissementAbsences pref,
Integer indice) {
+
TypeSanction result = TypeSanction.findByLibelleAndPreferencesEtablissement(
PREFIXE_TYPE_SANCTION_TEST + indice.toString(), pref
)
+
if (!result) {
result = absencesTypeSanctionService.creeTypeSanction(
- securiteSession,
pref,
PREFIXE_TYPE_SANCTION_TEST + indice.toString()
)
return result
}
- TypePunition getTypePunition1(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getTypePunitionForIndice(securiteSession, pref, 1)
+ TypePunition getTypePunition1(PreferencesEtablissementAbsences pref) {
+ return getTypePunitionForIndice(pref, 1)
}
- TypePunition getTypePunition2(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref) {
- return getTypePunitionForIndice(securiteSession, pref, 2)
+ TypePunition getTypePunition2(PreferencesEtablissementAbsences pref) {
+ return getTypePunitionForIndice(pref, 2)
}
- private TypePunition getTypePunitionForIndice(SecuriteSession securiteSession,
- PreferencesEtablissementAbsences pref,
+ private TypePunition getTypePunitionForIndice(PreferencesEtablissementAbsences pref,
Integer indice) {
TypePunition result = TypePunition.findByLibelleAndPreferencesEtablissement(
PREFIXE_TYPE_PUNITION_TEST + indice.toString(), pref
)
if (!result) {
result = absencesTypePunitionService.creeTypePunition(
- securiteSession,
pref,
PREFIXE_TYPE_PUNITION_TEST + indice.toString()
)
* @return une Punition
*/
Punition getPunition1_eleve1_classe1() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
PunitionParams params = new PunitionParams(
date: Date.parse('dd/MM/yyyy', '10/09/2010'),
type: getTypePunition1(
- securiteSession,
initDonneesCommunesTestPreferencesAbsencesService.
getPrefEtab1()
),
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesPunitionService.creePunition(securiteSession, params)
+ return absencesPunitionService.creePunition(params)
}
/**
* @return une Punition
*/
Punition getPunition1_eleve2_classe1() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
PunitionParams params = new PunitionParams(
date: Date.parse('dd/MM/yyyy', '20/09/2010'),
type: getTypePunition2(
- securiteSession,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
isPunitionEffectuee: true,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesPunitionService.creePunition(securiteSession, params)
+ return absencesPunitionService.creePunition(params)
}
/**
* @return une Punition
*/
Punition getPunition2_eleve1_classe1() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
PunitionParams params = new PunitionParams(
date: Date.parse('dd/MM/yyyy', '05/10/2010'),
type: getTypePunition2(
- securiteSession,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
isPunitionEffectuee: true,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesPunitionService.creePunition(securiteSession, params)
+ return absencesPunitionService.creePunition(params)
}
/**
* @return une Punition
*/
Punition getPunition1_eleve1_classe2() {
- SecuriteSession securiteSession = getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
Etablissement etablissement = getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
PunitionParams params = new PunitionParams(
date: Date.parse('dd/MM/yyyy', '10/09/2010'),
type: getTypePunition1(
- securiteSession,
initDonneesCommunesTestPreferencesAbsencesService.getPrefEtab1()
),
isPunitionEffectuee: true,
preferences: preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesPunitionService.creePunition(securiteSession, params)
+ return absencesPunitionService.creePunition(params)
}
}
samedi: true,
dimanche: false
)
+
plageHoraire1.save(flush: true)
+
+ pref.addToPlageHoraires(plageHoraire1)
+
return plageHoraire1
}
import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeLigneParams
import org.lilie.services.eliot.test.InitDonneesCommunesTestAbsenceService
import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeLigneInfo
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.test.InitDonneesCommunesTestPreferencesAbsencesService
import org.lilie.services.eliot.absences.saisie.discipline.sanction.AbsencesSanctionService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
etablissement = initDonneesCommunesTestAbsenceService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
+
PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
+
typeSanction = absencesTypeSanctionService.creeTypeSanction(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
pref,
'test--typeSanction de test'
)
Boolean exceptionLevee = false
try {
absenceJourneeService.
- internalCreeAbsencesForSanction(
+ creeAbsencesForSanction(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.DIRECTION_1
),
exceptionLevee = false
try {
absenceJourneeService.
- internalCreeAbsencesForSanction(
+ creeAbsencesForSanction(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.DIRECTION_1
),
sanction.motif = motif1
absenceJourneeService.
- internalCreeAbsencesForSanction(
+ creeAbsencesForSanction(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.DIRECTION_1
),
sanction.debutAbsence = Date.parse('dd/MM/yyyy', '01/09/2010')
sanction.finAbsence = Date.parse('dd/MM/yyyy hh:mm:ss:SSS', '10/09/2010 23:59:59:999')
absenceJourneeService.
- internalCreeAbsencesForSanction(
+ creeAbsencesForSanction(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.DIRECTION_1
),
sanction.debutAbsence = Date.parse('dd/MM/yyyy', '01/09/2010')
sanction.finAbsence = Date.parse('dd/MM/yyyy hh:mm:ss:SSS', '10/09/2010 23:59:59:999')
absenceJourneeService.
- internalCreeAbsencesForSanction(
+ creeAbsencesForSanction(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.DIRECTION_1
),
PopulationTestEtablissement.ETABLISSEMENT_1
)
Sanction sanction = absencesSanctionService.creeSanction(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
new SanctionParams(
etablissement: etablissement,
date: new Date(),
}
void testEnregistreAbsenceJournee() {
- SecuriteSession securiteSessionDirection1 =
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
//Teste l'ajout d'une absence
AbsenceJourneeParams params = creeAbsenceJourneeParams()
- params.lignes.add(
- creeAbsenceJourneeLigneParams()
- )
- List<AbsenceJourneeLigneInfo> ligneInfos = absenceJourneeService.enregistreAbsenceJournee(
- securiteSessionDirection1,
- params
- )
+ params.lignes.add(creeAbsenceJourneeLigneParams())
+
+ List<AbsenceJourneeLigneInfo> ligneInfos = absenceJourneeService.enregistreAbsenceJournee(params)
+
assertNotNull("L'appel à la méthode n'a rien retourné.", ligneInfos)
assertEquals("La méthode doit retourner une ligne", 1, ligneInfos.size())
AbsenceJourneeLigneInfo ligne = ligneInfos[0]
AbsenceJourneeParams paramModif = creeAbsenceJourneeParams()
AbsenceJourneeLigneParams ligneModifiee = creeAbsenceJourneeLigneParams()
ligneModifiee.appelLigne = ligne.appelLigne
- ligneModifiee.motif = initDonneesCommunesTestPreferencesAbsencesService.
- getMotif2()
+ ligneModifiee.motif = initDonneesCommunesTestPreferencesAbsencesService.getMotif2()
paramModif.lignes.add(ligneModifiee)
- List<AbsenceJourneeLigneInfo> ligneInfosModif = absenceJourneeService.
- enregistreAbsenceJournee(
- securiteSessionDirection1,
- paramModif
- )
+
+ List<AbsenceJourneeLigneInfo> ligneInfosModif =
+ absenceJourneeService.enregistreAbsenceJournee(paramModif)
+
assertEquals(
"La modification ne retourne pas de ligne",
0,
ligneSupprimee.appelLigne = ligne.appelLigne
ligneSupprimee.aSupprimer = true
paramSuppr.lignes.add(ligneSupprimee)
- absenceJourneeService.enregistreAbsenceJournee(
- securiteSessionDirection1,
- paramSuppr
- )
+
+ absenceJourneeService.enregistreAbsenceJournee(paramSuppr)
+
assertNull(
"La ligne d'absence doit avoir été supprimée",
AppelLigne.get(appelLigneId)
)
//Teste l'enregistrement "à vide"
- absenceJourneeService.enregistreAbsenceJournee(
- securiteSessionDirection1,
- creeAbsenceJourneeParams()
- )
-
- //Teste la vérification des droits
- Boolean exceptionLevee = false
- try {
- absenceJourneeService.enregistreAbsenceJournee(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- ),
- creeAbsenceJourneeParams()
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Une l'enregistrement par un enseignant doit lever une exception",
- exceptionLevee
- )
+ absenceJourneeService.enregistreAbsenceJournee(creeAbsenceJourneeParams())
}
private AbsenceJourneeLigneParams creeAbsenceJourneeLigneParams() {
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.absences.saisie.discipline.incident.IncidentParams
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
import org.lilie.services.eliot.absences.saisie.discipline.incident.ProtagonisteIncidentParams
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
import org.lilie.services.eliot.absences.saisie.discipline.incident.PartenaireAPrevenirIncidentParams
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.PartenaireAPrevenirService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.saisie.discipline.incident.exceptions.IncidentChampsObligatoiresException
import org.lilie.services.eliot.absences.saisie.discipline.incident.GrilleIncidentsForEleveInfo
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.test.InitDonneesCommunesTestDisciplineService
import org.lilie.services.eliot.absences.saisie.discipline.sanction.SanctionParams
-
import org.lilie.services.eliot.absences.saisie.discipline.punition.PunitionParams
-
import org.lilie.services.eliot.parametrages.motifs.GroupeMotifService
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.DisciplineCriteresRecherche
import org.lilie.services.eliot.applications.absences.IncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypePunitionService
-import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
+import org.lilie.services.eliot.absences.saisie.discipline.incident.exceptions.IncidentProtagonistesObligatoiresException
class AbsencesIncidentServiceTests extends GrailsUnitTestCase {
InitDonneesCommunesTestAbsenceService initDonneesCommunesTestAbsenceService
InitDonneesCommunesTestDisciplineService initDonneesCommunesTestDisciplineService
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
- AbsencesTypeIncidentService absencesTypeIncidentService
- LieuIncidentService lieuIncidentService
- QualiteProtagonisteService qualiteProtagonisteService
- PartenaireAPrevenirService partenaireAPrevenirService
AbsencesSanctionService absencesSanctionService
AbsencesPunitionService absencesPunitionService
AbsencesTypeSanctionService absencesTypeSanctionService
IncidentService incidentService
- SecuriteSession sessionDirecteur
- SecuriteSession sessionEnseignant
- SecuriteSession sessionDirecteur2
PreferencesEtablissementAbsences pref
Etablissement etablissement
TypeIncident typeIncident1
protected void setUp() {
super.setUp()
- sessionDirecteur = (SecuriteSession) initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
-
- sessionEnseignant = (SecuriteSession) initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
- sessionDirecteur2 = (SecuriteSession) initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_2
- )
etablissement = initDonneesCommunesTestAbsenceService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
+
pref = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
+ typeIncident1 = initDonneesCommunesTestDisciplineService.getTypeIncident1(pref)
+ typeIncident2 = initDonneesCommunesTestDisciplineService.getTypeIncident2(pref)
+ lieuIncident1 = initDonneesCommunesTestDisciplineService.getLieuIncident1(pref)
- typeIncident1 = initDonneesCommunesTestDisciplineService.getTypeIncident1(
- sessionDirecteur,
- pref
- )
+ lieuIncident2 = initDonneesCommunesTestDisciplineService.getLieuIncident1(pref)
- typeIncident2 = initDonneesCommunesTestDisciplineService.getTypeIncident2(
- sessionDirecteur,
- pref
- )
-
- lieuIncident1 = initDonneesCommunesTestDisciplineService.getLieuIncident1(
- sessionDirecteur,
- pref
- )
-
- lieuIncident2 = initDonneesCommunesTestDisciplineService.getLieuIncident1(
- sessionDirecteur,
- pref
- )
+ qualite1 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste1(pref)
+ qualite2 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste2(pref)
+ qualite3 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste3(pref)
-
- qualite1 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste1(
- sessionDirecteur,
- pref
- )
-
- qualite2 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste2(
- sessionDirecteur,
- pref
- )
-
- qualite3 = initDonneesCommunesTestDisciplineService.getQualiteProtagoniste3(
- sessionDirecteur,
- pref
- )
-
- partenaire1 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir1(
- sessionDirecteur,
- pref
- )
-
- partenaire2 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir2(
- sessionDirecteur,
- pref
- )
-
- partenaire3 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir3(
- sessionDirecteur,
- pref
- )
-
- partenaire4 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir4(
- sessionDirecteur,
- pref
- )
+ partenaire1 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir1(pref)
+ partenaire2 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir2(pref)
+ partenaire3 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir3(pref)
+ partenaire4 = initDonneesCommunesTestDisciplineService.getPartenaireAPrevenir4(pref)
directeur = initDonneesCommunesTestAbsenceService.getPersonne(
PopulationTestActeur.DIRECTION_1
)
//Création d'un incident simple
- Incident incident = absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams
- )
+ Incident incident = absencesIncidentService.creeIncident(incidentParams)
assertNotNull("L'incident n'a pas été créé", incident.id)
assertEquals(
incident.etablissement.id
)
- //Tentative de création par un enseignant
- Boolean exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionEnseignant,
- incidentParams
- )
- } catch (AutorisationException) {
- exceptionLevee = true
- }
- assertTrue("Un enseignant ne peut pas créer d'incident", exceptionLevee)
-
- //Tentative de création sur un autre établissement
- exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionDirecteur2,
- incidentParams
- )
- } catch (AutorisationException) {
- exceptionLevee = true
- }
- assertTrue(
- "Un directeur ne peut pas créer d'incident sur un autre établissement",
- exceptionLevee
- )
-
//Création d'un incident sans protagoniste
IncidentParams incidentParamsSansProtagoniste = new IncidentParams(
date: new Date(),
preferences: pref
)
- exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParamsSansProtagoniste
- )
- } catch (IncidentProtagonistesObligatoiresException) {
- exceptionLevee = true
- }
- assertTrue("On ne peut pas créer d'incident sans protagoniste", exceptionLevee)
-
//Création d'un incident sans protagoniste
IncidentParams incidentParamsDescriptionTropLongue = new IncidentParams(
date: new Date(),
etablissement: pref.etablissement,
preferences: pref
)
-
- exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParamsDescriptionTropLongue
- )
- } catch (IncidentDescriptionLongueException) {
- exceptionLevee = true
- }
- assertTrue(
- "On ne peut pas créer d'incident avec une description trop longue",
- exceptionLevee
- )
}
void testCoherenceProtagoniste() {
),
qualiteProtagoniste: qualite1
)
-
- Boolean exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams
- )
- } catch (Exception e) {
- exceptionLevee = true
- }
- assertTrue(
- "Le type de protagoniste doit être cohérent.",
- exceptionLevee
- )
}
void testDoublonsPartenaires() {
id: null,
partenaireAPrevenir: partenaire1
)
-
- Boolean exceptionLevee = false
- try {
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams
- )
- } catch (Exception e) {
- exceptionLevee = true
- }
- assertTrue(
- "On ne peut pas associer deux fois un partenaire à un incident",
- exceptionLevee
- )
}
void testModifieIncident() {
Incident incident = creeIncident()
+ IncidentParams incidentParams = copieIncidentDansParams(incident)
- IncidentParams incidentParamsAModifier1 = copieIncidentDansParams(incident)
Date nouvelleDate = new Date() + 1
String nouvelleDescription = 'Nouvelle description'
- incidentParamsAModifier1.date = nouvelleDate
- incidentParamsAModifier1.description = nouvelleDescription
+ incidentParams.date = nouvelleDate
+ incidentParams.description = nouvelleDescription
- Incident incidentModifie1 = absencesIncidentService.modifieIncident(
- sessionDirecteur,
+ incident = absencesIncidentService.modifieIncident(
incident,
- incidentParamsAModifier1
+ incidentParams
)
assertEquals(
"La date de l'incident n'a pas été modifiée",
nouvelleDate,
- incidentModifie1.date
+ incident.date
)
assertEquals(
"La description de l'incident n'a pas été modifiée",
nouvelleDescription,
- incidentModifie1.description
+ incident.description
)
assertEquals(
"Le nombre de protagonistes a été modifié à tort",
- incidentParamsAModifier1.protagonistesParams.size(),
- incidentModifie1.protagonistes.size()
- )
-
- IncidentParams incidentParamsAModifier2 = copieIncidentDansParams(incidentModifie1)
- incidentParamsAModifier2.protagonistesParams[0].aSupprimer = true
- Incident incidentModifie2 = absencesIncidentService.modifieIncident(
- sessionDirecteur,
- incidentModifie1,
- incidentParamsAModifier2
- )
- assertEquals(
- "Le protagoniste n'a pas été supprimé",
- incidentParamsAModifier2.protagonistesParams.size() - 1,
- incidentModifie2.protagonistes.size()
+ incidentParams.protagonistesParams.size(),
+ incident.protagonistes.size()
)
- IncidentParams incidentParamsAModifier3 = copieIncidentDansParams(incidentModifie2)
- incidentParamsAModifier3.protagonistesParams << new ProtagonisteIncidentParams(
+ incident = creeIncident()
+ incidentParams = copieIncidentDansParams(incident)
+ incidentParams.protagonistesParams << new ProtagonisteIncidentParams(
id: null,
type: TypeProtagonisteIncident.ELEVE,
autorite: initDonneesCommunesTestAbsenceService.getAutorite(
),
qualiteProtagoniste: qualite1
)
- Incident incidentModifie3 = absencesIncidentService.modifieIncident(
- sessionDirecteur,
- incidentModifie2,
- incidentParamsAModifier3
+
+ incident = absencesIncidentService.modifieIncident(
+ incident,
+ incidentParams
)
+
assertEquals(
"Le protagoniste n'a pas été ajouté",
- incidentParamsAModifier3.protagonistesParams.size(),
- incidentModifie3.protagonistes.size()
+ incidentParams.protagonistesParams.size(),
+ incident.protagonistes.size()
)
- Incident incidentModifie4 = null
- IncidentParams incidentParamsAModifier4 = copieIncidentDansParams(incidentModifie3)
- Boolean exceptionLevee = false
- try {
- incidentModifie4 = absencesIncidentService.modifieIncident(
- sessionEnseignant,
- incidentModifie3,
- incidentParamsAModifier4
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un enseignant n'a pas le droit de modifier un incident",
- exceptionLevee
+ incident = creeIncident()
+ incidentParams = copieIncidentDansParams(incident)
+
+ incidentParams.protagonistesParams[0].aSupprimer = true
+ incident = absencesIncidentService.modifieIncident(
+ incident,
+ incidentParams
)
- IncidentParams incidentParamsAModifier5 = copieIncidentDansParams(incidentModifie3)
- incidentParamsAModifier5.protagonistesParams.clear()
- exceptionLevee = false
+ assertEquals(
+ "Le protagoniste n'a pas été supprimé",
+ incidentParams.protagonistesParams.size() - 1,
+ incident.protagonistes.size()
+ )
+
+
+ incident = creeIncident()
+ incidentParams = copieIncidentDansParams(incident)
+ incidentParams.date = null
+ Boolean exceptionLevee = false
+
try {
absencesIncidentService.modifieIncident(
- sessionDirecteur,
- incidentModifie4,
- incidentParamsAModifier5
+ incident,
+ incidentParams
)
- } catch (IncidentProtagonistesObligatoiresException) {
+ } catch (IncidentChampsObligatoiresException e) {
exceptionLevee = true
}
assertTrue(
- "On ne peut pas supprimer tous les protagonistes d'un incident",
+ "On ne peut pas enregistrer un incident sans date",
exceptionLevee
)
- IncidentParams incidentParamsAModifier6 = copieIncidentDansParams(incidentModifie3)
- incidentParamsAModifier6.date = null
- exceptionLevee = false
+ incident = creeIncident()
+ incidentParams = copieIncidentDansParams(incident)
+ incidentParams.protagonistesParams*.aSupprimer = true
+ exceptionLevee = false
try {
absencesIncidentService.modifieIncident(
- sessionDirecteur,
- incidentModifie3,
- incidentParamsAModifier6
+ incident,
+ incidentParams
)
- } catch (IncidentChampsObligatoiresException e) {
+ } catch (IncidentProtagonistesObligatoiresException e) {
exceptionLevee = true
}
assertTrue(
- "On ne peut pas enregistrer un incident sans date",
+ "On ne peut pas supprimer tous les protagonistes d'un incident",
exceptionLevee
)
+
}
void testModifiePartenairesIncident() {
partenaireAPrevenir: partenaire4
)
Incident incidentModifie = absencesIncidentService.modifieIncident(
- sessionDirecteur,
incident,
incidentParams
)
IncidentParams incidentParams2 = copieIncidentDansParams(incidentModifie)
incidentParams2.partenairesParams.clear()
Incident incidentModifie2 = absencesIncidentService.modifieIncident(
- sessionDirecteur,
incidentModifie,
incidentParams2
)
AppelLigne absence = AppelLigne.findBySanction(sanction)
Long absenceId = absence.id
-
- absencesIncidentService.supprimeIncident(sessionDirecteur, incident)
+ absencesIncidentService.supprimeIncident(incident)
assertNull("Incident n'est pas supprime", Incident.findById(incidentId))
assertNull("Sanction n'est pas supprimee", Sanction.findById(sanctionId))
assertNull("Absence liee n'est pas supprimee", AppelLigne.findById(absenceId))
assertNull("Punition n'est pas supprimee", Punition.findById(punitionId))
-
}
void testFindIncidents() {
creeListeIncidents()
absencesIncidentService.findIncidents(
- sessionDirecteur,
+ initDonneesCommunesTestAbsenceService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
directeur,
pref.etablissement,
'gravite',
0,
10
)
-
}
+
/**
* Crée plusieurs incidents dans la base
*/
qualiteProtagoniste: qualite3
)
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams1
- )
-
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams2
- )
-
- absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams3
- )
+ absencesIncidentService.creeIncident(incidentParams1)
+ absencesIncidentService.creeIncident(incidentParams2)
+ absencesIncidentService.creeIncident(incidentParams3)
}
void testFindIncidentByEleve() {
partenaireAPrevenir: partenaire3
)
- Incident incident = absencesIncidentService.creeIncident(
- sessionDirecteur,
- incidentParams
- )
+ Incident incident = absencesIncidentService.creeIncident(incidentParams)
+
return incident
}
id: protagonisteIncident.id,
type: protagonisteIncident.type,
autorite: protagonisteIncident.autorite,
- qualiteProtagoniste: protagonisteIncident.qualite
+ qualiteProtagoniste: protagonisteIncident.qualite,
+ aSupprimer: false
)
}
private Sanction creeSanction(Incident incident) {
TypeSanction typeSanction = absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
pref,
'Test-Sanction-Type1'
)
preferences: incident.preferencesEtablissementAbsences
)
- return absencesSanctionService.creeSanction(
- sessionDirecteur,
- sanctionParams
- )
+ return absencesSanctionService.creeSanction(sanctionParams)
}
private Punition creePunition(Incident incident) {
TypePunition typePunition1 = absencesTypePunitionService.creeTypePunition(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
pref,
'test--type punition 1'
)
getPreferencesEtablissementForEtablissement(etablissement)
)
- return absencesPunitionService.creePunition(
- sessionDirecteur,
- punitionParams
- )
+ return absencesPunitionService.creePunition(punitionParams)
}
private Motif creeMotif() {
incidentService.findIncidentsForCriteres(disciplineCriteresRecherche)
assertTrue('Un incident devrait être trouvée', allIncident.size() == 1)
-
}
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
import org.lilie.services.eliot.absences.saisie.discipline.punition.AbsencesPunitionService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.saisie.discipline.punition.exceptions.PunitionDescriptionLongueException
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Calendrier
import org.lilie.services.eliot.absences.saisie.discipline.punition.exceptions.PunitionException
TypeIncident typeIncident1
LieuIncident lieuIncident1
QualiteProtagoniste qualiteProtagoniste1
- SecuriteSession securiteSessionDirecteur
- SecuriteSession securiteSessionDirecteur2
- SecuriteSession securiteSessionEleve
- SecuriteSession securiteSessionEnseignant
protected void setUp() {
super.setUp()
etablissement = initDonneesCommunesTestAbsenceService.
- getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
+ getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
+
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
+
calendrier = calendrierService.
- getCalendrierForEtablissement(etablissement)
+ getCalendrierForEtablissement(etablissement)
+
datePunition = calendrier.premierJour
+
typePunition1 = absencesTypePunitionService.creeTypePunition(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
- pref,
- 'test--type punition 1'
+ pref,
+ 'test--type punition 1'
)
+
typePunition2 = absencesTypePunitionService.creeTypePunition(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
- pref,
- 'test--type punition 2'
- )
- securiteSessionDirecteur = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- securiteSessionDirecteur2 = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_2
- )
- securiteSessionEleve = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ELEVE_1_CLASSE_1
- )
- securiteSessionEnseignant = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
+ pref,
+ 'test--type punition 2'
)
+
typePunition3 = absencesTypePunitionService.creeTypePunition(
- securiteSessionDirecteur,
- pref,
- 'test--type punition 3'
+ pref,
+ 'test--type punition 3'
)
autoriteEleve1 = initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.ELEVE_1_CLASSE_1
+ PopulationTestActeur.ELEVE_1_CLASSE_1
)
autoriteEleve2 = initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.ELEVE_1_CLASSE_2
+ PopulationTestActeur.ELEVE_1_CLASSE_2
)
autoriteEleve3 = initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.ELEVE_2_CLASSE_1
+ PopulationTestActeur.ELEVE_2_CLASSE_1
)
autoriteCenseur1 = initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.DIRECTION_1
+ PopulationTestActeur.DIRECTION_1
)
autoriteCenseur2 = initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.EDUCATION_1
+ PopulationTestActeur.EDUCATION_1
)
personneEleve1 = initDonneesCommunesTestAbsenceService.getPersonne(
- PopulationTestActeur.ELEVE_1_CLASSE_1
+ PopulationTestActeur.ELEVE_1_CLASSE_1
)
personneCenseur1 = initDonneesCommunesTestAbsenceService.getPersonne(
- PopulationTestActeur.DIRECTION_1
+ PopulationTestActeur.DIRECTION_1
)
typeIncident1 = absencesTypeIncidentService.creeTypeIncident(
- securiteSessionDirecteur,
- pref,
- 'test--type incident 1'
+ pref,
+ 'test--type incident 1'
)
lieuIncident1 = lieuIncidentService.creeLieuIncident(
- securiteSessionDirecteur,
- pref,
- 'test--lieu incident 1'
+ pref,
+ 'test--lieu incident 1'
)
qualiteProtagoniste1 = qualiteProtagonisteService.creeQualiteProtagoniste(
- securiteSessionDirecteur,
- pref,
- 'test--qualite protagoniste 1'
+ pref,
+ 'test--qualite protagoniste 1'
)
IncidentParams incidentParams = new IncidentParams(
- date: new Date(),
- gravite: GraviteIncident.NIVEAU_3,
- type: typeIncident1,
- lieu: lieuIncident1,
- description: 'test--description de test',
- etablissement: pref.etablissement,
- preferences: pref
+ date: new Date(),
+ gravite: GraviteIncident.NIVEAU_3,
+ type: typeIncident1,
+ lieu: lieuIncident1,
+ description: 'test--description de test',
+ etablissement: pref.etablissement,
+ preferences: pref
)
incidentParams.protagonistesParams << new ProtagonisteIncidentParams(
- id: null,
- type: TypeProtagonisteIncident.ELEVE,
- autorite: initDonneesCommunesTestAbsenceService.getAutorite(
- PopulationTestActeur.ELEVE_2_CLASSE_1
- ),
- qualiteProtagoniste: qualiteProtagoniste1
+ id: null,
+ type: TypeProtagonisteIncident.ELEVE,
+ autorite: initDonneesCommunesTestAbsenceService.getAutorite(
+ PopulationTestActeur.ELEVE_2_CLASSE_1
+ ),
+ qualiteProtagoniste: qualiteProtagoniste1
)
- incident = absencesIncidentService.creeIncident(
- securiteSessionDirecteur,
- incidentParams
- )
+ incident = absencesIncidentService.creeIncident(incidentParams)
}
protected void tearDown() {
void testCreePunition() {
PunitionParams punitionParams = new PunitionParams(
- date: datePunition,
- type: typePunition1,
- isPunitionEffectuee: false,
- eleve: personneEleve1,
- censeur: personneCenseur1,
- description: 'test--description punition 1',
- incident: incident,
- etablissement: etablissement,
- preferences: pref
- )
-
- Boolean exceptionLevee = false
- try {
- absencesPunitionService.creePunition(
- securiteSessionEleve,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("Un élève ne doit pas pouvoir créer de punition", exceptionLevee)
-
- exceptionLevee = false
- try {
- absencesPunitionService.creePunition(
- securiteSessionEnseignant,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("Un enseignant ne doit pas pouvoir créer de punition", exceptionLevee)
-
- exceptionLevee = false
- try {
- absencesPunitionService.creePunition(
- securiteSessionDirecteur2,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un directeur ne peut pas créer de punition sur un autre étab.",
- exceptionLevee
+ date: datePunition,
+ type: typePunition1,
+ isPunitionEffectuee: false,
+ eleve: personneEleve1,
+ censeur: personneCenseur1,
+ description: 'test--description punition 1',
+ incident: incident,
+ etablissement: etablissement,
+ preferences: pref
)
- Punition punition3 = absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
- )
+ Punition punition3 = absencesPunitionService.creePunition(punitionParams)
assertNotNull("La punition n'a pas été créée", punition3)
assertNotNull("La punition n'a pas d'id", punition3.id)
assertEquals(
- "La date a été modifiée à l'enregistrement",
- punitionParams.date,
- punition3.date
+ "La date a été modifiée à l'enregistrement",
+ punitionParams.date,
+ punition3.date
)
assertEquals(
- "Le type de punition a été modifié à l'enregistrement",
- punitionParams.type,
- punition3.typePunition
+ "Le type de punition a été modifié à l'enregistrement",
+ punitionParams.type,
+ punition3.typePunition
)
assertEquals(
- "Le statut a été modifié à l'enregistrement",
- punitionParams.isPunitionEffectuee,
- punition3.effectue
+ "Le statut a été modifié à l'enregistrement",
+ punitionParams.isPunitionEffectuee,
+ punition3.effectue
)
assertEquals(
- "L'élève a été modifié à l'enregistrement",
- punitionParams.eleve,
- punition3.eleve
+ "L'élève a été modifié à l'enregistrement",
+ punitionParams.eleve,
+ punition3.eleve
)
assertEquals(
- "Le censeur a été modifié à l'enregistrement",
- punitionParams.censeur,
- punition3.censeur
+ "Le censeur a été modifié à l'enregistrement",
+ punitionParams.censeur,
+ punition3.censeur
)
assertEquals(
- "La description a été modifiée à l'enregistrement",
- punitionParams.description,
- punition3.description
+ "La description a été modifiée à l'enregistrement",
+ punitionParams.description,
+ punition3.description
)
assertEquals(
- "L'incident a été modifié à l'enregistrement",
- punitionParams.incident,
- punition3.incident
+ "L'incident a été modifié à l'enregistrement",
+ punitionParams.incident,
+ punition3.incident
)
assertEquals(
- "L'établissement a été modifié à l'enregistrement",
- punitionParams.etablissement,
- punition3.etablissement
+ "L'établissement a été modifié à l'enregistrement",
+ punitionParams.etablissement,
+ punition3.etablissement
)
punitionParams.description = """
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
"""
- exceptionLevee = false
+ Boolean exceptionLevee = false
try {
- absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
- )
+ absencesPunitionService.creePunition(punitionParams)
} catch (PunitionDescriptionLongueException e) {
exceptionLevee = true
}
assertTrue(
- "La description de la punition ne doit pas dépasser 300 caractères",
- exceptionLevee
+ "La description de la punition ne doit pas dépasser 300 caractères",
+ exceptionLevee
)
punitionParams.description = "Description de test"
punitionParams.date = null
exceptionLevee = false
try {
- absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
- )
+ absencesPunitionService.creePunition(punitionParams)
} catch (PunitionException e) {
exceptionLevee = true
}
assertTrue(
- "La date est obligatoire",
- exceptionLevee
+ "La date est obligatoire",
+ exceptionLevee
)
}
Boolean exceptionLevee
String newLibelle = 'Nouvelle description'
PunitionParams punitionParams = new PunitionParams(
- date: datePunition,
- type: typePunition1,
- isPunitionEffectuee: false,
- eleve: personneEleve1,
- censeur: personneCenseur1,
- description: 'test--description punition 2',
- incident: incident,
- etablissement: etablissement,
- preferences: pref
- )
- Punition punition = absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
+ date: datePunition,
+ type: typePunition1,
+ isPunitionEffectuee: false,
+ eleve: personneEleve1,
+ censeur: personneCenseur1,
+ description: 'test--description punition 2',
+ incident: incident,
+ etablissement: etablissement,
+ preferences: pref
)
- punitionParams.description = newLibelle
-
- exceptionLevee = false
- try {
- absencesPunitionService.modifiePunition(
- securiteSessionEnseignant,
- punition,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("Un enseignant de peut pas modifier de punition.", exceptionLevee)
- exceptionLevee = false
- try {
- absencesPunitionService.modifiePunition(
- securiteSessionDirecteur2,
- punition,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un directeur de peut pas modifier de punition sur un autre étab.",
- exceptionLevee
- )
+ Punition punition = absencesPunitionService.creePunition(punitionParams)
- exceptionLevee = false
- try {
- absencesPunitionService.modifiePunition(
- securiteSessionEleve,
- punition,
- punitionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("Un élève de peut pas modifier de punition.", exceptionLevee)
+ punitionParams.description = newLibelle
Punition punitionModifiee = absencesPunitionService.modifiePunition(
- securiteSessionDirecteur,
- punition,
- punitionParams
+ punition,
+ punitionParams
)
+
assertNotNull("La punition n'a pas été modifiée", punitionModifiee)
assertEquals(
- "L'id de la punition a été modifié",
- punition.id,
- punitionModifiee.id
+ "L'id de la punition a été modifié",
+ punition.id,
+ punitionModifiee.id
)
assertEquals(
- "La description n'a pas été modifiée",
- newLibelle,
- punitionModifiee.description
+ "La description n'a pas été modifiée",
+ newLibelle,
+ punitionModifiee.description
)
}
Boolean exceptionLevee
PunitionParams punitionParams = new PunitionParams(
- date: datePunition,
- type: typePunition1,
- isPunitionEffectuee: false,
- eleve: personneEleve1,
- censeur: personneCenseur1,
- description: 'test--description punition 1',
- incident: incident,
- etablissement: etablissement,
- preferences: pref
- )
-
- Punition punitionASupprimer = absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
- )
-
- exceptionLevee = false
- try{
- absencesPunitionService.supprimePunition(securiteSessionEleve, punitionASupprimer)
- } catch(AutorisationException e){
- exceptionLevee = true
- }
- assertTrue(
- "Un élève ne doit pas pouvoir supprimer une punition.",
- exceptionLevee
- )
-
- exceptionLevee = false
- try{
- absencesPunitionService.supprimePunition(securiteSessionDirecteur2, punitionASupprimer)
- } catch(AutorisationException e){
- exceptionLevee = true
- }
- assertTrue(
- "Un directeur ne peut pas supprimer une punition sur un autre étab.",
- exceptionLevee
+ date: datePunition,
+ type: typePunition1,
+ isPunitionEffectuee: false,
+ eleve: personneEleve1,
+ censeur: personneCenseur1,
+ description: 'test--description punition 1',
+ incident: incident,
+ etablissement: etablissement,
+ preferences: pref
)
- exceptionLevee = false
- try{
- absencesPunitionService.supprimePunition(
- securiteSessionEnseignant,
- punitionASupprimer
- )
- } catch(AutorisationException e){
- exceptionLevee = true
- }
- assertTrue(
- "Un enseignant ne doit pas pouvoir supprimer une punition.",
- exceptionLevee
- )
+ Punition punitionASupprimer = absencesPunitionService.creePunition(punitionParams)
Long idPunitionSupprimee = punitionASupprimer.id
- absencesPunitionService.supprimePunition(
- securiteSessionDirecteur,
- punitionASupprimer
- )
+ absencesPunitionService.supprimePunition(punitionASupprimer)
+
assertNull(
- "La punition n'a pas été supprimée",
- Punition.get(idPunitionSupprimee)
+ "La punition n'a pas été supprimée",
+ Punition.get(idPunitionSupprimee)
)
}
preferences: pref
)
- Punition punition = absencesPunitionService.creePunition(
- securiteSessionDirecteur,
- punitionParams
- )
+ absencesPunitionService.creePunition(punitionParams)
DisciplineCriteresRecherche disciplineCriteresRecherche =
new DisciplineCriteresRecherche(
package org.lilie.services.eliot.absences
import org.lilie.services.eliot.scolarite.Etablissement
-
import org.lilie.services.eliot.test.InitDonneesCommunesTestAbsenceService
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.test.PopulationTestActeur
-
import org.lilie.services.eliot.absences.saisie.discipline.sanction.SanctionParams
-import org.lilie.services.eliot.securite.AutorisationException
-
import org.lilie.services.eliot.absences.saisie.discipline.incident.IncidentParams
import org.lilie.services.eliot.absences.saisie.discipline.incident.ProtagonisteIncidentParams
-
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
import org.lilie.services.eliot.scolarite.Personne
-
import org.lilie.services.eliot.absences.saisie.discipline.sanction.exceptions.SanctionDescriptionLongueException
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.absences.saisie.discipline.sanction.AbsencesSanctionService
import org.lilie.services.eliot.absences.saisie.discipline.incident.AbsencesIncidentService
import org.lilie.services.eliot.applications.absences.DisciplineCriteresRecherche
import org.lilie.services.eliot.applications.absences.SanctionService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
+import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
+import grails.test.GrailsUnitTestCase
-class AbsencesSanctionServiceTests extends GroovyTestCase {
+class AbsencesSanctionServiceTests extends GrailsUnitTestCase {
InitDonneesCommunesTestAbsenceService initDonneesCommunesTestAbsenceService
- org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
+ PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AbsencesTypeSanctionService absencesTypeSanctionService
AbsencesSanctionService absencesSanctionService
AbsencesIncidentService absencesIncidentService
Etablissement etablissement
PreferencesEtablissementAbsences preferences
- SecuriteSession securiteSessionDirecteur
- SecuriteSession securiteSessionEleve
- SecuriteSession securiteSessionEnseignant
-
Personne eleve
Personne censeur
protected void setUp() {
super.setUp()
+
etablissement = initDonneesCommunesTestAbsenceService.
getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
+
preferences = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(etablissement)
- securiteSessionDirecteur = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- securiteSessionEleve = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ELEVE_1_CLASSE_1
- )
- securiteSessionEnseignant = initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
eleve = localPersonneService.findPersonneByAutorite(
initDonneesCommunesTestAbsenceService.getAutorite(
PopulationTestActeur.ELEVE_1_CLASSE_1
)
typeSanction = absencesTypeSanctionService.creeTypeSanction(
- securiteSessionDirecteur,
preferences,
'Test-Sanction-Type1'
)
lieuIncident = lieuIncidentService.creeLieuIncident(
- securiteSessionDirecteur,
preferences,
'Test--Sanction lieuInci'
)
typeIncident = absencesTypeIncidentService.creeTypeIncident(
- securiteSessionDirecteur,
preferences,
'Test--sanction Tyincident'
)
qualiteProtagoniste = qualiteProtagonisteService.creeQualiteProtagoniste(
- securiteSessionDirecteur,
preferences,
'Test--Sanction protagon'
)
qualiteProtagoniste: qualiteProtagoniste
)
- incident = absencesIncidentService.creeIncident(
- securiteSessionDirecteur,
- incidentParams
- )
+ incident = absencesIncidentService.creeIncident(incidentParams)
}
super.tearDown()
}
+
void testDonneesInit() {
assertNotNull('Etablissement', etablissement)
assertNotNull('Preferences', preferences)
- assertNotNull('securiteSessionDirecteur', securiteSessionDirecteur)
- assertNotNull('securiteSessionEleve', securiteSessionEleve)
- assertNotNull('securiteSessionEnseignant', securiteSessionEnseignant)
assertNotNull('elève 1', eleve)
assertNotNull('Censeur 1', censeur)
assertNotNull('Type sanction 1', typeSanction)
void testCreeSanction() {
String descriptionCourte = 'description de la sanction'
String descriptionLongue = """
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+ aaaaaaaa aaaa aaaaaaaaaaa aa aaaaaaaaa aaaaaaaaaa aaaaaaaaaaa aaaaaaaaaaaaa
+ aa aaaaaaaaa a aaaaaaaa aaaaaaaaaa aaaaaaaaaa aaaaaaaaaaaaa aaaaaaaaaaaaaaa
+ aaa aaaaa aaaaaa aaaaaaaaaaaa aaaaaaaaaaaaaaa aaaaaaaaaaaa aaaaaaaa aaaaaaa
+ aaaaaaaaaa aaaaaaaaa aaaaaaaaa aaaaaaaaaaaaaa aaaaaaaaaa aaaaaaaaaaa aaaaaa
+ aaaaaaaaaaa aaaaaaaaaaa aaaaaaaaaaaa aaaaaaaaaaaaa aaa a aaaaaaa aaaaaaaaaa
"""
SanctionParams sanctionParams = new SanctionParams(
etablissement: etablissement,
Boolean exceptionLevee = false
try {
- absencesSanctionService.creeSanction(
- securiteSessionEleve,
- sanctionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un élève ne doit pas pouvoir créer une sanction",
- exceptionLevee
- )
-
- exceptionLevee = false
- try {
- absencesSanctionService.creeSanction(
- securiteSessionEnseignant,
- sanctionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
-
- assertTrue(
- "Un enseignant ne doit pas pouvoir créer une sanction",
- exceptionLevee
- )
-
- exceptionLevee = false
- try {
- absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- sanctionParams
- )
+ absencesSanctionService.creeSanction(sanctionParams)
} catch (SanctionDescriptionLongueException e) {
exceptionLevee = true
}
)
sanctionParams.description = descriptionCourte
- Sanction sanction = absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- sanctionParams
- )
+ Sanction sanction = absencesSanctionService.creeSanction(sanctionParams)
assertNotNull(
"La sanction n'a pas été créee",
)
}
+
void testModifieSanction() {
SanctionParams sanctionParams = new SanctionParams(
etablissement: etablissement,
preferences: preferences
)
- Sanction sanction = absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- sanctionParams
- )
+ Sanction sanction = absencesSanctionService.creeSanction(sanctionParams)
sanctionParams.effectue = false
- Boolean exceptionLevee = false
- try {
- absencesSanctionService.modifieSanction(
- securiteSessionEnseignant,
- sanction,
- sanctionParams
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un enseignant n'a pas le droit de modifier une sanction",
- exceptionLevee
- )
-
absencesSanctionService.modifieSanction(
- securiteSessionDirecteur,
sanction,
sanctionParams
)
sanctionModifiee.effectue,
sanctionParams.effectue
)
-
}
+
void testSupprimeSanction() {
SanctionParams sanctionParams = new SanctionParams(
etablissement: etablissement,
preferences: preferences
)
- Sanction sanction = absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- sanctionParams
- )
-
- Boolean exceptionLevee = false
- try {
- absencesSanctionService.supprimeSanction(securiteSessionEnseignant, sanction)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un enseignant n'a pas le droit de supprimer une sanction",
- exceptionLevee
- )
-
- exceptionLevee = false
- try {
- absencesSanctionService.supprimeSanction(securiteSessionEleve, sanction)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(
- "Un élève n'a pas le droit de supprimer une sanction",
- exceptionLevee
- )
+ Sanction sanction = absencesSanctionService.creeSanction(sanctionParams)
- absencesSanctionService.supprimeSanction(securiteSessionDirecteur, sanction)
+ absencesSanctionService.supprimeSanction(sanction)
assertNull("La sanction n'a pas été supprimée", Sanction.get(sanction.id))
-
}
+
void testFindSanctionForCriteres(){
Date date = new Date()
preferences: preferences
)
- Sanction sanction = absencesSanctionService.creeSanction(
- securiteSessionDirecteur,
- sanctionParams
- )
+ absencesSanctionService.creeSanction(sanctionParams)
DisciplineCriteresRecherche disciplineCriteresRecherche =
new DisciplineCriteresRecherche(
assertTrue('Une sanction devrait être trouvée',allSanction.size() == 1)
}
-
-
-
-
}
super.setUp()
pref = preferencesEtablissementAbsencesService.
getPreferencesEtablissementForEtablissement(
- initDonneesCommunesTestAbsenceService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ initDonneesCommunesTestAbsenceService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ )
)
- )
eleve1 = localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_1
*/
void testCalculeBilanForEleveAndPeriode() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_JOUR,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref.id,
+ PreferencesEtablissementAbsences.DECOMPTE_JOUR
)
absencesGeneralService.setLongueurPlage(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
- pref,
- AbsencesGeneralService.CODE_LONGUEUR_PLAGE_HEURE
+ initDonneesCommunesTestAbsenceService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1
+ ),
+ pref,
+ AbsencesGeneralService.CODE_LONGUEUR_PLAGE_HEURE
)
// positionne motifs
// verifie les recoups d'absences
Map bilanTous = getBilan(
- PopulationTestActeur.DIRECTION_1,
- PopulationTestActeur.ELEVE_2_CLASSE_1,
- '01/09/2010', '30/09/2010',
- PopulationTestClasse.CLASSE_1,
- PriseEnCompteMotif.TOUS)
+ PopulationTestActeur.DIRECTION_1,
+ PopulationTestActeur.ELEVE_2_CLASSE_1,
+ '01/09/2010', '30/09/2010',
+ PopulationTestClasse.CLASSE_1,
+ PriseEnCompteMotif.TOUS)
Map bilanBulletin = getBilan(
- PopulationTestActeur.DIRECTION_1,
- PopulationTestActeur.ELEVE_2_CLASSE_1,
- '01/09/2010', '30/09/2010',
- PopulationTestClasse.CLASSE_1,
- PriseEnCompteMotif.BULLETIN)
+ PopulationTestActeur.DIRECTION_1,
+ PopulationTestActeur.ELEVE_2_CLASSE_1,
+ '01/09/2010', '30/09/2010',
+ PopulationTestClasse.CLASSE_1,
+ PriseEnCompteMotif.BULLETIN)
Map bilanStats = getBilan(
- PopulationTestActeur.DIRECTION_1,
- PopulationTestActeur.ELEVE_2_CLASSE_1,
- '01/09/2010', '30/09/2010',
- PopulationTestClasse.CLASSE_1,
- PriseEnCompteMotif.STATS)
+ PopulationTestActeur.DIRECTION_1,
+ PopulationTestActeur.ELEVE_2_CLASSE_1,
+ '01/09/2010', '30/09/2010',
+ PopulationTestClasse.CLASSE_1,
+ PriseEnCompteMotif.STATS)
assertEquals(
- "L'élève doit avoir 1 absences de moins",
- 1,
- bilanTous.get(BilanService.ABSENCES_EXCUSEES_NB) -
- bilanBulletin.get(BilanService.ABSENCES_EXCUSEES_NB)
+ "L'élève doit avoir 1 absences de moins",
+ 1,
+ bilanTous.get(BilanService.ABSENCES_EXCUSEES_NB) -
+ bilanBulletin.get(BilanService.ABSENCES_EXCUSEES_NB)
)
assertEquals(
- "L'élève doit avoir 1 absence de moins",
- 1,
- bilanTous.get(BilanService.ABSENCES_EXCUSEES_NB) -
- bilanStats.get(BilanService.ABSENCES_EXCUSEES_NB)
+ "L'élève doit avoir 1 absence de moins",
+ 1,
+ bilanTous.get(BilanService.ABSENCES_EXCUSEES_NB) -
+ bilanStats.get(BilanService.ABSENCES_EXCUSEES_NB)
)
}
PopulationTestClasse classe = null,
PriseEnCompteMotif priseEnCompteMotif = null) {
return bilanService.calculeBilanForEleveAndPeriode(
- initDonneesCommunesTestAbsenceService.getSecuriteSession(acteurDir),
- initDonneesCommunesTestAbsenceService.getAutorite(acteurEleve),
- Date.parse('dd/MM/yyyy', dateDebut),
- Date.parse('dd/MM/yyyy', dateFin),
- classe? initDonneesCommunesTestAbsenceService.getClasse(classe) : null,
- priseEnCompteMotif
+ initDonneesCommunesTestAbsenceService.getSecuriteSession(acteurDir),
+ initDonneesCommunesTestAbsenceService.getAutorite(acteurEleve),
+ Date.parse('dd/MM/yyyy', dateDebut),
+ Date.parse('dd/MM/yyyy', dateFin),
+ classe? initDonneesCommunesTestAbsenceService.getClasse(classe) : null,
+ priseEnCompteMotif
)
}
void testCalculeBilanForEleveAndPeriodeEnHeures() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
Map bilanInitialEleve4 = getBilan(
- PopulationTestActeur.DIRECTION_1,
- PopulationTestActeur.ELEVE_4_CLASSE_1,
- '01/09/2010',
- '30/09/2010'
+ PopulationTestActeur.DIRECTION_1,
+ PopulationTestActeur.ELEVE_4_CLASSE_1,
+ '01/09/2010',
+ '30/09/2010'
)
Map bilanInitialEleve3 = getBilan(
void testCalculeBilanForEleveAndPeriodeEnDemiJour() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_DEMIJOUR,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ PreferencesEtablissementAbsences.DECOMPTE_DEMIJOUR
)
absencesGeneralService.setLongueurPlage(
Map bilanInitialEleve4 = getBilan(
- PopulationTestActeur.DIRECTION_1,
- PopulationTestActeur.ELEVE_4_CLASSE_1,
- '01/09/2010', '30/09/2010'
+ PopulationTestActeur.DIRECTION_1,
+ PopulationTestActeur.ELEVE_4_CLASSE_1,
+ '01/09/2010', '30/09/2010'
)
Map bilanInitialEleve3 = getBilan(
void testCalculeBilanForEleveAndPeriodeEnJour() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_JOUR,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ PreferencesEtablissementAbsences.DECOMPTE_JOUR
)
absencesGeneralService.setLongueurPlage(
// Récupère les impressions infos
List<EleveImpressionInfo> impressionsInfo =
- impressionRequetageAbsencesService.findAllInfoForRetardsAndDepartAnticipes(
- sessionDirecteur,
- etablissement,
- criteres,
- SelectionAdresseResponsableEnum.ADRESSE_RESPONSABLE1
- )
+ impressionRequetageAbsencesService.findAllInfoForRetardsAndDepartAnticipes(
+ sessionDirecteur,
+ etablissement,
+ criteres,
+ SelectionAdresseResponsableEnum.ADRESSE_RESPONSABLE1
+ )
assertTrue(impressionsInfo.size() == 2)
// Récupère les impressions infos
List<EleveImpressionInfo> impressionsInfo =
- impressionRequetageAbsencesService.findAllInfoForAbsences(
- sessionDirecteur,
- etablissement,
- criteres,
- SelectionAdresseResponsableEnum.ADRESSE_RESPONSABLE1
- )
+ impressionRequetageAbsencesService.findAllInfoForAbsences(
+ sessionDirecteur,
+ etablissement,
+ criteres,
+ SelectionAdresseResponsableEnum.ADRESSE_RESPONSABLE1
+ )
assertTrue(impressionsInfo.size() == 2)
import org.lilie.services.eliot.absences.saisie.demipensioninternat.DemiPensionInternatLigneParams
import org.lilie.services.eliot.test.InitDonneesCommunesTestAbsenceService
import org.lilie.services.eliot.absences.saisie.demipensioninternat.DemiPensionInternatService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.test.InitDonneesCommunesTestPreferencesAbsencesService
/**
*/
class DemiPensionInternatServiceTests extends GroovyTestCase {
+
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
InitDonneesCommunesTestAbsenceService InitDonneesCommunesTestAbsenceService
DemiPensionInternatService demiPensionInternatService
Etablissement etablissement
SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
Personne eleve1
Personne eleve2
Motif motif1
protected void setUp() {
super.setUp()
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
+ PopulationTestActeur.DIRECTION_1
)
eleve1 = localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ELEVE_1_CLASSE_1
+ PopulationTestActeur.ELEVE_1_CLASSE_1
)
eleve2 = localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ELEVE_2_CLASSE_1
+ PopulationTestActeur.ELEVE_2_CLASSE_1
)
motif1 = initDonneesCommunesTestPreferencesAbsencesService.getMotif1()
// Crée une absence en demi-demipensioninternat
DemiPensionInternatLigneParams ligne1 = new DemiPensionInternatLigneParams(
- eleve: eleve1,
- motif: motif1
+ eleve: eleve1,
+ motif: motif1
)
DemiPensionInternatLigneParams ligne2 = new DemiPensionInternatLigneParams(
- eleve: eleve2,
- motif: motif1
+ eleve: eleve2,
+ motif: motif1
)
DemiPensionInternatParams params = new DemiPensionInternatParams(
- date: new Date(),
- etablissement: etablissement,
- demiPension: true,
- operateurSaisie: (Personne) sessionDirecteur.personne,
- lignes: [
- ligne1,
- ligne2
- ]
+ date: new Date(),
+ etablissement: etablissement,
+ demiPension: true,
+ operateurSaisie: (Personne) sessionDirecteur.personne,
+ lignes: [
+ ligne1,
+ ligne2
+ ]
)
- // Vréification des droits de création
- boolean exceptionLevee = false
- try {
- demiPensionInternatService.creeAbsences(sessionProfesseur, params)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("L'enseignant a le droit de créer des pensions", exceptionLevee)
-
- List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(
- sessionDirecteur,
- params
- )
+ List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(params)
assertTrue(
- "Nombre des appels lignes crées n est pas correct",
- appelLignes.size() == 2
+ "Nombre des appels lignes crées n est pas correct",
+ appelLignes.size() == 2
)
assertNotNull('Appel ligne null', appelLignes[0])
assertNull(appelLignes[0].heureFin)
assertNull(appelLignes[0].sanction)
assertEquals(
- appelLignes[0].operateurSaisie.idExterne,
- sessionDirecteur.personne.autorite.idExterne
+ appelLignes[0].operateurSaisie.idExterne,
+ sessionDirecteur.personne.autorite.idExterne
)
println 'params.date ' + params.date
println 'appelLignes[0].dateSaisie ' + appelLignes[0].dateSaisie
println 'appelLignes[0].absenceJournee.date ' + appelLignes[0].absenceJournee.date
assertEquals(
- appelLignes[0].dateSaisie,
- appelLignes[0].absenceJournee.date
+ appelLignes[0].dateSaisie,
+ appelLignes[0].absenceJournee.date
)
assertEquals(
- appelLignes[0].absenceJournee,
- appelLignes[1].absenceJournee,
+ appelLignes[0].absenceJournee,
+ appelLignes[1].absenceJournee,
)
assertNotNull(
- appelLignes[0].absenceJournee
+ appelLignes[0].absenceJournee
)
void testModifiePensions() {
DemiPensionInternatLigneParams ligne1 = new DemiPensionInternatLigneParams(
- eleve: eleve1,
- motif: motif1
+ eleve: eleve1,
+ motif: motif1
)
DemiPensionInternatParams params = new DemiPensionInternatParams(
- date: new Date(),
- etablissement: etablissement,
- demiPension: true,
- operateurSaisie: (Personne) sessionDirecteur.personne,
- lignes: [ligne1]
+ date: new Date(),
+ etablissement: etablissement,
+ demiPension: true,
+ operateurSaisie: (Personne) sessionDirecteur.personne,
+ lignes: [ligne1]
)
- List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(
- sessionDirecteur,
- params
- )
+ List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(params)
// Modifie le motif
ligne1.motif = motif2
// Ajoute l'identifiant
ligne1.id = appelLignes[0].id
- // Vréification des droits de création
- boolean exceptionLevee = false
- try {
- demiPensionInternatService.modifieAbsences(sessionProfesseur,
- etablissement,
- [ligne1]
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("L'enseignant a le droit de modifier des pensions", exceptionLevee)
-
- List lignesModifiees = demiPensionInternatService.modifieAbsences(
- sessionDirecteur,
- etablissement,
- [ligne1]
- )
+ List lignesModifiees = demiPensionInternatService.modifieAbsences([ligne1])
assertTrue(lignesModifiees.size() == 1)
assertNotNull(lignesModifiees[0])
void testSupprimePensions() {
DemiPensionInternatLigneParams ligne1 = new DemiPensionInternatLigneParams(
- eleve: eleve1,
- motif: motif1
+ eleve: eleve1,
+ motif: motif1
)
DemiPensionInternatParams params = new DemiPensionInternatParams(
- date: new Date(),
- etablissement: etablissement,
- demiPension: true,
- operateurSaisie: (Personne) sessionDirecteur.personne,
- lignes: [ligne1]
+ date: new Date(),
+ etablissement: etablissement,
+ demiPension: true,
+ operateurSaisie: (Personne) sessionDirecteur.personne,
+ lignes: [ligne1]
)
- List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(
- sessionDirecteur,
- params
- )
+ List<AppelLigne> appelLignes = demiPensionInternatService.creeAbsences(params)
- // Vréification des droits de création
- boolean exceptionLevee = false
- try {
- demiPensionInternatService.supprimeAbsences(
- sessionProfesseur,
- etablissement,
- [appelLignes[0].id]
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("L'enseignant a le droit de supprimer des pensions", exceptionLevee)
-
- demiPensionInternatService.supprimeAbsences(
- sessionDirecteur,
- etablissement,
- [appelLignes[0].id]
- )
+ demiPensionInternatService.supprimeAbsences([appelLignes[0].id])
assertNull(AppelLigne.get(appelLignes[0].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.absences
-
-import grails.test.*
-import org.lilie.services.eliot.annuaire.Acteur
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.test.PopulationTestEtablissement
-import org.lilie.services.eliot.test.PopulationTestActeur
-
-import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.absences.AbsencesFonctionnalite
-
-
-class DroitsServiceTests extends GrailsUnitTestCase {
-
- DroitsService droitsService
- LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
-
- protected void setUp() {
- super.setUp()
- }
-
- protected void tearDown() {
- super.tearDown()
- }
-
- void testVerificationDroitModificationParam() {
- Boolean exceptionLevee = false
-
- Acteur directeurEtab1 =
- localInitDonneesCommunesTestService.getActeur(PopulationTestActeur.DIRECTION_1)
- try {
- droitsService.verifieDroitFonctionnalite(
- directeurEtab1.securiteSession,
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- AbsencesFonctionnalite.ABS_PARAM_GENERAUX
- )
- } catch (Exception e) {
- exceptionLevee = true
- }
-
- assertFalse("Le directeur peut modifier le paramétrage de son établissement",
- exceptionLevee)
-
- exceptionLevee = false
- Acteur profEtab1 =
- localInitDonneesCommunesTestService.getActeur(PopulationTestActeur.ENSEIGNANT_1)
- try {
- droitsService.verifieDroitFonctionnalite(
- profEtab1.securiteSession,
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- AbsencesFonctionnalite.ABS_PARAM_GENERAUX
- )
- } catch (Exception e) {
- exceptionLevee = true
- }
- assertTrue("Un professeur ne peut pas modifier le paramétrage" +
- " de son établissement", exceptionLevee)
-
- exceptionLevee = false
- Acteur directeurEtab2 = localInitDonneesCommunesTestService.
- getActeur(PopulationTestActeur.DIRECTION_2)
- try {
- droitsService.verifieDroitFonctionnalite(
- directeurEtab2.securiteSession,
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- AbsencesFonctionnalite.ABS_PARAM_GENERAUX
- )
- } catch (Exception e) {
- exceptionLevee = true
- }
- assertTrue("Un directeur ne peut pas modifier le paramétrage" +
- " d'un autre établissement", exceptionLevee)
- }
-
- private Etablissement getUserEtab(Acteur acteur) {
- Etablissement etab = Etablissement.findByIdExterne(acteur.organisationRattachement.idExterne)
- return etab
- }
-}
import java.text.SimpleDateFormat
import org.lilie.services.eliot.temps.TempsAgendaService
import org.lilie.services.eliot.temps.TempsEvenementService
-import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
import org.lilie.services.eliot.temps.DateUtil
import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTemps
EmploiDuTempsService emploiDuTempsService
TempsAgendaService tempsAgendaService
TempsEvenementService tempsEvenementService
- EnseignementService enseignementService
-
Personne eleve1
Enseignement enseignement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.LieuIncidentService
PreferencesEtablissementAbsences pref
SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
protected void setUp() {
super.setUp()
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
+ PopulationTestActeur.DIRECTION_1
)
}
assertNotNull(etablissement)
assertNotNull(pref)
assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
println pref.id
}
// Crée un lieu d'incident
String libelle = "test--Lieu d'incident"
- LieuIncident lieu =
- lieuIncidentService.creeLieuIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ LieuIncident lieu = lieuIncidentService.creeLieuIncident(pref, libelle)
// Vérifie les propriétés
assertNotNull(lieu)
assertEquals(lieu.libelle, libelle)
assertEquals(lieu.preferencesEtablissement, pref)
- // Crée un lieu d'incident avec une session qui n'a pas le droit
- Boolean exceptionDroitsLevee = false
- try {
- lieuIncidentService.creeLieuIncident(
- sessionProfesseur,
- pref,
- libelle
- )
- } catch (AutorisationException e) {
- exceptionDroitsLevee = true
- }
- assertTrue(exceptionDroitsLevee)
-
// Crée un lieu d'incident avec libellé de plus de 30 caractères
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- lieuIncidentService.creeLieuIncident(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ lieuIncidentService.creeLieuIncident(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- lieuIncidentService.creeLieuIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ lieuIncidentService.creeLieuIncident(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
// Crée un lieu d'incident
String libelle = 'test--Lieu 2'
String libelle2 = 'test--Lieu 3'
- String libelle3 = 'test--Lieu 3'
- LieuIncident lieu = lieuIncidentService.creeLieuIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ LieuIncident lieu = lieuIncidentService.creeLieuIncident(pref, libelle)
+
// Modifie les propriétés
- lieuIncidentService.modifieLieuIncident(sessionDirecteur,
- lieu,
- libelle2
- )
- LieuIncident lieuMisAJour = LieuIncident.get(
- lieu.id
- )
- assertEquals(lieuMisAJour.libelle, libelle2)
+ lieuIncidentService.modifieLieuIncident(lieu, libelle2)
- // Modifie les propriétés avec une session qui n'a pas le droit
- Boolean exceptionLevee = false
- try {
- lieuIncidentService.modifieLieuIncident(sessionProfesseur,
- lieuMisAJour,
- libelle3
- )
- }
- catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(exceptionLevee)
+ LieuIncident lieuMisAJour = LieuIncident.get(lieu.id)
+
+ assertEquals(lieuMisAJour.libelle, libelle2)
}
// Crée un lieu d'incident
String libelle = 'test--Lieu Suppression'
LieuIncident lieu =
- lieuIncidentService.creeLieuIncident(
- sessionDirecteur,
- pref,
- libelle
- )
- // Supprime le lieu d'incident avec une autorité qui n'a pas le droits
- Boolean exceptionLevee = false
- try {
- lieuIncidentService.supprimeLieuIncident(
- sessionProfesseur,
- lieu
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue exceptionLevee
+ lieuIncidentService.creeLieuIncident(pref, libelle)
// Supprime le lieu d'incident
- lieuIncidentService.supprimeLieuIncident(
- sessionDirecteur,
- lieu
- )
- LieuIncident lieuSupprime = LieuIncident.findByLibelle(
- libelle
- )
+ lieuIncidentService.supprimeLieuIncident(lieu)
+
+ LieuIncident lieuSupprime = LieuIncident.findByLibelle(libelle)
+
assertNull(lieuSupprime)
}
// récupère la liste des lieux d'incident
// vérifie qu'elle contient les lieux d'incidents par défaut
List<String> libellesLieuxIncidents =
- lieuIncidentService.getLieuxIncident(pref)*.libelle
+ lieuIncidentService.getLieuxIncident(pref)*.libelle
assertTrue(
- "La liste des lieux d'incidents contient au moins les 5 items par défaut",
- libellesLieuxIncidents.size() >= 5)
+ "La liste des lieux d'incidents contient au moins les 5 items par défaut",
+ libellesLieuxIncidents.size() >= 5)
String libelle = 'test--Lieu ajouté'
- lieuIncidentService.creeLieuIncident(
- // ajoute un lieu d'incident à préveniret vérife qu'il est dans la liste
- sessionDirecteur,
- pref,
- libelle
- )
+ lieuIncidentService.creeLieuIncident(pref, libelle)
+
List<String> libellesLieuxIncidents2 = lieuIncidentService.
- getLieuxIncident(pref)*.libelle
+ getLieuxIncident(pref)*.libelle
assertTrue(libellesLieuxIncidents2.contains(libelle))
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.PartenaireAPrevenirService
-
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
-class PartenaireAPrevenirIntegrationTests extends GrailsUnitTestCase {
+class PartenaireAPrevenirServiceTests extends GrailsUnitTestCase {
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AnneeScolaireService anneeScolaireService
Etablissement etablissement
PreferencesEtablissementAbsences pref
- SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
-
protected void setUp() {
super.setUp()
PartenaireAPrevenirIncident.executeUpdate("delete PartenaireAPrevenirIncident")
PartenaireAPrevenir.executeUpdate("delete PartenaireAPrevenir c ")
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
- sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
}
protected void tearDown() {
void testInitDonneestests() {
assertNotNull(etablissement)
assertNotNull(pref)
- assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
println pref.id
}
// Crée un partenaire à prévenir
String libelle = 'Partenaire à prevenir'
PartenaireAPrevenir partenaire =
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelle
- )
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
// Vérifie les propriétés
assertNotNull(partenaire)
assertEquals(partenaire.libelle, libelle)
assertEquals(partenaire.preferencesEtablissement, pref)
- // Crée un partenaire à prévenir avec une session qui n'a pas le droit
- Boolean exceptionDroitsLevee = false
- try {
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionProfesseur,
- pref,
- libelle
- )
- } catch (AutorisationException e) {
- exceptionDroitsLevee = true
- }
- assertTrue(exceptionDroitsLevee)
-
- // Crée un partenaire à prévenir avec libellé de plus de 30 caractères
+ // Crée un partenaire à prévenir avec libellé de plus de 30 caractères
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelle
- )
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
String libelle = 'Partenaire 2'
String libelle2 = 'Partenaire 3'
String libelle3 = 'Partenaire 3'
- PartenaireAPrevenir partenaire = partenaireAPrevenirService.
- creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelle
- )
+ PartenaireAPrevenir partenaire =
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
+
// Modifie les propriétés
- partenaireAPrevenirService.modifiePartenaireAPrevenir(sessionDirecteur,
- partenaire,
- libelle2
+ partenaireAPrevenirService.modifiePartenaireAPrevenir(
+ partenaire,
+ libelle2
)
+
PartenaireAPrevenir partenaireMisAJour = PartenaireAPrevenir.get(
- partenaire.id
+ partenaire.id
)
- assertEquals(partenaireMisAJour.libelle, libelle2)
-
- // Modifie les propriétés avec une session qui n'a pas le droit
- Boolean exceptionLevee = false
- try {
- partenaireAPrevenirService.modifiePartenaireAPrevenir(sessionProfesseur,
- partenaireMisAJour,
- libelle3
- )
- }
- catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(exceptionLevee)
+ assertEquals(partenaireMisAJour.libelle, libelle2)
}
void testSupprimePartenaireAPrevenir() {
// Crée un partenaire à prévenir
String libelle = 'Partenaire Suppression'
PartenaireAPrevenir partenaire =
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelle
- )
- // Supprime le partenaire à prévenir avec une autorité qui n'a pas le droits
- Boolean exceptionLevee = false
- try {
- partenaireAPrevenirService.supprimePartenaireAPrevenir(
- sessionProfesseur,
- partenaire
- )
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue exceptionLevee
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
+
// Supprime le partenaire à prévenir
- partenaireAPrevenirService.supprimePartenaireAPrevenir(
- sessionDirecteur,
- partenaire
- )
+ partenaireAPrevenirService.supprimePartenaireAPrevenir(partenaire)
+
PartenaireAPrevenir partenaireSupprime = PartenaireAPrevenir.findByLibelle(
- libelle
+ libelle
)
assertNull(partenaireSupprime)
}
// récupère la liste des partenaires à prévenir
// vérifie qu'elle contient les partenaires à prévenir par défaut
List<String> libellesPartenairesAPrevenir =
- partenaireAPrevenirService.getParteniresAPrevenir(pref)*.libelle
+ partenaireAPrevenirService.getParteniresAPrevenir(pref)*.libelle
assertTrue(
- "La liste contient au moins les 4 items par défaut",
- libellesPartenairesAPrevenir.size() >= 4
+ "La liste contient au moins les 4 items par défaut",
+ libellesPartenairesAPrevenir.size() >= 4
)
// ajoute un partenaire à préveniret vérife qu'il est dans la liste
String libelle = 'Partenaire ajoutée'
- partenaireAPrevenirService.creePartenaireAPrevenir(
- sessionDirecteur,
- pref,
- libelle
- )
+ partenaireAPrevenirService.creePartenaireAPrevenir(pref, libelle)
+
List<String> libellesPartenairesAPrevenir2 = partenaireAPrevenirService.
- getParteniresAPrevenir(pref)*.libelle
+ getParteniresAPrevenir(pref)*.libelle
assertTrue(libellesPartenairesAPrevenir2.contains(libelle))
}
-
-
}
import grails.test.*
import org.lilie.services.eliot.scolarite.Etablissement
-
-import org.lilie.services.eliot.SessionUtils
-import org.lilie.services.eliot.securite.AutorisationException
-
import org.lilie.services.eliot.test.InitDonneesCommunesTestAbsenceService
import org.lilie.services.eliot.scolarite.etablissement.EtablissementService
-import org.lilie.services.eliot.annuaire.SecuriteSession
/**
* @author ywan
*/
class PreferencesEtablissementServiceTests extends GrailsUnitTestCase {
private static final String idExterneEtablissement = '440000000000002'
- private static final String nomAffichageEtablissement = 'Emile Zola'
- private static final String uaiEtablissement = '0000000B'
- private static final String codePorteur = 'CRIF'
private PreferencesEtablissementAbsences preferenceEtab
EtablissementService etablissementService
org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
PreferencesEtablissementAbsences.DECOMPTE_DEMIJOUR)
}
- void testDroitModifNonDirection() {
- Etablissement etab = (Etablissement)dummySessionDirection().etablissementRattachement
- PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForIdExterne(etab.idExterne)
- SecuriteSession dummySecuriteSession = SessionUtils.securiteSession(dummySessionNonDirection())
- Boolean exceptionLevee = false
- try {
- preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE, dummySecuriteSession)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue("Vérification des droits modification préférences non direction", exceptionLevee)
- }
-
- void testDroitModifDirection() {
- Etablissement etab = (Etablissement)dummySessionDirection().etablissementRattachement
- PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForIdExterne(etab.idExterne)
- SecuriteSession dummySecuriteSession = SessionUtils.securiteSession(dummySessionDirection())
- Boolean exceptionLevee = false
- try {
- preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_JOUR, dummySecuriteSession)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertFalse("Vérification des droits modification préférences direction", exceptionLevee)
- }
-
- private def dummySessionNonDirection() {
- return initDonneesCommunesTestAbsenceService.getDummySessionForLogin(
- 'anais.rousseau'
- )
- }
-
- private SecuriteSession dummySessionDirection() {
- return initDonneesCommunesTestAbsenceService.getDummySessionForLogin(
- 'claire.rougier'
- ).acteur.securiteSession
- }
-
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.QualiteProtagonisteService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
-class QualiteProtagonisteIntegrationTests extends GrailsUnitTestCase {
+class QualiteProtagonisteServiceTests extends GrailsUnitTestCase {
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AnneeScolaireService anneeScolaireService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
QualiteProtagonisteService qualiteProtagonisteService
-
Etablissement etablissement
PreferencesEtablissementAbsences pref
- SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
-
protected void setUp() {
super.setUp()
// Vide la table des qualités de protagoniste
- ProtagonisteIncident.executeUpdate("delete ProtagonisteIncident")
+ ProtagonisteIncident.executeUpdate("delete ProtagonisteIncident")
QualiteProtagoniste.executeUpdate("delete QualiteProtagoniste c ")
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
-
- sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
+ getPreferencesEtablissementForEtablissement(etablissement)
}
protected void tearDown() {
void testInitDonneestests() {
assertNotNull(etablissement)
assertNotNull(pref)
- assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
println pref.id
}
// Crée une de qualité de protagoniste
String libelle = 'Qualite protagoliste'
QualiteProtagoniste protagoniste =
- qualiteProtagonisteService.creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelle
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
+
// Vérifie les propriétés
assertNotNull(protagoniste)
assertEquals(protagoniste.libelle, libelle)
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- qualiteProtagonisteService.creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- qualiteProtagonisteService.creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelle
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
// Crée une qualité
String libelle = 'Protagoniste 2'
String libelle2 = 'Protagoniste 3'
- String libelle3 = 'Protagoniste 3'
- QualiteProtagoniste protagoniste = qualiteProtagonisteService.
- creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelle
- )
+ QualiteProtagoniste protagoniste =
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
+
// Modifie les propriétés
- qualiteProtagonisteService.modifieQualiteProtagoniste(sessionDirecteur,
- protagoniste,
- libelle2
+ qualiteProtagonisteService.modifieQualiteProtagoniste(
+ protagoniste,
+ libelle2
)
QualiteProtagoniste protagonisteMisAJour = QualiteProtagoniste.get(
- protagoniste.id
+ protagoniste.id
)
assertEquals(protagonisteMisAJour.libelle, libelle2)
// Crée une qualité protagoniste
String libelle = 'Protagoniste Suppression'
QualiteProtagoniste protagoniste =
- qualiteProtagonisteService.creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelle
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
// Supprime la qualité protagoniste
- qualiteProtagonisteService.supprimeQualiteProtagoniste(
- sessionDirecteur,
- protagoniste
- )
+ qualiteProtagonisteService.supprimeQualiteProtagoniste(protagoniste)
+
QualiteProtagoniste protagonisteSupprime = QualiteProtagoniste.findByLibelle(
- libelle
+ libelle
)
assertNull(protagonisteSupprime)
}
// récupère la liste des qualités protagoniste,
// vérifie qu'elle contient les qualités protagoniste par défaut
List<String> libellesQualitesProtagoniste =
- qualiteProtagonisteService.getQualitesProtagoniste(pref)*.libelle
+ qualiteProtagonisteService.getQualitesProtagoniste(pref)*.libelle
assertTrue("La liste contient au moins les 3 items par défaut", libellesQualitesProtagoniste.size() >= 3)
// ajoute une qualité protagoniste et vérife qu'il est dans la liste
String libelle = 'Protagoniste ajoutée'
- qualiteProtagonisteService.creeQualiteProtagoniste(
- sessionDirecteur,
- pref,
- libelle
- )
+ qualiteProtagonisteService.creeQualiteProtagoniste(pref, libelle)
+
List<String> libellesQualitesProtagoniste2 = qualiteProtagonisteService.
- getQualitesProtagoniste(pref)*.libelle
+ getQualitesProtagoniste(pref)*.libelle
+
assertTrue(libellesQualitesProtagoniste2.contains(libelle))
}
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
- Stat statVendredi20h00 = getStaJourPlage(stats, Jour.VENDREDI, 20, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statVendredi20h00 = getStatJourPlage(stats, Jour.VENDREDI, 20, 0)
assertEquals(
"Nombre d'absences incorrect pour Jeudi 04h00 - 04h55",
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
assertEquals(
"Nombre de retards incorrect pour Jeudi 04h00 - 04h55",
1,
- statJeudi04h00.valeur
+ statJeudi04h00?.valeur
)
}
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
assertEquals(
"Nombre de departs incorrect pour Jeudi 04h00 - 04h55",
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
Integer nombreEleve = localStructureEnseignementService.findNombreEleve(classe)
Integer precision = StatsHebdosService.PRECISION
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
Integer nombreEleve = localStructureEnseignementService.findNombreEleve(classe)
Integer precision = StatsHebdosService.PRECISION
StatsHebdos stats = statsHebdosService.calculeStatsHebdos(sessionDirecteur, criteres, pref)
- Stat statJeudi04h00 = getStaJourPlage(stats, Jour.JEUDI, 4, 0)
+ Stat statJeudi04h00 = getStatJourPlage(stats, Jour.JEUDI, 4, 0)
Integer precision = StatsHebdosService.PRECISION
}
- private getStaJourPlage(StatsHebdos stats, Jour jour, int heur, int minute) {
+ private getStatJourPlage(StatsHebdos stats, Jour jour, int heur, int minute) {
Calendar c = Calendar.getInstance(Locale.FRANCE)
StatsHebdosPlage statsPlage = stats.statsPlages.find {
idExterne: "-1"
)
- groupe.save(failOnError: true)
classe.addToGroupes(groupe)
+ groupe.save(failOnError: true, flush: true)
+ groupe.refresh()
eleves.each {
proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(it, groupe)
void testCalculeStatsMensuellesAbsencesHeures() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
void testCalculeStatsMensuellesAbsencesHeuresSansMotif() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
void testCalculeStatsMensuellesAbsencesHeuresClasse2() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
void testCalculeStatsMensuellesAbsencesHeuresDates() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
void testCalculeStatsMensuellesAbsencesRetards() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
void testCalculeStatsMensuellesDeparts() {
preferencesEtablissementAbsencesService.modifiePreferencesEtablissement(
- pref.id,
- PreferencesEtablissementAbsences.DECOMPTE_HEURE,
- initDonneesCommunesTestAbsenceService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+ pref,
+ PreferencesEtablissementAbsences.DECOMPTE_HEURE
)
absencesGeneralService.setLongueurPlage(
type: Type.INCIDENTS,
modeCalcul: ModeCalcul.VOLUME,
typesDiscipline: [
- initDonneesCommunesTestDisciplineService.getTypeIncident1(
- sessionDirecteur1, pref
- )
+ initDonneesCommunesTestDisciplineService.getTypeIncident1(pref)
],
structIds: [structure1.id, structure2.id]
)
type: Type.SANCTIONS,
modeCalcul: ModeCalcul.VOLUME,
typesDiscipline: [
- initDonneesCommunesTestDisciplineService.getTypeSanction1(
- sessionDirecteur1, pref
- ),
- initDonneesCommunesTestDisciplineService.getTypeSanction2(
- sessionDirecteur1, pref
- )
+ initDonneesCommunesTestDisciplineService.getTypeSanction1(pref),
+ initDonneesCommunesTestDisciplineService.getTypeSanction2(pref)
],
structIds: [structure1.id, structure2.id]
)
type: Type.PUNITIONS,
modeCalcul: ModeCalcul.VOLUME,
typesDiscipline: [
- initDonneesCommunesTestDisciplineService.getTypePunition1(
- sessionDirecteur1, pref
- ),
- initDonneesCommunesTestDisciplineService.getTypePunition2(
- sessionDirecteur1, pref
- )
+ initDonneesCommunesTestDisciplineService.getTypePunition1(pref),
+ initDonneesCommunesTestDisciplineService.getTypePunition2(pref)
],
structIds: [structure1.id, structure2.id]
)
import grails.test.*
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
-
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.CreationContraintException
-
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
-class TypeIncidentIntegrationTests extends GrailsUnitTestCase {
+class TypeIncidentServiceTests extends GrailsUnitTestCase {
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AnneeScolaireService anneeScolaireService
Etablissement etablissement
PreferencesEtablissementAbsences pref
- SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
-
protected void setUp() {
super.setUp()
Incident.executeUpdate("delete Incident")
TypeIncident.executeUpdate("delete TypeIncident c ")
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
- sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
}
protected void tearDown() {
void testInitDonneestests() {
assertNotNull(etablissement)
assertNotNull(pref)
- assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
- println pref.id
}
void testCreeTypeIncident() {
// Crée un type d'incident
String libelle = 'Dispute'
- TypeIncident type = absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypeIncident type = absencesTypeIncidentService.creeTypeIncident(pref, libelle)
+
// Vérifie les propriétés
assertNotNull(type)
assertEquals(type.libelle, libelle)
assertEquals(type.preferencesEtablissement, pref)
- // Crée un type avec une session qui n'a pas le droit
- Boolean exceptionDroitsLevee = false
- try {
- absencesTypeIncidentService.creeTypeIncident(
- sessionProfesseur,
- pref,
- libelle
- )
- } catch (AutorisationException e) {
- exceptionDroitsLevee = true
- }
- assertTrue(exceptionDroitsLevee)
-
// Crée un type avec libellé de plus de 30 caractères
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ absencesTypeIncidentService.creeTypeIncident(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypeIncidentService.creeTypeIncident(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
String libelle = 'Dispute 2'
String libelle2 = 'Dispute 3'
String libelle3 = 'Dispute 3'
- TypeIncident type = absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypeIncident type = absencesTypeIncidentService.creeTypeIncident(pref, libelle)
+
// Modifie les propriétés
- absencesTypeIncidentService.modifieTypeIncident(sessionDirecteur, type, libelle2)
+ absencesTypeIncidentService.modifieTypeIncident(type, libelle2)
TypeIncident typeMisAJour = TypeIncident.get(type.id)
assertEquals(typeMisAJour.libelle, libelle2)
-
- // Modifie les propriétés avec une session qui n'a pas le droit
- Boolean exceptionLevee = false
- try {
- absencesTypeIncidentService.modifieTypeIncident(sessionProfesseur, type, libelle3)
- }
- catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(exceptionLevee)
-
}
void testSupprimeTypeIncident() {
// Crée un type
String libelle = 'Suppression'
- TypeIncident type = absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelle
- )
- // Supprime le type avec une autorité qui n'a pas le droits
- Boolean exceptionLevee = false
- try {
- absencesTypeIncidentService.supprimeTypeIncident(sessionProfesseur, type)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue exceptionLevee
+ TypeIncident type = absencesTypeIncidentService.creeTypeIncident(pref, libelle)
// Supprime le type
- absencesTypeIncidentService.supprimeTypeIncident(sessionDirecteur, type)
+ absencesTypeIncidentService.supprimeTypeIncident(type)
TypeIncident typeSupprime = TypeIncident.findByLibelle(libelle)
assertNull(typeSupprime)
}
void testGetTypesIncident() {
// récupère la liste des types, vérifie qu'elle contient les types par défaut
List<String> libellesTypesIncidents = absencesTypeIncidentService.
- getTypesIncident(pref)*.libelle
+ getTypesIncident(pref)*.libelle
assertTrue("La liste doit contenir les 4 types par défaut", libellesTypesIncidents.size() >= 4)
// ajoute un type et vérife qu'il est dans la liste
String libelle = '123456'
- absencesTypeIncidentService.creeTypeIncident(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypeIncidentService.creeTypeIncident(pref, libelle)
+
List<String> libellesTypesIncidents2 = absencesTypeIncidentService.
- getTypesIncident(pref)*.libelle
+ getTypesIncident(pref)*.libelle
assertTrue(libellesTypesIncidents2.contains(libelle))
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypePunitionService
-
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.SecuriteSession
-class TypePunitionIntegrationTests extends GrailsUnitTestCase {
+class TypePunitionServiceTests extends GrailsUnitTestCase {
org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AnneeScolaireService anneeScolaireService
Etablissement etablissement
PreferencesEtablissementAbsences pref
- SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
-
protected void setUp() {
super.setUp()
Punition.executeUpdate("delete Punition")
TypePunition.executeUpdate("delete TypePunition")
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
- sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
}
protected void tearDown() {
void testInitDonneestests() {
assertNotNull(etablissement)
assertNotNull(pref)
- assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
- println pref.id
}
void testCreeTypePunition() {
// Crée un type de punition
String libelle = 'Punition'
- TypePunition type = absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypePunition type = absencesTypePunitionService.creeTypePunition(pref, libelle)
// Vérifie les propriétés
assertNotNull(type)
assertEquals(type.libelle, libelle)
assertEquals(type.preferencesEtablissement, pref)
- // Crée un type avec une session qui n'a pas le droit
- Boolean exceptionDroitsLevee = false
- try {
- absencesTypePunitionService.creeTypePunition(
- sessionProfesseur,
- pref,
- libelle
- )
- } catch (AutorisationException e) {
- exceptionDroitsLevee = true
- }
- assertTrue(exceptionDroitsLevee)
-
// Crée un type avec libellé de plus de 30 caractères
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ absencesTypePunitionService.creeTypePunition(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypePunitionService.creeTypePunition(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
String libelle = 'Punition 2'
String libelle2 = 'Punition 3'
String libelle3 = 'Punition 3'
- TypePunition type = absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypePunition type = absencesTypePunitionService.creeTypePunition(pref, libelle)
+
// Modifie les propriétés
- absencesTypePunitionService.modifieTypePunition(sessionDirecteur, type, libelle2)
+ absencesTypePunitionService.modifieTypePunition(type, libelle2)
TypePunition typeMisAJour = TypePunition.get(type.id)
assertEquals(typeMisAJour.libelle, libelle2)
-
- // Modifie les propriétés avec une session qui n'a pas le droit
- Boolean exceptionLevee = false
- try {
- absencesTypePunitionService.modifieTypePunition(sessionProfesseur, type, libelle3)
- }
- catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(exceptionLevee)
-
}
void testSupprimeTypePunition () {
// Crée un type
String libelle = 'Punition Suppression'
- TypePunition type = absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelle
- )
- // Supprime le type avec une autorité qui n'a pas le droits
- Boolean exceptionLevee = false
- try {
- absencesTypePunitionService.supprimeTypePunition(sessionProfesseur, type)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue exceptionLevee
+ TypePunition type = absencesTypePunitionService.creeTypePunition(pref, libelle)
// Supprime le type
- absencesTypePunitionService.supprimeTypePunition(sessionDirecteur, type)
+ absencesTypePunitionService.supprimeTypePunition(type)
+
TypePunition typeSupprime = TypePunition.findByLibelle(libelle)
assertNull(typeSupprime)
}
void testGetTypesPunition() {
// récupère la liste des types, vérifie qu'elle contient les types par défaut
List<String> libellesTypesPunition = absencesTypePunitionService.
- getTypesPunition(pref)*.libelle
+ getTypesPunition(pref)*.libelle
assertTrue("La liste doit contenir les 2 éléments par défaut", libellesTypesPunition.size() >= 2)
// ajoute un type et vérife qu'il est dans la liste
String libelle = 'Punition ajoutée'
- absencesTypePunitionService.creeTypePunition(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypePunitionService.creeTypePunition(pref, libelle)
+
List<String> libellesTypesPunition2 = absencesTypePunitionService.
- getTypesPunition(pref)*.libelle
- assertTrue(libellesTypesPunition2.contains(libelle))
+ getTypesPunition(pref)*.libelle
+ assertTrue(libellesTypesPunition2.contains(libelle))
}
-
-
}
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.exceptions.LibelleLongException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
-class TypeSanctionIntegrationTests extends GrailsUnitTestCase {
+class TypeSanctionServiceTests extends GrailsUnitTestCase {
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AnneeScolaireService anneeScolaireService
Etablissement etablissement
PreferencesEtablissementAbsences pref
- SecuriteSession sessionDirecteur
- SecuriteSession sessionProfesseur
-
protected void setUp() {
super.setUp()
etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
pref = preferencesEtablissementAbsencesService.
- getPreferencesEtablissementForEtablissement(etablissement)
+ getPreferencesEtablissementForEtablissement(etablissement)
- sessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
- sessionProfesseur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
}
protected void tearDown() {
void testInitDonneestests() {
assertNotNull(etablissement)
assertNotNull(pref)
- assertNotNull(sessionDirecteur)
- assertNotNull(sessionProfesseur)
- println pref.id
}
void testCreeTypeSanction() {
// Crée un type de sanction
String libelle = 'Exclusion'
- TypeSanction type = absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypeSanction type = absencesTypeSanctionService.creeTypeSanction(pref, libelle)
+
// Vérifie les propriétés
assertNotNull(type)
assertEquals(type.libelle, libelle)
assertEquals(type.preferencesEtablissement, pref)
- // Crée un type avec une session qui n'a pas le droit
- Boolean exceptionDroitsLevee = false
- try {
- absencesTypeSanctionService.creeTypeSanction(
- sessionProfesseur,
- pref,
- libelle
- )
- } catch (AutorisationException e) {
- exceptionDroitsLevee = true
- }
- assertTrue(exceptionDroitsLevee)
-
// Crée un type avec libellé de plus de 30 caractères
String libelleLong = 'azertyuiopqsdfghjklmwxcvbnazert'
Boolean exceptionLibelleLevee = false
try {
- absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelleLong
- )
+ absencesTypeSanctionService.creeTypeSanction(pref, libelleLong)
} catch (LibelleLongException e) {
exceptionLibelleLevee = true
}
// Crée un doublon
Boolean exceptionDoublonLevee = false
try {
- absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypeSanctionService.creeTypeSanction(pref, libelle)
} catch (CreationContraintException e) {
exceptionDoublonLevee = true
}
// Crée un type
String libelle = 'Exclusion 2'
String libelle2 = 'Exclusion 3'
- String libelle3 = 'Exclusion 3'
- TypeSanction type = absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelle
- )
+ TypeSanction type = absencesTypeSanctionService.creeTypeSanction(pref, libelle)
+
// Modifie les propriétés
- absencesTypeSanctionService.modifieTypeSanction(sessionDirecteur, type, libelle2)
+ absencesTypeSanctionService.modifieTypeSanction(type, libelle2)
TypeSanction typeMisAJour = TypeSanction.get(type.id)
assertEquals(typeMisAJour.libelle, libelle2)
-
- // Modifie les propriétés avec une session qui n'a pas le droit
- Boolean exceptionLevee = false
- try {
- absencesTypeSanctionService.modifieTypeSanction(sessionProfesseur, type, libelle3)
- }
- catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue(exceptionLevee)
-
}
void testSupprimeTypeSanction() {
// Crée un type
String libelle = 'Suppression'
- TypeSanction type = absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelle
- )
- // Supprime le type avec une autorité qui n'a pas le droits
- Boolean exceptionLevee = false
- try {
- absencesTypeSanctionService.supprimeTypeSanction(sessionProfesseur, type)
- } catch (AutorisationException e) {
- exceptionLevee = true
- }
- assertTrue exceptionLevee
+ TypeSanction type = absencesTypeSanctionService.creeTypeSanction(pref, libelle)
// Supprime le type
- absencesTypeSanctionService.supprimeTypeSanction(sessionDirecteur, type)
+ absencesTypeSanctionService.supprimeTypeSanction(type)
TypeSanction typeSupprime = TypeSanction.findByLibelle(libelle)
assertNull(typeSupprime)
}
void testGetTypesSanction() {
// récupère la liste des types, vérifie qu'elle contient les types par défaut
List<String> libellesTypesSanction = absencesTypeSanctionService.
- getTypesSanction(pref)*.libelle
+ getTypesSanction(pref)*.libelle
assertTrue(
- "La liste doit contenir les deux éléments par défaut",
- libellesTypesSanction.size() >= 2
+ "La liste doit contenir les deux éléments par défaut",
+ libellesTypesSanction.size() >= 2
)
// ajoute un type et vérife qu'il est dans la liste
String libelle = '123456'
- absencesTypeSanctionService.creeTypeSanction(
- sessionDirecteur,
- pref,
- libelle
- )
+ absencesTypeSanctionService.creeTypeSanction(pref, libelle)
+
List<String> libellesTypesSanction2 = absencesTypeSanctionService.
- getTypesSanction(pref)*.libelle
+ getTypesSanction(pref)*.libelle
+
assertTrue(libellesTypesSanction2.contains(libelle))
}
classe.etablissement = etablissement
CalendrierDispense calendrierDispense =
- saisieDispenseService.findDispensesInfoForEleveAndPeriode(securiteSession,
+ saisieDispenseService.findDispensesInfoForEleveAndPeriode(
+ securiteSession,
eleve,
classe,
matiere,
dateDebut,
dateFin)
- assertEquals(calendrierDispense.lignes.size(),15)
- assertEquals(calendrierDispense.lignes[4].plageHoraire.debut, Date.parse('hh:mm', '08:00'))
- assertEquals(calendrierDispense.lignes[4].plageHoraire.fin, Date.parse('hh:mm', '09:00'))
- assertEquals(calendrierDispense.lignes[4].jourSemaines.size() , 6)
- assertEquals(calendrierDispense.lignes[4].jourSemaines[3].dateCours.size() , 1)
- assertEquals(calendrierDispense.lignes[4].jourSemaines[3].dateCours[0] , Date.parse('dd/MM/yyyy', '16/05/2013'))
+ assertEquals(15, calendrierDispense.lignes.size())
+ assertEquals(Date.parse('hh:mm', '08:00'), calendrierDispense.lignes[4].plageHoraire.debut)
+ assertEquals(Date.parse('hh:mm', '09:00'), calendrierDispense.lignes[4].plageHoraire.fin, )
+ assertEquals(6, calendrierDispense.lignes[4].jourSemaines.size())
+ assertEquals(1, calendrierDispense.lignes[4].jourSemaines[3].dateCours.size())
+ assertEquals(Date.parse('dd/MM/yyyy', '16/05/2013'), calendrierDispense.lignes[4].jourSemaines[3].dateCours[0])
assertFalse(calendrierDispense.lignes[0].jourSemaines[0].plageOuverte)
- assertEquals(calendrierDispense.lignes[0].jourSemaines[0].dateCours.size() , 0)
-
+ assertEquals(0, calendrierDispense.lignes[0].jourSemaines[0].dateCours.size())
}
1 * saisieCollectiveReferentielService.creeReferentiel(_, _, _, _) >> saisieCollectiveReferentiel
1 * rechercheAbsenceExistanteService.findAppelLigneExistantes(_) >> []
1 * appelLigneService.supprimeAppelLignes(_)
- 1 * saisieHebdomadaireService.enregistreSaisieHebdo(_, _) >> []
+ 1 * saisieHebdomadaireService.enregistreSaisieHebdo(_) >> []
}
}