return enseignements*.service*.structureEnseignement
}
+ List<StructureEnseignement> findAllStructureEnseignementByEnseignantAndEtablissementLight(Autorite enseignant,
+ Etablissement etablissement,
+ TypeStructureEnum typeStructure = null
+ ) {
+
+ String sql = """
+ SELECT DISTINCT str.id AS id, str.code AS code
+ FROM ent.enseignement ens
+ LEFT JOIN ent.service ser ON ens.service_id = ser.id
+ LEFT JOIN ent.structure_enseignement str ON ser.structure_enseignement_id = str.id
+ WHERE ens.enseignant_id = :enseignantId
+ AND str.etablissement_id = :etablissementId
+ AND annee_scolaire_id = :anneeId
+ ORDER BY str.code ASC
+"""
+
+ Session session = sessionFactory.getCurrentSession()
+
+ SQLQuery sqlQuery = session.createSQLQuery(sql)
+
+ sqlQuery.addScalar(ConstTechniques.ID, Hibernate.LONG)
+ sqlQuery.addScalar(ConstTechniques.CODE, Hibernate.STRING)
+
+ sqlQuery.setLong(ConstTechniques.ETABLISSEMENT_ID, etablissement.id)
+ sqlQuery.setLong(ConstTechniques.ANNEE_ID, anneeScolaireService.anneeScolaireEnCours().id)
+ sqlQuery.setLong(ConstTechniques.ENSEIGNANT_ID, enseignant.id)
+
+ List<Map> result = (List<Map>)sqlQuery.list()
+
+ List<StructureEnseignement> structureEnseignementList = []
+
+ result.each {
+ StructureEnseignement structureEnseignement = new StructureEnseignement()
+ structureEnseignement.id = it[0]
+ structureEnseignement.code = it[1]
+
+ structureEnseignementList.add(structureEnseignement)
+ }
+
+ return structureEnseignementList
+ }
+
List<Map> findAllStructureEnseignementLight(Autorite enseignant,
Etablissement etablissement,
Boolean sortAsc = true
return defaultAgendasEnseignant
}
+ List<Long> findAllAgendaIdEnseignantByEnseignant(SecuriteSession securiteSession) {
+ List<Long> defaultAgendasIdEnseignant = []
+ // type de l'agenda, création si il n'existe pas
+ TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
+ TypeAgendaEnum.ETE
+ )
+ defaultAgendasIdEnseignant = Agenda.withCriteria {
+ eq("enseignant", securiteSession.defaultAutorite)
+ eq("typeAgenda", typeAgenda)
+ projections {
+ property('id')
+ }
+ }
+ return defaultAgendasIdEnseignant
+ }
+
/**
* Indique s'il existe un edt pour l'établissement
*/
* @param evenements : la liste des événements trouvés
* @param isEnseignement : Si les événements cherchés sont des enseignements
*/
- Collection<Evenement> findAllEvenement(Agenda agenda,
+ Collection<Evenement> findAllEvenement(Long agendaId,
Date dateHeureDebut,
Date dateHeureFin,
Boolean enseignementOnly
) {
- return findAllEvenement(agenda, null, dateHeureDebut, dateHeureFin, enseignementOnly)
+ return findAllEvenement(agendaId, null, dateHeureDebut, dateHeureFin, enseignementOnly)
}
/**
* @param enseignementOnly : Si on cherche une liste d'événement correpsondant à un enseignement
*
*/
- Collection<Evenement> findAllEvenement(Agenda agenda,
+ Collection<Evenement> findAllEvenement(Long agendaId,
String objet,
Date dateHeureDebut,
Date dateHeureFin,
Boolean enseignementOnly) {
List<Evenement> evenements = []
List<RelAgendaEvenement> relAgendaEvenements = []
- if (agenda) {
+ if (agendaId) {
relAgendaEvenements = RelAgendaEvenement.withCriteria {
- eq("agenda.id", agenda.id)
+ eq("agenda.id", agendaId)
evenement {
if (objet) {
eq("objet", objet)
// // cherche l'événement
// List<Evenement> recherche1 = tempsEvenementService.
// findAllEvenement(
-// agendaSE,
+// agendaSE.id,
// "Cours",
// dateHeureDebut.getTime(),
// dateHeureFin.getTime()
// // récupère 2 événements
// List<Evenement> recherche2 = tempsEvenementService.
// findAllEvenement(
-// agendaSE,
+// agendaSE.id,
// "Cours",
// dateHeureDebut.getTime(),
// dateHeureFin.getTime()
import org.lilie.services.eliot.absences.menu.description.MenuSousMenu
import org.lilie.services.eliot.absences.securite.DroitsService
import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.constantes.ConstDate
/**
* Classe ancêtre embarquant des traitements génériques à tous les controleurs d'absences
CodeComparator comparateurLogique = new CodeComparator()
- public static final String FORMAT_DATE = 'absences.format.dateJJMMAAAA'
- public static final String FORMAT_HEURE = 'absences.format.heureHHMM'
-
final static Long VALEUR_TOUS = -1
* @return une String
*/
protected String formateDate(Date date) {
- String format = message(code: FORMAT_DATE)
- SimpleDateFormat formatDate = new SimpleDateFormat(format, Locale.FRANCE)
+ SimpleDateFormat formatDate = new SimpleDateFormat(ConstDate.DATE_JJMMAAA, Locale.FRANCE)
return formatDate.format(date)
}
* @return une String
*/
protected String formateHeure(Date date) {
- String format = message(code: FORMAT_HEURE)
- SimpleDateFormat formatHeure = new SimpleDateFormat(format, Locale.FRANCE)
+ SimpleDateFormat formatHeure = new SimpleDateFormat(ConstDate.HEURE_HHMM, Locale.FRANCE)
return formatHeure.format(date)
}
* @author bahj
*/
protected Date parseDateComplete(String dateComplete) {
- String parse = message(code: FORMAT_DATE) +
+ String parse = ConstDate.DATE_JJMMAAA +
',' +
- message(code: FORMAT_HEURE)
+ ConstDate.HEURE_HHMM
SimpleDateFormat formatDate = new SimpleDateFormat(parse, Locale.FRANCE)
return formatDate.parse(dateComplete)
}
* @author bahj
*/
protected Date parseDate(String date) {
- String parse = message(code: FORMAT_DATE)
- SimpleDateFormat formatDate = new SimpleDateFormat(parse, Locale.FRANCE)
+ SimpleDateFormat formatDate = new SimpleDateFormat(ConstDate.DATE_JJMMAAA, Locale.FRANCE)
return formatDate.parse(date)
}
import org.lilie.services.eliot.applications.absences.PriseEnCompteMotif
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstDate
class ConsultationController extends AbstractConsultationController {
def nbLignesParPages = ConfigurationHolder.config.eliot.
absences.bilan.nombreLignesParPage
- final static String MSG_FORMAT_HEURE_HHMM = 'absences.format.heureHHMM'
- final static String MSG_FORMAT_DATE_JJMMAAAA = 'absences.format.dateJJMMAAAA'
-
-
def multicriteresIndex = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_CONSULT_DIR)
// construction du modèle
* @author jbui
*/
private ResultatConsultation traduitResultatBilan(ResultatConsultation liste) {
- String formatDate = message(code: MSG_FORMAT_DATE_JJMMAAAA)
- SimpleDateFormat simpleDateFormatDate = new SimpleDateFormat(formatDate,
+ SimpleDateFormat simpleDateFormatDate = new SimpleDateFormat(ConstDate.DATE_JJMMAAA,
Locale.FRANCE)
- String formatHeure = message(code: MSG_FORMAT_HEURE_HHMM)
- SimpleDateFormat simpleDateFormatHeure = new SimpleDateFormat(formatHeure,
+ SimpleDateFormat simpleDateFormatHeure = new SimpleDateFormat(ConstDate.HEURE_HHMM,
Locale.FRANCE)
liste.lignes.each {
LigneConsultation it ->
getPreferencesEtablissementCourant()
).id
List resultats = []
- String formatDate = message(code: MSG_FORMAT_DATE_JJMMAAAA)
- SimpleDateFormat simpleDateFormatDate = new SimpleDateFormat(formatDate,
+ SimpleDateFormat simpleDateFormatDate = new SimpleDateFormat(ConstDate.DATE_JJMMAAA,
Locale.FRANCE)
lstLignes.each { AppelLigne appelLigne ->
resultats << new ConsultationParentEleveInfo(
import org.lilie.services.eliot.urllabel.UrlLabelInfo
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstDate
/**
* Contrôleur de consultation des appels oubliés
private Closure closureFormatHeure = {
Date heureDebut, Date heureFin ->
- SimpleDateFormat sdf = new SimpleDateFormat(
- message(code: 'absences.format.heureHHMM'), Locale.FRANCE)
+ SimpleDateFormat sdf = new SimpleDateFormat(ConstDate.HEURE_HHMM, Locale.FRANCE)
return message(code: 'absences.appels.oublies.heure', args: [
sdf.format(heureDebut),
sdf.format(heureFin)
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.urllabel.UrlLabelInfo
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstDate
/**
* Contrôleur de consultation des registre mensuel
break
}
SimpleDateFormat sdf = new SimpleDateFormat(
- (String) message(code: 'absences.format.dateDDMM'),
+ ConstDate.DATE_DDMM,
Locale.FRANCE
)
return result + ' ' + sdf.format(jour)
private toolTipDetail = {
DetailPlageInfo detail ->
SimpleDateFormat sdf = new SimpleDateFormat(
- (String) message(code: 'absences.format.heureHHMM'),
+ ConstDate.HEURE_HHMM,
Locale.FRANCE
)
String result = ''
import org.lilie.services.eliot.absences.Sanction
import org.lilie.services.eliot.absences.AbstractAbsencesController
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author bahj
private SimpleDateFormat getSimpleDateFormatJourHeure() {
SimpleDateFormat sdf = new SimpleDateFormat(
- message(code: 'absences.format.dateJJMMAAAA') + ' ' +
- message(code: 'absences.format.heureHHMM'), Locale.FRANCE
+ ConstDate.DATE_JJMMAAA + ' ' +
+ ConstDate.HEURE_HHMM, Locale.FRANCE
)
return sdf
}
import org.lilie.services.eliot.absences.AppelLigne
import org.lilie.services.eliot.temps.Time
import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeService
-import org.lilie.services.eliot.temps.Agenda
-import org.lilie.services.eliot.temps.TempsAgendaService
import org.lilie.services.eliot.temps.Evenement
-import org.lilie.services.eliot.temps.TempsEvenementService
-import org.lilie.services.eliot.temps.DateUtil
-import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.absences.saisie.absencejournee.AbsenceJourneeInfo
import org.lilie.services.eliot.absences.PlageHoraire
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.absences.saisie.appel.AppelTemporaire
import org.lilie.services.eliot.absences.saisie.appel.AppelEleveMarshallerService
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
-import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTemps
-import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTempsService
-import org.lilie.services.eliot.absences.saisie.emploidutemps.EmploiDuTempsMarshallerService
-import org.hibernate.FetchMode
import org.lilie.services.eliot.absences.saisie.appel.AppelSaisieAccueilService
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.securite.Autorite
+import org.lilie.services.eliot.constantes.ConstDate
+import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
+import org.lilie.services.eliot.securite.impl.Autorite
import java.util.regex.Pattern
AppelService appelService
AbsenceJourneeService absenceJourneeService
- TempsAgendaService tempsAgendaService
- TempsEvenementService tempsEvenementService
- LocalStructureEnseignementService localStructureEnseignementService
PlageHoraireService plageHoraireService
AppelEleveMarshallerService appelEleveMarshallerService
- EmploiDuTempsService emploiDuTempsService
- EmploiDuTempsMarshallerService emploiDuTempsMarshallerService
AppelSaisieAccueilService appelSaisieAccueilService
+ CalendrierService calendrierService
private static final String OPTION_SAISIE = 'optionSaisie'
private static final String ID_ELEVE = 'eleveId'
private static final Pattern PATTERN_APPEL_ID = ~/^appel(\d*)$/
private static final String APPEL_ID = 'appelId'
- // sauvegarde dans la session avant sont enregistrement dans la base
-
def indexCpe = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_APPELS)
Map modele = prepareBaseModele(Page.SAISIE_ABSENCES_CPE)
+ // valeurs constantes
+ modele.isSaisieHorsEDT = true
+ modele.actionNom = 'indexCpe'
+
PreferencesEtablissementAbsences prefEtab = getPreferencesEtablissementCourant()
+ Etablissement etablissement = etablissementCourant()
+ Autorite autorite = getSecuriteSession().defaultAutorite
+
+ // reprise de paramètres
+ modele.enseignantId = params.enseignantId
+ modele.eleveSelectionneId = params.eleveSelectionneId
+
+ modele.affichageEdt = prefEtab.affichageEdt
// est ce qu'il faut préciser l'année scolaire
- Calendrier calendrier = calendrierSessionService.getCalendrierForEtablissement(prefEtab.etablissement)
+ Calendrier calendrier = calendrierService.getCalendrierForEtablissement(prefEtab.etablissement)
if (!calendrier) {
forward(
action: 'multicriteresIndex',
return
}
- def date = params.date
-
- Date dateJour = date ? parseDate(date) : null
- if (!dateJour) {
- dateJour = new Date()
- if (dateJour < calendrier.premierJour ||
- dateJour > calendrier.dernierJour
- ) {
- dateJour = calendrier.premierJour
- }
- }
-
- modele = appelSaisieAccueilService.marshallMotifs(modele, prefEtab)
-
+ // récupération de la structure d'enseignement
def structureEnseignementId = params.structureEnseignementId
- StructureEnseignement structure = null
-
- if (structureEnseignementId) {
-
- structure = StructureEnseignement.findById(
- structureEnseignementId,
- [fetch: ['groupes': FetchMode.JOIN]]
- )
-
- }
-
- boolean affichageEdt = prefEtab.affichageEdt
-
- if (affichageEdt && structure) {
-
- modele = findInfosEmploiDuTemps(
- modele,
- structure,
- dateJour
- )
-
- }
-
- modele = appelSaisieAccueilService.findInfosGrilleHoraire(
+ modele = marshallTemps(
getSecuriteSession(),
- AppelTemporaire.charge(session),
+ modele,
prefEtab,
- structure,
- dateJour,
- modele
+ AppelTemporaire.charge(session),
+ calendrier,
+ structureEnseignementId
)
- Map anneeScolaire = [
- debutAnneeScolaire: formateDate(calendrier.premierJour),
- finAnneeScolaire: formateDate(calendrier.dernierJour)
- ]
-
- modele.anneeScolaire = anneeScolaire as JSON
- modele.date = formateDate(dateJour)
-
- List<String> lstJoursFermetureHebdo = getListeJoursFermetureHebdo(prefEtab)
- modele.disabledDays = lstJoursFermetureHebdo
- modele.joursFermetureHebdo = (lstJoursFermetureHebdo.size() > 0 ?
- (lstJoursFermetureHebdo as JSON) : null)
+ modele = appelSaisieAccueilService.marshallListesStructures(
+ modele,
+ autorite,
+ etablissement,
+ structureEnseignementId
+ )
- modele = getInfosStructures(
+ modele = appelSaisieAccueilService.marshallMotifs(
modele,
- structureEnseignementId)
+ prefEtab
+ )
+
+ modele = marshallAnneeScolaire(modele, calendrier)
modele.enseignants = getListeEnseignantForEtablissementCourant() as JSON
- modele.enseignantId = params.enseignantId
- modele.affichageEdt = prefEtab.affichageEdt
- modele.eleveSelectionneId = params.eleveSelectionneId
+ modele = appelSaisieAccueilService.marshallJoursFermeturesHebdo(
+ modele,
+ prefEtab
+ )
- modele.isSaisieHorsEDT = true
- modele.actionNom = 'indexCpe'
+ modele = appelSaisieAccueilService.marshallListeJoursFeries(
+ modele,
+ prefEtab
+ )
+
+ modele = appelSaisieAccueilService.marshallAllStructuresForEnseignantOrEtabCourant(
+ modele,
+ params,
+ etablissementCourant()
+ )
modele[OPTION_SAISIE] = flash[OPTION_SAISIE] ?: message(code: "absences.formulaire.option.valable")
)
}
- private Map getInfosStructures(Map modele, def structureEnseignementId) {
-
- Etablissement etablissement = etablissementCourant()
-
- Autorite autorite = getSecuriteSession().defaultAutorite
-
- List<Map> structures =
- localStructureEnseignementService.findAllStructureEnseignementLight(
- autorite,
- etablissement
- )
-
- List<StructureEnseignement> structuresDirection = []
- List<StructureEnseignement> structuresEnseignant = []
-
- structures.each{
- StructureEnseignement structureEnseignement = new StructureEnseignement()
- structureEnseignement.id = it[0]
- structureEnseignement.code = it[1]
-
- structuresDirection.add(structureEnseignement)
-
- if (it[2] != null){
- structuresEnseignant.add(structureEnseignement)
- }
- }
-
- modele.listeStructure = structuresEnseignant as JSON
- modele.structureEnseignementId = structureEnseignementId
- modele.structures = structuresDirection as JSON
-
- return modele
- }
-
-
- private Map findInfosEmploiDuTemps(Map modele, StructureEnseignement structure, Date dateJour) {
-
- SimpleDateFormat sdfHeure = new SimpleDateFormat(
- (String) message(code: 'absences.format.heureHHMM'),
- Locale.FRANCE
- )
-
- List<PlageHoraire> plageHoraires = plageHoraireService.getPlageHoraires(
- this.preferencesEtablissementCourant
- )
- List<EmploiDuTemps> edt = emploiDuTempsService.findEmploiDuTemps(
- structure,
- dateJour,
- dateJour,
- plageHoraires
- )
-
- Map mapEmploiDuTemps = [:]
-
- edt.each {
- EmploiDuTemps emploiDuTemps ->
- mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] =
- emploiDuTempsMarshallerService.getLibelle(
- emploiDuTemps,
- sdfHeure,
- mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] as Map
- )
- }
-
- modele.emploiDuTemps = mapEmploiDuTemps as JSON
-
- return modele
- }
-
/**
* Page d'accueil de saisie des absences par Prof
* @author bahj
*/
def indexProf = {
- // toimp charge l'appel depuis la session
-
- verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE)
- // construction du modèle
- Map modele = prepareBaseModele(Page.SAISIE_ABSENCES_PROF)
- modele += getModeleSaisieAbsence(params)
- modele.actionNom = 'indexProf'
- Long evenementId = params.evenementId ?
- Long.parseLong(params.evenementId) :
- null
+ // toimpl charge l'appel depuis la session
- modele.evenementId = evenementId
- if (evenementId) {
- Evenement evt = Evenement.get(evenementId)
- modele.structureEnseignementCode =
- evt.enseignement.service.structureEnseignement.code
- } else {
- Long structureEnseignementId = (params.structureEnseignementId ?
- Long.parseLong(params.structureEnseignementId) : null)
- if (structureEnseignementId) {
- modele.structureEnseignementCode = StructureEnseignement.get(
- structureEnseignementId
- )?.code
- }
- }
- modele.enseignantNom = localPersonneService.getNomAffichage(
- getSecuriteSession().defaultAutorite
- )
- modele.modeSaisie = params.modeSaisie
- modele.listeCours = findCoursDuJour(parseDate(modele.date), getSecuriteSession()) as JSON
- modele.enseignantId = getSecuriteSession().defaultAutorite.id
- modele.isSaisieHorsEDT = getPreferencesEtablissementCourant().autoriseSaisieHorsEdt
-
- render(
- view: '/saisie/absence/prof/index',
- model: modele
- )
- }
-
- private Map getModeleSaisieAbsence(Map params, PreferencesEtablissementAbsences prefEtab = null) {
-
- Map results = [:]
+ verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_APPELS_EN_CLASSE)
- if (!prefEtab) {
- prefEtab = getPreferencesEtablissementCourant()
- }
+ registerTime()
- def date = params.date
- def structureEnseignementId = params.structureEnseignementId
- String idMotifSansMotif = motifService.getMotifSansMotif(prefEtab).id
+ // récupèration des données nécessaire auprès de la session
+ SecuriteSession securiteSession = getSecuriteSession()
+ Autorite enseignant = (Autorite) securiteSession.defaultAutorite
+ PreferencesEtablissementAbsences prefEtab = getPreferencesEtablissementCourant()
Calendrier calendrier =
- calendrierSessionService.getCalendrierForEtablissement(prefEtab.etablissement)
+ calendrierService.getCalendrierForEtablissement(prefEtab.etablissement)
- Map anneeScolaire = [
- debutAnneeScolaire: formateDate(calendrier.premierJour),
- finAnneeScolaire: formateDate(calendrier.dernierJour)
- ]
+ // construction du modèle
+ Map modele = prepareBaseModele(Page.SAISIE_ABSENCES_PROF)
- Date dateJour = date ? parseDate(date) : null
- if (!dateJour) {
- dateJour = new Date()
- if (dateJour < calendrier.premierJour ||
- dateJour > calendrier.dernierJour
- ) {
- dateJour = calendrier.premierJour
- }
- }
+ // valeurs constantes
+ modele.actionNom = 'indexProf'
+ modele.isSaisieHorsEDT = true
- registerTime()
+ // reprise de paramètres
+ modele.modeSaisie = params.modeSaisie
+ modele.isSaisieHorsEDT = prefEtab.autoriseSaisieHorsEdt
- StructureEnseignement structure = StructureEnseignement.findById(
- structureEnseignementId,
- [fetch: ['groupes': FetchMode.JOIN]]
- )
+ modele = marshallEvenementStructure(modele, params)
- List<PlageAppelInfo> lst = appelService.getGrilleHoraire(
- getSecuriteSession(),
- prefEtab,
- structure,
- dateJour
- )
+ modele = marshallEnseignant(modele, enseignant)
- boolean affichageEdt = prefEtab.affichageEdt
+ modele = marshallAnneeScolaire(modele, calendrier)
- if (affichageEdt && structure) {
- SimpleDateFormat sdfHeure = new SimpleDateFormat(
- (String) message(code: 'absences.format.heureHHMM'),
- Locale.FRANCE
- )
+ Date dateJour = appelSaisieAccueilService.parseDateJour(params, calendrier)
- List<PlageHoraire> plageHoraires = plageHoraireService.getPlageHoraires(
- this.preferencesEtablissementCourant
- )
- List<EmploiDuTemps> edt = emploiDuTempsService.findEmploiDuTemps(
- structure,
- dateJour,
+ modele.listeCours =
+ appelSaisieAccueilService.findCoursDuJour(
dateJour,
- plageHoraires
- )
-
- Map mapEmploiDuTemps = [:]
-
- edt.each {
- EmploiDuTemps emploiDuTemps ->
- mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] =
- emploiDuTempsMarshallerService.getLibelle(
- emploiDuTemps,
- sdfHeure,
- mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] as Map
- )
- }
+ securiteSession,
+ getPreferencesEtablissementCourant(),
+ etablissementCourantId()) as JSON
- results.emploiDuTemps = mapEmploiDuTemps as JSON
- }
+ def structureEnseignementId = params.structureEnseignementId
- appelSaisieAccueilService.ajouteAppelTemporaire(
+ modele = marshallTemps(
+ securiteSession,
+ modele,
+ prefEtab,
AppelTemporaire.charge(session),
- lst,
- structure,
- dateJour
+ calendrier,
+ structureEnseignementId
+ )
+
+ modele = appelSaisieAccueilService.marshallStructures(
+ modele,
+ enseignant,
+ etablissementCourant()
)
- List<String> lstJoursFermetureHebdo = getListeJoursFermetureHebdo(prefEtab)
+ modele = appelSaisieAccueilService.marshallMotifSansMotif(prefEtab, modele)
- List<StructureEnseignement> structures = localStructureEnseignementService.
- findAllStructureEnseignementByEnseignantAndEtablissement(
- getSecuriteSession().defaultAutorite,
- etablissementCourant()
- )
+ // jours de fermetures
+ modele = appelSaisieAccueilService.marshallJoursFermeturesHebdo(
+ modele,
+ prefEtab
+ )
- results += [
- anneeScolaire: anneeScolaire as JSON,
- date: formateDate(dateJour),
- idMotifSansMotif: idMotifSansMotif,
- listeStructure: structures.collect {[id: it.id, code: it.code]} as JSON,
- isSaisieHorsEDT: true,
- disabledDates: getListeJoursFeries(prefEtab),
- disabledDays: lstJoursFermetureHebdo,
- structureEnseignementId: structureEnseignementId,
- grilleHoraire: lst as JSON,
- joursFermetureHebdo: (lstJoursFermetureHebdo.size() > 0 ?
- (lstJoursFermetureHebdo as JSON) : null)
- ]
+ modele = appelSaisieAccueilService.marshallListeJoursFeries(
+ modele,
+ prefEtab
+ )
- return results
+ render(
+ view: '/saisie/absence/prof/index',
+ model: modele
+ )
}
@SuppressWarnings('CatchException')
def listeAppelsEleves = {
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE)
- JSON.registerObjectMarshaller(Time) {
- return it?.format(message(code: 'absences.format.heureHHMM'))
- }
+ registerTime()
StructureEnseignement structureEnseignement = StructureEnseignement.get(
params.structureEnseignementId
SimpleDateFormat sdfHeure = new SimpleDateFormat(
- (String) message(code: 'absences.format.heureHHMM'),
+ ConstDate.HEURE_HHMM,
Locale.FRANCE
)
def getPlagesHorairesAppel = {
SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy", Locale.FRANCE)
- JSON.registerObjectMarshaller(Time) {
- return it?.format(message(code: 'absences.format.heureHHMM'))
- }
+ registerTime()
Long structureEnseignementId = Long.parseLong(params.structureEnseignementId)
}
- private List<Map> findCoursDuJour(Date date, SecuriteSession securiteSession) {
- Calendar debutJour = Calendar.getInstance()
- debutJour.setTime(date)
- DateUtil.setDebutJour(debutJour)
- Calendar finJour = Calendar.getInstance()
- finJour.setTime(date)
- DateUtil.setFinJour(finJour)
- List<PlageHoraire> plages = plageHoraireService.getPlageHoraires(
- getPreferencesEtablissementCourant()
- )
-
-// Récupère tous les agendas de l'enseignant
- List<Agenda> agendasEnseignant =
- tempsAgendaService.findAllAgendaEnseignantByEnseignant(securiteSession)
- List<Evenement> evenements = []
-
-// Récupère les événements dans tous les agendas pour la date choisie
- agendasEnseignant.each { Agenda agenda ->
- evenements += tempsEvenementService.findAllEvenement(agenda,
- debutJour.getTime(),
- finJour.getTime(),
- true
- )
- }
-
-// Ordonner les événements selon la date de début
- evenements.sort { Evenement evenement ->
- evenement.dateHeureDebut
- }
-
- List result = []
- SimpleDateFormat sdfHeure = new SimpleDateFormat(
- (String) message(code: 'absences.format.heureHHMM'),
- Locale.FRANCE
- )
-
- evenements.each {
- Evenement evt ->
- if (evt.enseignement.service.structureEnseignement.etablissementId ==
- etablissementCourantId()) {
- String text = '(' + sdfHeure.format(evt.dateHeureDebut) + ' - ' +
- sdfHeure.format(evt.dateHeureFin) + ') ' +
- evt.enseignement.service.structureEnseignement.code + ' - ' +
- evt.enseignement.service.matiere.libelleCourt
-
- result << [
- evenementId: evt.id,
- structureId: evt.enseignement.service.structureEnseignementId,
- text: text,
- leaf: false,
- children: [],
- expanded: true,
- expandable: false,
- iconCls: 'cdt_icon',
- plagesIds: getPlagesForEvt(evt, plages)
- ]
- }
- }
- return result
- }
-
-/**
- * Retourne la liste des id de plage horaires concernées par l'évènement
- * @param evenement : l'évènement
- * @param plageHoraires : la liste des plages horaires de l'établissement
- * @return une List<Long>
- */
- private List<Long> getPlagesForEvt(Evenement evenement,
- List<PlageHoraire> plageHoraires) {
- List<Long> result = []
- Date debutEvt = DateUtil.getTime(evenement.dateHeureDebut)
- Date finEvt = DateUtil.getTime(evenement.dateHeureFin)
- plageHoraires.each {
- PlageHoraire plage ->
- Date debutPlage = DateUtil.getTime(plage.debut)
- Date finPlage = DateUtil.getTime(plage.fin)
- if ((debutEvt < finPlage) && (finEvt > debutPlage)) {
- result << plage.id
- }
- }
- return result
- }
-
-/**
- * Retourne une liste de jours fériés pour les vérouiller dans le calendrier
- * de saisie
- * @return une List<String>
- */
- private List<String> getListeJoursFeries(PreferencesEtablissementAbsences pref) {
-
- SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", Locale.FRANCE)
- List<String> result = []
- List<Date> dates = calendrierSessionService.getListeJoursFeriesForPreferencesEtablissement(
- pref
- )
- dates.each {
- Date date ->
- result << sdf.format(date)
- }
-
- return result
- }
-
/**
* Parse le JSON de modification de l'appel
* @param data : la map contenant les modifications à parser
private void registerTime() {
JSON.registerObjectMarshaller(Time) {
- return it?.format(message(code: 'absences.format.heureHHMM'))
+ return it?.format(ConstDate.HEURE_HHMM)
+ }
+
+ }
+
+ /**
+ * Enrichi le modèle avec les données de l'année scolaire
+ * @param modele modèle à enrichir
+ * @param calendrier calendrier concerné
+ * @return le modèle enrichi
+ */
+ public Map marshallAnneeScolaire(Map modele, Calendrier calendrier) {
+ Map anneeScolaire = [
+ debutAnneeScolaire: formateDate(calendrier.premierJour),
+ finAnneeScolaire: formateDate(calendrier.dernierJour)
+ ]
+
+ modele.anneeScolaire = anneeScolaire as JSON
+
+ return modele
+ }
+
+ /**
+ * Permet d'enrichir le modèle avec des informations liés au temps : date du jour, est ce que l'on a un
+ * emploi du temps, est ce que l'on doit afficher l'emploi du temps, données de l'emploi du temps, informations
+ * concernant la grille horaire
+ * @param securiteSession personne concerné
+ * @param modele modèle à enrichir
+ * @param prefEtab etablissement concerné
+ * @param appelTemporaire information d'appel enregistré en session
+ * @param calendrier calendrier courant
+ * @param structureEnseignementId : structure concerné par l'emploi du temps
+ * @return modèle enrichi
+ */
+ private Map marshallTemps(SecuriteSession securiteSession,
+ Map modele,
+ PreferencesEtablissementAbsences prefEtab,
+ AppelTemporaire appelTemporaire,
+ Calendrier calendrier,
+ structureEnseignementId) {
+
+ Date dateJour = appelSaisieAccueilService.parseDateJour(params, calendrier)
+
+ StructureEnseignement structure = appelSaisieAccueilService.parseStructureEnseignement(structureEnseignementId)
+
+ modele.date = formateDate(dateJour)
+
+ boolean affichageEdt = prefEtab.affichageEdt
+
+ if (affichageEdt && structure) {
+
+ modele = appelSaisieAccueilService.marshallEmploiDuTemps(
+ modele,
+ prefEtab,
+ structure,
+ dateJour
+ )
+
}
+ modele = appelSaisieAccueilService.marshallGrilleHoraire(
+ securiteSession,
+ modele,
+ prefEtab,
+ appelTemporaire,
+ structure,
+ dateJour
+ )
+ modele
+ }
+
+ private Map marshallEnseignant(Map modele, Autorite enseignant) {
+ modele.enseignantNom = localPersonneService.getNomAffichage(enseignant)
+ modele.enseignantId = enseignant.id
+ return modele
}
+ /**
+ * Enrichi le modèle avec le code de la structure passé en params et l'id de l'évènement
+ * @param modele : modèle à enrichir
+ * @param params : paramètre de l'action controlleur
+ * @return modèle enrichi
+ */
+ private Map marshallEvenementStructure(Map modele, Map params) {
+
+ if (params.structureEnseignementId) {
+ modele.structureEnseignementId = params.structureEnseignementId
+ }
+
+ Long evenementId = params.evenementId ?
+ Long.parseLong(params.evenementId) :
+ null
+
+ modele.evenementId = evenementId
+
+ if (evenementId) {
+ Evenement evt = Evenement.get(evenementId)
+ modele.structureEnseignementCode =
+ evt.enseignement.service.structureEnseignement.code
+ } else {
+ Long structureEnseignementId = (params.structureEnseignementId ?
+ Long.parseLong(params.structureEnseignementId) : null)
+ if (structureEnseignementId) {
+ modele.structureEnseignementCode = StructureEnseignement.get(
+ structureEnseignementId
+ )?.code
+ }
+ }
+ return modele
+ }
}
\ No newline at end of file
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.constantes.ConstController
import org.lilie.services.eliot.parametrages.calendrier.JourFerieInfo
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author jbui
Calendar cal = Calendar.getInstance()
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
SimpleDateFormat sdfDate = new SimpleDateFormat(
- ((String) message(code: 'absences.format.dateJJMMAAAA')),
+ ConstDate.DATE_JJMMAAA,
Locale.FRANCE
)
)
SimpleDateFormat sdf = new SimpleDateFormat(
- ((String) message(code: 'absences.format.heureHHMM')),
+ ConstDate.HEURE_HHMM,
Locale.FRANCE
)
import org.springframework.web.servlet.support.RequestContextUtils as RCU
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.constantes.ConstController
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author ywan
private SimpleDateFormat getSimpleDateFormatJour() {
SimpleDateFormat sdf = new SimpleDateFormat(
- message(code: 'absences.format.dateJJMMAAAA'), Locale.FRANCE)
+ ConstDate.DATE_JJMMAAA, Locale.FRANCE)
return sdf
}
import org.springframework.web.servlet.support.RequestContextUtils as RCU
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.constantes.ConstController
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author bahj
List<PlageHoraire> plages = plageHoraireService.getPlageHoraires(preferences)
SimpleDateFormat sdf = new SimpleDateFormat(
- message(code: 'absences.format.heureHHMM'), Locale.FRANCE)
+ ConstDate.HEURE_HHMM, Locale.FRANCE)
modele.listeHeureDebut = plages.collect {
PlageHoraire plage ->
modele.profils = enumMarshallerService.getEnumData(ProfilCenseur, locale) as JSON
List<PlageHoraire> plages = plageHoraireService.getPlageHoraires(preferences)
- SimpleDateFormat sdf = new SimpleDateFormat(
- message(code: 'absences.format.heureHHMM'), Locale.FRANCE)
+ SimpleDateFormat sdf = new SimpleDateFormat(ConstDate.HEURE_HHMM, Locale.FRANCE)
modele.listeHeureDebut = getListeHeureDebut(plages, sdf) as JSON
modele.listeHeureFin = getListeHeureFin(plages, sdf) as JSON
verifieDroitFonctionnalite(AbsencesFonctionnalite.ABS_SAISIE_INC_PUN_SAN_CUD)
Map absenceInfo = (Map) JSON.parse(params.absenceInfo)
Personne eleve = getPersonneForIdAutorite(absenceInfo.autoriteEleveId)
- Date dateDebut = Date.parse(message(code: 'absences.format.dateJJMMAAAA'), absenceInfo.dateDebut)
- Date dateFin = Date.parse(message(code: 'absences.format.dateJJMMAAAA'), absenceInfo.dateFin)
- Date heureDebut = Date.parse(message(code: 'absences.format.heureHHMM'), absenceInfo.heureDebut)
- Date heureFin = Date.parse(message(code: 'absences.format.heureHHMM'), absenceInfo.heureFin)
+ Date dateDebut = Date.parse(ConstDate.DATE_JJMMAAA, absenceInfo.dateDebut)
+ Date dateFin = Date.parse(ConstDate.DATE_JJMMAAA, absenceInfo.dateFin)
+ Date heureDebut = Date.parse(ConstDate.HEURE_HHMM, absenceInfo.heureDebut)
+ Date heureFin = Date.parse(ConstDate.HEURE_HHMM, absenceInfo.heureFin)
Boolean eleveAbsent = consultationService.isEleveAbsentForPeriode(
eleve,
dateDebut,
import org.lilie.services.eliot.absences.saisie.dateadate.SaisieDateADateLigneParams
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
import org.lilie.services.eliot.constantes.ConstController
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author jcok
Calendar cal = Calendar.getInstance()
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
SimpleDateFormat sdfDate = new SimpleDateFormat(
- ((String) message(code: 'absences.format.dateJJMMAAAA')),
+ ConstDate.DATE_JJMMAAA,
Locale.FRANCE
)
)
SimpleDateFormat sdfHeure = new SimpleDateFormat(
- ((String) message(code: 'absences.format.heureHHMM')),
+ ConstDate.HEURE_HHMM,
Locale.FRANCE
)
SimpleDateFormat sdfDate = new SimpleDateFormat(
- ((String) message(code: 'absences.format.dateJJMMAAAA')),
+ ConstDate.DATE_JJMMAAA,
Locale.FRANCE
)
import org.lilie.services.eliot.urllabel.UrlLabelInfo
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.AbsencesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstDate
/**
* @author ywan
)
SimpleDateFormat sdf = new SimpleDateFormat(
- ((String) message(code: 'absences.format.dateJJMMAAAA')),
+ ConstDate.DATE_JJMMAAA,
Locale.FRANCE)
def anneeScolaire = [
debutAnneeScolaire: sdf.format(calendrier.premierJour),
)
SimpleDateFormat sdf = new SimpleDateFormat(
- ((String) message(code: 'absences.format.heureHHMM')),
+ ConstDate.HEURE_HHMM,
Locale.FRANCE
)
absences.menuContextuel.supprimer=Supprimer
absences.menuContextuel.inserer=Insérer
-absences.format.dateJJMMAAAA=dd/MM/yyyy
-absences.format.heureHHMM=HH:mm
-absences.format.dateDDMM=dd/MM
-
absences.appel.titreEvenement=Appel
absences.mois.janvier=Janvier
import java.text.SimpleDateFormat
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
+import org.lilie.services.eliot.parametrages.calendrier.PlageHoraireService
+import org.lilie.services.eliot.temps.TempsEvenementService
+import org.lilie.services.eliot.temps.TempsAgendaService
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.absences.PlageHoraire
+import org.lilie.services.eliot.temps.DateUtil
+import org.lilie.services.eliot.temps.Evenement
+import org.lilie.services.eliot.constantes.ConstDate
+import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTemps
+import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTempsService
+import org.lilie.services.eliot.absences.saisie.emploidutemps.EmploiDuTempsMarshallerService
+import org.lilie.services.eliot.scolarite.Calendrier
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.CodeComparator
/**
* Ce service permet de récupérer les données nécessaires pour les page accueil de la saisie d'absences
MotifService motifService
AppelService appelService
CalendrierService calendrierService
+ PlageHoraireService plageHoraireService
+ LocalPersonneService localPersonneService
+ TempsAgendaService tempsAgendaService
+ TempsEvenementService tempsEvenementService
+ EmploiDuTempsService emploiDuTempsService
+ EmploiDuTempsMarshallerService emploiDuTempsMarshallerService
+ LocalStructureEnseignementService localStructureEnseignementService
+
+ /**
+ * Permet de récupérer le motif sans motif dans le modele
+ * @param prefEtab : preference etab
+ * @param modele : modèle à enrichir
+ * @return modele enrichi
+ */
+ public Map marshallMotifSansMotif(PreferencesEtablissementAbsences prefEtab, Map modele) {
+ String idMotifSansMotif = motifService.getMotifSansMotif(prefEtab).id
+ modele.idMotifSansMotif = idMotifSansMotif
+ return modele
+ }
/**
* Récupération des motifs et groupes de motifs
groupesAvecMotifs
}
+ /**
+ * Permet de récupérer les informations concernant les motifs dans le modele
+ * @param modele modele à enrichir
+ * @param pref preference etablissement
+ * @return modele enrichi
+ */
public Map marshallMotifs(Map modele, PreferencesEtablissementAbsences pref) {
if (pref.groupeMotifs.size() == 0) {
return modele
}
- public Map findInfosGrilleHoraire(SecuriteSession securiteSession,
- AppelTemporaire appelTemporaire,
- PreferencesEtablissementAbsences prefEtab,
- StructureEnseignement structure,
- Date dateJour,
- Map modele) {
+ /**
+ * Retourne une liste de jours fériés pour les vérouiller dans le calendrier de saisie
+ * @param modele : modèle à enrichir
+ * @param pref par rapport à quel établissement
+ * @return modèle enrichi
+ */
+ public Map marshallListeJoursFeries(Map modele, PreferencesEtablissementAbsences pref) {
+ SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", Locale.FRANCE)
+ List<String> resultat = []
List<Date> dates = calendrierService.getListeJoursFeriesForPreferencesEtablissement(
- prefEtab
+ pref
)
+ dates.each {
+ Date date ->
+ resultat << sdf.format(date)
+ }
+
+ modele.disabledDates = resultat
+
+ return modele
+ }
+
+ /**
+ * Ajoute les données de structures à un modèle
+ * @param modele modèle à enrichir
+ * @param enseignant : pour un enseignant
+ * @param etablissement : sur un établissment
+ * @return modèle enrichi
+ */
+ public Map marshallStructures(Map modele, Autorite enseignant, Etablissement etablissement) {
+ List<StructureEnseignement> structures = localStructureEnseignementService.
+ findAllStructureEnseignementByEnseignantAndEtablissementLight(
+ enseignant,
+ etablissement
+ )
+ modele.listeStructure = structures.collect {[id: it.id, code: it.code]} as JSON
+
+ return modele
+ }
+
+ /**
+ * Enrichi le modèle avec les infos de grille horaire
+ * @param securiteSession : perso
+ * @param modele : modèle à enrichir
+ * @param prefEtab : etablissement concerné
+ * @param appelTemporaire : s'il y a un appel temporaire en cours on le passe
+ * @param structure : structure concerné
+ * @param dateJour : sur quel jour ,
+ * @return retourne le modèle enrichi
+ */
+ public Map marshallGrilleHoraire(SecuriteSession securiteSession,
+ Map modele,
+ PreferencesEtablissementAbsences prefEtab,
+ AppelTemporaire appelTemporaire,
+ StructureEnseignement structure,
+ Date dateJour
+ ) {
List<PlageAppelInfo> lst = appelService.getGrilleHoraire(
securiteSession,
dateJour
)
- SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", Locale.FRANCE)
- List<String> listeJoursFeries = []
- dates.each {
- Date date ->
- listeJoursFeries << sdf.format(date)
- }
-
- modele.disabledDates = listeJoursFeries
-
ajouteAppelTemporaire(
appelTemporaire,
lst,
return modele
}
-
- public def ajouteAppelTemporaire(
+ /**
+ * Ajoute les données d'un appel temporaire dans une liste de plage d'appel pour un jour
+ * @param appelTemporaire
+ * @param lst
+ * @param classe
+ * @param jour
+ */
+ private void ajouteAppelTemporaire(
AppelTemporaire appelTemporaire,
List<PlageAppelInfo> lst,
StructureEnseignement classe,
return calendar.getTime()
}
+
+ public List<Map> findCoursDuJour(Date date,
+ SecuriteSession securiteSession,
+ PreferencesEtablissementAbsences pref,
+ Long etablissementCourantId) {
+ Calendar debutJour = Calendar.getInstance()
+ debutJour.setTime(date)
+ DateUtil.setDebutJour(debutJour)
+ Calendar finJour = Calendar.getInstance()
+ finJour.setTime(date)
+ DateUtil.setFinJour(finJour)
+ List<PlageHoraire> plages = plageHoraireService.getPlageHoraires(pref)
+
+// Récupère tous les id d'agendas de l'enseignant
+ List<Long> agendasIdEnseignant =
+ tempsAgendaService.findAllAgendaIdEnseignantByEnseignant(securiteSession)
+ List<Evenement> evenements = []
+
+// Récupère les événements dans tous les agendas pour la date choisie
+ agendasIdEnseignant.each { Long id ->
+ evenements += tempsEvenementService.findAllEvenement(id,
+ debutJour.getTime(),
+ finJour.getTime(),
+ true
+ )
+ }
+
+// Ordonner les événements selon la date de début
+ evenements.sort { Evenement evenement ->
+ evenement.dateHeureDebut
+ }
+
+ List result = []
+ SimpleDateFormat sdfHeure = new SimpleDateFormat(ConstDate.HEURE_HHMM,
+ Locale.FRANCE
+ )
+
+ evenements.each {
+ Evenement evt ->
+ if (evt.enseignement.service.structureEnseignement.etablissementId ==
+ etablissementCourantId) {
+ String text = '(' + sdfHeure.format(evt.dateHeureDebut) + ' - ' +
+ sdfHeure.format(evt.dateHeureFin) + ') ' +
+ evt.enseignement.service.structureEnseignement.code + ' - ' +
+ evt.enseignement.service.matiere.libelleCourt
+
+ result << [
+ evenementId: evt.id,
+ structureId: evt.enseignement.service.structureEnseignementId,
+ text: text,
+ leaf: false,
+ children: [],
+ expanded: true,
+ expandable: false,
+ iconCls: 'cdt_icon',
+ plagesIds: getPlagesForEvt(evt, plages)
+ ]
+ }
+ }
+ return result
+ }
+
+ /**
+ * Retourne la liste des id de plage horaires concernées par l'évènement
+ * @param evenement : l'évènement
+ * @param plageHoraires : la liste des plages horaires de l'établissement
+ * @return une List<Long>
+ */
+ private List<Long> getPlagesForEvt(Evenement evenement,
+ List<PlageHoraire> plageHoraires) {
+ List<Long> result = []
+ Date debutEvt = DateUtil.getTime(evenement.dateHeureDebut)
+ Date finEvt = DateUtil.getTime(evenement.dateHeureFin)
+ plageHoraires.each {
+ PlageHoraire plage ->
+ Date debutPlage = DateUtil.getTime(plage.debut)
+ Date finPlage = DateUtil.getTime(plage.fin)
+ if ((debutEvt < finPlage) && (finEvt > debutPlage)) {
+ result << plage.id
+ }
+ }
+ return result
+ }
+
+ /**
+ * Permet de récupérer l'emploi du temps d'un structure pour un jour dans le modele
+ * @param modele modele à enrichir
+ * @param prefEtab preference etablissement pour l'etab concerné
+ * @param structure structure dans l'etab
+ * @param dateJour date recherché
+ * @return modele enrichi
+ */
+ public Map marshallEmploiDuTemps(Map modele, PreferencesEtablissementAbsences prefEtab, StructureEnseignement structure, Date dateJour) {
+
+ SimpleDateFormat sdfHeure = new SimpleDateFormat(
+ ConstDate.HEURE_HHMM,
+ Locale.FRANCE
+ )
+
+ List<PlageHoraire> plageHoraires = plageHoraireService.getPlageHoraires(
+ prefEtab
+ )
+
+ List<EmploiDuTemps> edt = emploiDuTempsService.findEmploiDuTemps(
+ structure,
+ dateJour,
+ dateJour,
+ plageHoraires
+ )
+
+ Map mapEmploiDuTemps = [:]
+
+ edt.each {
+ EmploiDuTemps emploiDuTemps ->
+ mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] =
+ emploiDuTempsMarshallerService.getLibelle(
+ emploiDuTemps,
+ sdfHeure,
+ mapEmploiDuTemps[emploiDuTemps.idPlageHoraire] as Map
+ )
+ }
+
+ modele.emploiDuTemps = mapEmploiDuTemps as JSON
+
+ return modele
+ }
+
+ /**
+ * Permet de parser le parametre structureEnseignementId issu des paramètres d'une action.
+ * @param structureEnseignementId : valeur issue de params
+ * @return si cela est possible structure associé à l'id sinon null
+ */
+ public StructureEnseignement parseStructureEnseignement(structureEnseignementId) {
+ StructureEnseignement structure = null
+ if (structureEnseignementId) {
+ structure = StructureEnseignement.findById(
+ structureEnseignementId,
+ [fetch: ['groupes': FetchMode.JOIN]]
+ )
+ }
+ structure
+ }
+
+ /**
+ * Détermine la date du jour par rapport aux params d'une action
+ * @param params : params de l'action
+ * @param calendrier : le calendrier courant
+ * @return : la date du jour
+ */
+ public Date parseDateJour(Map params, Calendrier calendrier) {
+ def date = params.date
+ Date dateJour = date ? parseDate(date) : null
+ if (!dateJour) {
+ dateJour = new Date()
+ if (dateJour < calendrier.premierJour ||
+ dateJour > calendrier.dernierJour
+ ) {
+ dateJour = calendrier.premierJour
+ }
+ }
+ dateJour
+ }
+
+ /**
+ * Récupère les listes de structures pour les combo dans le modèle
+ * @param modele modèle à enrichir
+ * @param enseignant : enseignant concerné (une des listes est celle des structures de l'enseignant)
+ * @param etablissement : etablissement concerné
+ * @param structureEnseignementId : id de structure à repasser au modèle
+ * @return
+ */
+ public Map marshallListesStructures(Map modele,
+ Autorite enseignant,
+ Etablissement etablissement,
+ def structureEnseignementId) {
+
+ List<Map> structures =
+ localStructureEnseignementService.findAllStructureEnseignementLight(
+ enseignant,
+ etablissement
+ )
+
+ List<StructureEnseignement> structuresDirection = []
+ List<StructureEnseignement> structuresEnseignant = []
+
+ structures.each {
+ StructureEnseignement structureEnseignement = new StructureEnseignement()
+ structureEnseignement.id = it[0]
+ structureEnseignement.code = it[1]
+
+ structuresDirection.add(structureEnseignement)
+
+ if (it[2] != null) {
+ structuresEnseignant.add(structureEnseignement)
+ }
+ }
+
+ modele.listeStructure = structuresEnseignant as JSON
+ modele.structureEnseignementId = structureEnseignementId
+ modele.structures = structuresDirection as JSON
+
+ return modele
+ }
+
+ /**
+ * Récupère les jours de fermetures dans le modèle
+ * @param modele modèle à enrichir
+ * @param prefEtab etablissement concerné
+ * @return le modèle enrichi
+ */
+ public Map marshallJoursFermeturesHebdo(Map modele, PreferencesEtablissementAbsences prefEtab) {
+ List<String> lstJoursFermetureHebdo = getListeJoursFermetureHebdo(prefEtab)
+ modele.disabledDays = lstJoursFermetureHebdo
+ modele.joursFermetureHebdo = (lstJoursFermetureHebdo.size() > 0 ?
+ (lstJoursFermetureHebdo as JSON) : null)
+ return modele
+ }
+
+ private List<String> getListeJoursFermetureHebdo(PreferencesEtablissementAbsences pref) {
+
+ Calendrier calendrier = calendrierService.
+ getCalendrierForEtablissement(pref.etablissement)
+ List<String> result = []
+ result << (calendrier.jourSemaineFerie % 7).toString()
+ return result
+
+ }
+
+ /**
+ * Parse une cahine du format dd/MM/yyyy en date
+ * @author bahj
+ */
+ private Date parseDate(String date) {
+ SimpleDateFormat formatDate = new SimpleDateFormat(ConstDate.DATE_JJMMAAA, Locale.FRANCE)
+ return formatDate.parse(date)
+ }
+
+ private static final CodeComparator comparateurLogique = new CodeComparator()
+
+ private List<StructureEnseignement> getAllStructuresForEnseignantOrEtabCourant(Map params, Etablissement etablissement) {
+ List<StructureEnseignement> structures
+ if (params.idEnseignant) {
+ Long enseignantId = Long.parseLong(params.idEnseignant)
+ Autorite autoriteEnseignant = Autorite.get(enseignantId)
+
+ structures = localStructureEnseignementService.
+ findAllStructureEnseignementByEnseignantAndEtablissement(
+ autoriteEnseignant,
+ etablissement
+ )
+ }
+ else {
+ structures = localStructureEnseignementService.findAllClasseByEtablissement(
+ etablissement,
+ "code"
+ )
+ }
+
+ // Trie logique
+ structures.sort {a, b -> comparateurLogique.compare(a.code, b.code)}
+ return structures
+ }
+
+ /**
+ * Enrichi le modele avec les informations de structures concernant un enseignant ou un etablissement
+ * @param modele modele à enrichir
+ * @param params paramètre de laction de controlleur
+ * @param etablissement etablissement courant
+ * @return le modèle enrichi
+ */
+ public Map marshallAllStructuresForEnseignantOrEtabCourant(Map modele, Map params, Etablissement etablissement) {
+
+ List<StructureEnseignement> structures =
+ getAllStructuresForEnseignantOrEtabCourant(
+ params,
+ etablissement
+ )
+
+ List structuresForJson = []
+
+ structures.each {
+ StructureEnseignement struct ->
+ structuresForJson.add([
+ id: struct.id,
+ code: struct.code
+ ])
+ }
+ modele.allStructures = structuresForJson as JSON
+
+ return modele
+ }
+
+
}
<eliotjs:varJson name="motifs" value="${motifs}"/>
<eliotjs:varJson name="enseignants" value="${enseignants}"/>
<eliotjs:varJson name="structures" value="${structures}"/>
+ <eliotjs:varJson name="allStructures" value="${allStructures}"/>
</eliotjs:ns>
<eliotjs:ns name="url">
<eliotjs:varLink name="urlIndex" action="indexCpe" controller="saisie"/>
- <eliotjs:varLink name="urlStoreComboStructureEnseignement"
- action="getAllStructureEnseignementEnCodeByEnseignantOrEtabCourant"
- controller="jsonScolarite"/>
<eliotjs:varLink name="urlStoreListePlagesHorairesDuJour"
action="listePlageDuJour"
controller="parametrageCalendrierHebdo"/>
</eliotjs:ns>
-
- <eliotjs:ns name="eliot.absences.commons.ComboStructureEnsControllerModele">
-
- <eliotjs:ns name="url">
- <eliotjs:varLink name="urlStoreComboStructureEnseignement"
- action="getAllStructureEnseignementEnCodeByEnseignantOrEtabCourant"
- controller="jsonScolarite"/>
- </eliotjs:ns>
-
- </eliotjs:ns>
-
-
<eliotjs:ns name="eliot.absences.commons.PageControllerModele">
<eliotjs:ns name="url">
}
};
-eliot.absences.commons.ComboStructureEnsControllerModele = {
- url : {
- urlStoreComboStructureEnseignement : undefined
- }
-};
-
eliot.absences.commons.ComboStructureEnseignementController = Ext.extend(Ext.util.Observable, {
/**
* Constructeur
// Store du combo de classe ou groupe
this.storeStructureEnseignement = new Ext.data.JsonStore({
- url : this.Modele.url.urlStoreComboStructureEnseignement,
baseParams: baseParams,
fields:[
{
type : 'string'
}
],
- data : []
+ data : this.Modele.data.allStructures
});
// Params du store
emploiDuTemps:undefined,
enseignants:undefined,
structures:undefined,
- motifs:undefined
+ motifs:undefined,
+ allStructures:undefined
}
};
// Store du combo de classe ou groupe
this.storeStructureEnseignement = new Ext.data.JsonStore({
- autoLoad:true,
- url:NameSpace.Modele.url.urlStoreComboStructureEnseignement,
baseParams:baseParams,
fields:[
{
data:NameSpace.Modele.data.structures
});
- this.storeStructureEnseignement.load();
-
},
observeEnseignantController:function (enseignantController) {
}
Collection<Evenement> allEvenement =
- tempsEvenementService.findAllEvenement(agenda, dateDebut, dateFin, false)
+ tempsEvenementService.findAllEvenement(agenda.id, dateDebut, dateFin, false)
return new AgendaExport(
agenda: agenda,
}
Collection<Evenement> allEvenement =
- tempsEvenementService.findAllEvenement(agenda, dateDebut, dateFin, false)
+ tempsEvenementService.findAllEvenement(agenda.id, dateDebut, dateFin, false)
return new AgendaExport(
agenda: agenda,
}
Collection<Evenement> allEvenement =
- tempsEvenementService.findAllEvenement(agenda, dateDebut, dateFin, false)
+ tempsEvenementService.findAllEvenement(agenda.id, dateDebut, dateFin, false)
return new AgendaExport(
agenda: agenda,
false
) >> agenda
tempsEvenementService.findAllEvenement(
- agenda,
+ agenda.id,
dateDebut,
dateFin,
false
false
) >> agenda
tempsEvenementService.findAllEvenement(
- agenda,
+ agenda.id,
dateDebut,
dateFin,
false
) >> agenda
tempsEvenementService.findAllEvenement(
- agenda,
+ agenda.id,
dateDebut,
dateFin,
false
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.ItemService
+import org.lilie.services.eliot.temps.Evenement
+import org.lilie.services.eliot.temps.TempsEvenementService
+import org.lilie.services.eliot.temps.Agenda
+import org.lilie.services.eliot.temps.TempsAgendaService
import org.lilie.services.eliot.temps.DateUtil
+import org.lilie.services.eliot.applications.agendatextes.RelServiceEvenement
+import org.lilie.services.eliot.applications.agendatextes.CahierTempsService
+import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.securite.impl.Item
import org.lilie.services.eliot.applications.textes.ActiviteParams
import org.lilie.services.eliot.textes.activite.TextesActiviteService
import org.lilie.services.eliot.textes.arbre.DossierInfoAffichage
import org.lilie.services.eliot.constantes.ConstFonct
-import org.hibernate.Session
-import org.hibernate.SQLQuery
-import org.lilie.services.eliot.temps.TypeAgenda
-import org.lilie.services.eliot.temps.TypeAgendaEnum
-import org.lilie.services.eliot.temps.TypeAgendaService
-import org.hibernate.Hibernate
class TextesCahierDeTextesService extends CahierDeTextesService {
TextesRelDossierAutorisationCahierService textesRelDossierAutorisationCahierService
TextesChapitreService textesChapitreService
RessourceService ressourceService
+ TempsEvenementService tempsEvenementService
+ TempsAgendaService tempsAgendaService
+ CahierTempsService cahierTempsService
ActiviteVisibiliteService activiteVisibiliteService
- TypeAgendaService typeAgendaService
static transactional = true
/**
* Récupération de tous les cahiers de textes consultables pour un utilisateur.
*/
- public List<CahierDeTextes> findAllCahiersConsultables(SecuriteSession securiteSession) {
+ List<CahierDeTextes> findAllCahiersConsultables(SecuriteSession securiteSession) {
return CahierDeTextes.withCriteria {
'item' {
and {
}
}
+ /**
+ * Récupération de toutes les matières correspondants aux cahiers de textes
+ * donnés. On préfère faire une seule requête plutôt que traverser
+ * les relations.
+ * @param cahiers la liste des cahiers (en général des cahiers de service)
+ * @return la liste des matières correspondant aux cahiers donnés
+ */
+ Collection<Matiere> getMatieres(Collection<CahierDeTextes> cahiers) {
+ List<Matiere> matieres = []
+ if (cahiers) {
+ Map params = [cdts: cahiers*.id.toList()]
+ matieres =
+ Matiere.executeQuery(TextesCahierDeTextesServiceHql.HQL_GET_MATIERES, params)
+ }
+ return matieres
+ }
+
/**
* Récupération de toutes les matières (id et libelleLong) correspondants aux cahiers de textes
* donnés. On préfère faire une seule requête plutôt que traverser
* chapitres du cahierDeTextes
* @return un ChapitreCourt
*/
- private ChapitreCourt getStructureChapitre(Chapitre chapitre, List<Chapitre> chapitres) {
+ ChapitreCourt getStructureChapitre(Chapitre chapitre, List<Chapitre> chapitres) {
ChapitreCourt result = new ChapitreCourt(
id: chapitre.id,
nom: chapitre.nom
return result
}
+ /**
+ * Récupèration de cahier de textes de services par emploi du temps
+ */
+ Collection<RelCahierEvenement> findAllCdtServiceByJour(SecuriteSession securiteSession,
+ ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
+ Calendar dateSelectionnee
+ ) {
+ List<RelCahierEvenement> relsCahierEvenement = []
+ List<Evenement> evenements = []
+ List<RelServiceEvenement> relServiceEvenements
+
+ Calendar dateHeureDebutJour = Calendar.getInstance()
+ dateHeureDebutJour.setTime(dateSelectionnee.getTime())
+
+ Calendar dateHeureFinJour = Calendar.getInstance()
+ dateHeureFinJour.setTime(dateSelectionnee.getTime())
+
+ DateUtil.setDebutJour(dateHeureDebutJour)
+ DateUtil.setFinJour(dateHeureFinJour)
+
+ // Récupère tous les agendas de l'enseignant
+ List<Agenda> agendasEnseignant =
+ tempsAgendaService.findAllAgendaEnseignantByEnseignant(securiteSession)
+
+ // Récupère les événements dans tous les agendas pour la date choisie
+ agendasEnseignant.each { Agenda agenda ->
+ evenements += tempsEvenementService.findAllEvenement(agenda.id,
+ dateHeureDebutJour.getTime(),
+ dateHeureFinJour.getTime(),
+ true
+ )
+ }
+
+ // Ordonner les événements selon la date de début
+ evenements.sort { Evenement evenement ->
+ evenement.dateHeureDebut
+ }
+
+ // Récupère l'objet RelServiceEvenement à partir de tous les événements
+ relServiceEvenements = cahierTempsService.
+ getServicesFromEvenements(evenements)
+
+ // Récupère les CahierEvenementInfo à partir de tous les ServiceEvenementInfo
+ relServiceEvenements.each { RelServiceEvenement rel ->
+
+ // récupérer le cahier de textes de service par (service & prof)
+ CahierDeTextes cahierDeTextes =
+ acteurAllCahierPersonnalise.findCahierDeTextesByService(
+ rel.service
+ )?.cahierDeTextes
+
+
+ if (cahierDeTextes) {
+ // Construire le CahierEvenementInfo
+ RelCahierEvenement relCahierEvenement = new RelCahierEvenement(
+ cahierDeTextes: cahierDeTextes,
+ evenement: rel.evenement
+ )
+ // ajouter CahierEvenementInfo dans la liste
+ relsCahierEvenement.add(relCahierEvenement)
+ }
+ }
+ // Retourne les CahierEvenementInfo
+ return relsCahierEvenement
+ }
+
/**
* Déplacement d'un cahier de textes de son dossier vers un dossier cible.
* @return true si l'opération a été effectuée avec succès