--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.scolarite.structureenseignement
+
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordParams
+import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBord
+import org.hibernate.SQLQuery
+import org.hibernate.Hibernate
+import org.lilie.services.eliot.annuaire.Fonction
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.annuaire.TypeStructureEnum
+import org.lilie.services.eliot.requetage.RequetageUtilsService
+
+/**
+ * Personnes associés aux structures d'enseignement
+ */
+class LocalStructureEnseignementPersonneService extends RequetageUtilsService {
+
+ /**
+ * Retourne les "Personne" de tous les élèves appartenant à une des classes
+ * @return une List<Personne>
+ */
+ public List<Personne> findAllPersonnesElevesForAllStructures(Set<StructureEnseignement> structures) {
+ String hql = """select pps.personne
+ from PersonneProprietesScolarite pps
+ inner join fetch pps.personne.autorite
+ where pps.proprietesScolarite.fonction.code = :fonctionCode
+ and pps.proprietesScolarite.structureEnseignement in (:structures)
+ and pps.estActive = true
+ """
+ return Personne.executeQuery(hql, [
+ fonctionCode: org.lilie.services.eliot.annuaire.FonctionEnum.ELEVE.getCode(),
+ structures: structures.toList()
+ ])
+ }
+
+ /**
+ * Liste les élèves avec leur dernière classe dans l'établissement
+ */
+ public List<Map> listeElevesDerniereClasseEtab(List<Long> autoriteIds,
+ TableauDeBordParams criteres) {
+ if (!autoriteIds) {
+ return []
+ }
+
+ def sql =
+ LocalStructureEnseignementServiceHql.SQL_ELEVES_DERNIERE_CLASSE_ETAB
+
+ String sensTri = criteres.sortAsc ? "asc" : "desc"
+
+ switch (criteres.sortField) {
+ case TableauDeBord.FIELD_DIVISION_CODE:
+ sql <<= " order by se.code ${sensTri}, p.nom ${sensTri}, p.prenom ${sensTri}"
+ break
+ case TableauDeBord.FIELD_NOM_PRENOM:
+ sql <<= " order by p.nom ${sensTri}, p.prenom ${sensTri}"
+ break
+ }
+
+ sql <<= " offset :offset"
+ if (criteres.limit > 0) {
+ sql <<= " limit :limit"
+ }
+
+ SQLQuery sqlQuery = prepareRequete(sql.toString())
+ sqlQuery.addEntity("p", Personne)
+ sqlQuery.addScalar('codeClasse', Hibernate.STRING)
+
+ sqlQuery.setParameterList("autoriteIds", autoriteIds)
+ sqlQuery.setLong("eleveFonctionId",
+ Fonction.findByCode(FonctionEnum.ELEVE.getCode(), [cache: true]).id)
+ sqlQuery.setLong("etablissementId", criteres.classes[0].etablissementId)
+ sqlQuery.setString("typeClasse", TypeStructureEnum.CLASSE.name())
+ if (criteres.limit > 0) {
+ sqlQuery.setInteger("limit", criteres.limit)
+ }
+ sqlQuery.setInteger("offset", criteres.start)
+
+ sqlQuery.list().collect {
+ Personne eleve = it[0]
+ String codeClasse = it[1]
+ [
+ id: eleve.id,
+ libelle: eleve.nomAffichage(),
+ autoriteId: eleve.autoriteId,
+ classe: codeClasse
+ ]
+ }
+ }
+
+ public List listeElevesActifs(StructureEnseignement structureEnseignement) {
+
+ List<Personne> eleves =
+ findAllPersonnesElevesForAllStructures([structureEnseignement] as Set)
+ eleves.collect { Personne eleve ->
+ [
+ id: eleve.id,
+ libelle: eleve.nomAffichage(),
+ actif: true
+ ]
+ }.sort {it.libelle}
+
+ }
+
+ /**
+ * Liste les élèves actifs ou sortants d'une liste de classes
+ */
+ public List<Map> listeElevesActifsOuSortants(List<Long> classeIds) {
+
+ String sql = LocalStructureEnseignementServiceHql.SQL_ELEVES_ACTIFS_OU_SORTANTS
+
+ SQLQuery sqlQuery = prepareRequete(sql)
+ sqlQuery.addEntity("p", Personne)
+ sqlQuery.addScalar('actif', Hibernate.BOOLEAN)
+ sqlQuery.addScalar('codeClasse', Hibernate.STRING)
+
+ sqlQuery.setParameterList("classeIds", classeIds)
+ sqlQuery.setLong("eleveFonctionId",
+ Fonction.findByCode(FonctionEnum.ELEVE.getCode(), [cache: true]).id)
+
+ sqlQuery.list().collect {
+ Personne eleve = it[0]
+ Boolean actif = it[1]
+ String codeClasse = it[2]
+ [
+ id: eleve.id,
+ libelle: eleve.nomAffichage(),
+ actif: actif,
+ autoriteId: eleve.autoriteId,
+ classe: codeClasse
+ ]
+ }
+ }
+
+}
package org.lilie.services.eliot.scolarite.structureenseignement
-import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBord
-import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordParams
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.hibernate.FetchMode
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteHqlFactory
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.PeriodeService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
* @return <code>true</code> si l'élève appartient à la structure,
* <code>false</code> sinon
*/
- boolean isEleveDansStructureEnseignement(Personne eleve,
- StructureEnseignement structureEnseignement,
- Boolean actif = true) {
+ public boolean isEleveDansStructureEnseignement(Personne eleve,
+ StructureEnseignement structureEnseignement,
+ Boolean actif = true) {
List<StructureEnseignement> rep =
(List<StructureEnseignement>) PersonneProprietesScolarite.createCriteria().list {
* @return liste des structures liées à une classe avec la classe dans la liste aussi.
* @author msan
*/
- List<StructureEnseignement> findAllStructuresForClasse(StructureEnseignement classe)
+ public List<StructureEnseignement> findAllStructuresForClasse(StructureEnseignement classe)
throws InvalidParameterException {
if (!classe || !classe.isClasse()) {
throw new InvalidParameterException("Structure $classe passée en parameter n'est pas une classe")
* Retourne les "Autorite" de tous les élèves appartenant à une des structures
* @return une List<Autorite>
*/
- List<Autorite> findAllAutoritesElevesForAllStructures(
+ public List<Autorite> findAllAutoritesElevesForAllStructures(
Set<StructureEnseignement> structures,
Boolean elevesActifsSeulement = true,
Boolean autoriteIdsSeulement = false
])
}
- /**
- * Retourne les "Personne" de tous les élèves appartenant à une des classes
- * @return une List<Personne>
- */
- List<Personne> findAllPersonnesElevesForAllStructures(Set<StructureEnseignement> structures) {
- String hql = """select pps.personne
- from PersonneProprietesScolarite pps
- inner join fetch pps.personne.autorite
- where pps.proprietesScolarite.fonction.code = :fonctionCode
- and pps.proprietesScolarite.structureEnseignement in (:structures)
- and pps.estActive = true
- """
- return Personne.executeQuery(hql, [
- fonctionCode: FonctionEnum.ELEVE.getCode(),
- structures: structures.toList()
- ])
- }
-
/**
* Retourne les "Personne" de tous les élèves appartenant à une des classes avec la classe où il se trouve
* @return une List<<PPS, StructureEnseignement>>
} as Boolean
}
- /**
- * Liste les élèves actifs ou sortants d'une liste de classes
- */
- public List<Map> listeElevesActifsOuSortants(List<Long> classeIds) {
-
- String sql = LocalStructureEnseignementServiceHql.SQL_ELEVES_ACTIFS_OU_SORTANTS
-
- SQLQuery sqlQuery = prepareRequete(sql)
- sqlQuery.addEntity("p", Personne)
- sqlQuery.addScalar('actif', Hibernate.BOOLEAN)
- sqlQuery.addScalar('codeClasse', Hibernate.STRING)
-
- sqlQuery.setParameterList("classeIds", classeIds)
- sqlQuery.setLong("eleveFonctionId",
- Fonction.findByCode(FonctionEnum.ELEVE.getCode(), [cache: true]).id)
-
- sqlQuery.list().collect {
- Personne eleve = it[0]
- Boolean actif = it[1]
- String codeClasse = it[2]
- [
- id: eleve.id,
- libelle: eleve.nomAffichage(),
- actif: actif,
- autoriteId: eleve.autoriteId,
- classe: codeClasse
- ]
- }
- }
-
- /**
- * Liste les élèves avec leur dernière classe dans l'établissement
- */
- public List<Map> listeElevesDerniereClasseEtab(List<Long> autoriteIds,
- TableauDeBordParams criteres) {
- if (!autoriteIds) {
- return []
- }
-
- def sql =
- LocalStructureEnseignementServiceHql.SQL_ELEVES_DERNIERE_CLASSE_ETAB
-
- String sensTri = criteres.sortAsc ? "asc" : "desc"
-
- switch (criteres.sortField) {
- case TableauDeBord.FIELD_DIVISION_CODE:
- sql <<= " order by se.code ${sensTri}, p.nom ${sensTri}, p.prenom ${sensTri}"
- break
- case TableauDeBord.FIELD_NOM_PRENOM:
- sql <<= " order by p.nom ${sensTri}, p.prenom ${sensTri}"
- break
- }
-
- sql <<= " offset :offset"
- if (criteres.limit > 0) {
- sql <<= " limit :limit"
- }
-
- SQLQuery sqlQuery = prepareRequete(sql.toString())
- sqlQuery.addEntity("p", Personne)
- sqlQuery.addScalar('codeClasse', Hibernate.STRING)
-
- sqlQuery.setParameterList("autoriteIds", autoriteIds)
- sqlQuery.setLong("eleveFonctionId",
- Fonction.findByCode(FonctionEnum.ELEVE.getCode(), [cache: true]).id)
- sqlQuery.setLong("etablissementId", criteres.classes[0].etablissementId)
- sqlQuery.setString("typeClasse", TypeStructureEnum.CLASSE.name())
- if (criteres.limit > 0) {
- sqlQuery.setInteger("limit", criteres.limit)
- }
- sqlQuery.setInteger("offset", criteres.start)
-
- sqlQuery.list().collect {
- Personne eleve = it[0]
- String codeClasse = it[1]
- [
- id: eleve.id,
- libelle: eleve.nomAffichage(),
- autoriteId: eleve.autoriteId,
- classe: codeClasse
- ]
- }
- }
-
- List listeElevesActifs(StructureEnseignement structureEnseignement) {
- List<Personne> eleves =
- findAllPersonnesElevesForAllStructures([structureEnseignement] as Set)
- eleves.collect { Personne eleve ->
- [
- id: eleve.id,
- libelle: eleve.nomAffichage(),
- actif: true
- ]
- }.sort {it.libelle}
- }
-
boolean isEleveSortant(Long eleveId) {
Long result = (Long) PersonneProprietesScolarite.executeQuery(
LocalStructureEnseignementServiceHql.HQL_IS_ELEVE_SORTANT,
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.annuaire.Niveau
import org.junit.Ignore
-
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.constantes.ConstFonct
import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementEnseignantService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
/**
* Tests : LocalStructureEnseignementService
LocalResponsableService localResponsableService
LocalClasseService localClasseService
LocalStructureEnseignementEnseignantService localStructureEnseignementEnseignantService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
Etablissement etablissement1
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
void testFindAllPersonnesElevesForAllStructures() {
- List liste1 = localStructureEnseignementService.findAllPersonnesElevesForAllStructures(
+ List liste1 = localStructureEnseignementPersonneService.findAllPersonnesElevesForAllStructures(
(Set) [
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1),
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_2)
)
}
- LocalClasseService localClasseService
-
-
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
void testFindClasseForElevePersonne() {
import org.lilie.services.eliot.scolarite.LocalResponsableService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementEnseignantService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class JsonScolariteController extends AbstractAbsencesController {
LocalResponsableService localResponsableService
LocalClasseService localClasseService
LocalStructureEnseignementEnseignantService localStructureEnseignementEnseignantService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
/**
* Retourne la liste des enseignants de l'établissement courant
)
if (structureEnseignement) {
- result = localStructureEnseignementService.listeElevesActifsOuSortants([structureEnseignement.id])
+ result = localStructureEnseignementPersonneService.listeElevesActifsOuSortants([structureEnseignement.id])
}
render result as JSON
if (structureEnseignement) {
result =
- localStructureEnseignementService.listeElevesActifs(structureEnseignement)
+ localStructureEnseignementPersonneService.listeElevesActifs(structureEnseignement)
}
render result as JSON
import org.lilie.services.eliot.absences.statistiques.mensuelle.StatsMensuellesParams
import org.lilie.services.eliot.applications.absences.PriseEnCompteMotif
import org.springframework.context.NoSuchMessageException
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class ArchivageRequetageService {
LocalStructureEnseignementService localStructureEnseignementService
AbsencesStatsMensuellesService absencesStatsMensuellesService
StatsMarshallerService statsMarshallerService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
public JSON registreAppel(SecuriteSession securiteSession,
Etablissement etablissement,
return sanctionsConsultationInfo
}
-
private StatsMensuellesParams getStatsMensuellesParams(
Etablissement etablissement,
PreferencesEtablissementAbsences pref,
Date dateFin,
ModeCalcul modeCalcul) {
- List<Map> listeElevesActifsOuSortant = localStructureEnseignementService.listeElevesActifsOuSortants([classeId])
+ List<Map> listeElevesActifsOuSortant = localStructureEnseignementPersonneService.listeElevesActifsOuSortants([classeId])
List<Long> eleveIds = []
listeElevesActifsOuSortant.each {
import org.lilie.services.eliot.absences.PlageHoraire
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.absences.consultation.controller.LigneResultatRequeteConsultation
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class ConsultationService extends AbstractConsultationService {
FonctionAnnuaireService fonctionAnnuaireService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
+
static transactional = true
* @param acteur : l'acteur qui lance la recherche
* @return une map contenant les résultats
*/
- ResultatConsultation listeDesAbsencesEtRetards(BilanCriteresRecherche criteresBilan,
+ public ResultatConsultation listeDesAbsencesEtRetards(BilanCriteresRecherche criteresBilan,
SecuriteSession securiteSession,
Etablissement etablissement) {
ResultatConsultation result = new ResultatConsultation()
)
if (!criteresBilan.eleveIds) {
criteresBilan.eleveIds =
- localStructureEnseignementService.listeElevesActifsOuSortants(
+ localStructureEnseignementPersonneService.listeElevesActifsOuSortants(
criteresBilan.structIds
)*.autoriteId
}
)
if (!criteresBilan.eleveIds) {
criteresBilan.eleveIds =
- localStructureEnseignementService.listeElevesActifsOuSortants(
+ localStructureEnseignementPersonneService.listeElevesActifsOuSortants(
criteresBilan.structIds
)*.autoriteId
}
import org.lilie.services.eliot.absences.statistiques.mensuelle.ModeCalcul
import org.lilie.services.eliot.temps.DateUtil
import org.lilie.services.eliot.absences.statistiques.StatistiqueParserService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class ExportParserService {
LocalStructureEnseignementService localStructureEnseignementService
LocalPersonneService localPersonneService
StatistiqueParserService statistiqueParserService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
public List<Long> parseEleve(String eleves, List<StructureEnseignement> structures) {
List<Personne> elevePersonnes
eleveIds = [(Long) -1]
}
if (eleveIds.contains((Long) (-1))) {
- elevePersonnes = localStructureEnseignementService.
+ elevePersonnes = localStructureEnseignementPersonneService.
findAllPersonnesElevesForAllStructures((Set<StructureEnseignement>) structures)
} else {
elevePersonnes = localPersonneService.findAllPersonne(eleveIds)
import org.lilie.services.eliot.temps.TypeEvenement
import org.lilie.services.eliot.temps.TypeAgenda
import org.lilie.services.eliot.temps.TypeAgendaEnum
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class SaisieCollectiveService {
CalendrierService calendrierService
SaisieCollectiveReferentielService saisieCollectiveReferentielService
AbsenceJourneeService absenceJourneeService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
SessionFactory sessionFactory
rechercherParams.structureEnseignement.etablissement
)
RechercherResultat result = new RechercherResultat(
- eleves: localStructureEnseignementService.
+ eleves: localStructureEnseignementPersonneService.
findAllPersonnesElevesForAllStructures(
(Set) [rechercherParams.structureEnseignement]
),
import java.math.RoundingMode
import org.lilie.services.eliot.absences.emploidutemps.EmploiDuTempsService
import org.lilie.services.eliot.temps.DateUtil
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class StatsHebdosService extends AbstractConsultationService {
CalendrierAbsencesService calendrierAbsencesService
EmploiDuTempsService emploiDuTempsService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
- StatsHebdos calculeStatsHebdos(SecuriteSession securiteSession,
+ public StatsHebdos calculeStatsHebdos(SecuriteSession securiteSession,
StatsParams criteres,
PreferencesEtablissementAbsences pref) {
}
/* Retourne la liste des absences/retards/départs composée de l'élève, la date
-et la plage horaire concernés*/
-
+ et la plage horaire concernés*/
private List<StatsHebdoData> findAllStatsHebdoData(SecuriteSession securiteSession,
StatsParams criteres,
List<StructureEnseignement> classes) {
List<Long> eleveAutoriteIds =
- localStructureEnseignementService.listeElevesActifsOuSortants(classes)
+ localStructureEnseignementPersonneService.listeElevesActifsOuSortants(classes)
.collect{it.autoriteId}
if (eleveAutoriteIds.isEmpty()) {
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
/**
* @author jbui
LocalStructureEnseignementService localStructureEnseignementService
TableauDeBordAbsencesService tableauDeBordAbsencesService
LocalPersonneService localPersonneService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
/**
* Prépare les lignes du resultat en fonction du seuil demandé
result.nbLignes = eleveIds.size()
- localStructureEnseignementService.listeElevesDerniereClasseEtab(
+ localStructureEnseignementPersonneService.listeElevesDerniereClasseEtab(
eleveIds,
tableauDeBordParams
).each {
import org.lilie.services.eliot.absences.AppelLigne
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
/**
* Gère le tableau de bord avec seuil pour les départs anticipés, les retards,
* @author jbui
*/
class TableauDeBordRetardDepartPensionSeuilService {
+
public static final Byte RETARD = 0
public static final Byte DEPART = 1
public static final Byte DEMI_PENSION = 2
public static final Byte INTERNAT = 3
LocalPersonneService localPersonneService
- LocalStructureEnseignementService localStructureEnseignementService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
/**
* Prépare les lignes du résultat en fonction du seuil demandé
Byte typeAbsence) {
TableauDeBord result = new TableauDeBord()
- List<Map> infosElevesActifsOuSortants = localStructureEnseignementService.
+ List<Map> infosElevesActifsOuSortants = localStructureEnseignementPersonneService.
listeElevesActifsOuSortants(criteres.classes*.id)
List<Long> autoriteIds = AppelLigne.executeQuery(
dateFin: criteres.dateFin,
seuil: (Long) criteres.valeurSeuil
]
- ).collect{ it[0] }
+ ).collect { it[0] }
result.lignes.addAll(this.prepareLignes(criteres, autoriteIds))
result.nbLignes = autoriteIds.size()
List<Long> autoriteIds) {
List<TableauDeBordLigne> result = []
- localStructureEnseignementService.listeElevesDerniereClasseEtab(
+ localStructureEnseignementPersonneService.listeElevesDerniereClasseEtab(
autoriteIds,
criteres
).each {
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementServiceHql
import org.lilie.services.eliot.constantes.ConstFonct
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
/**
* @author jbui
TableauDeBordRetardDepartPensionSeuilService tableauDeBordRetardDepartPensionSeuilService
SessionFactory sessionFactory
LocalStructureEnseignementService localStructureEnseignementService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
static transactional = true
tableauDeBord.totaux = new TableauDeBordTotaux()
- criteres.autoriteEleveIds = localStructureEnseignementService.
+ criteres.autoriteEleveIds = localStructureEnseignementPersonneService.
listeElevesActifsOuSortants(criteres.classes*.id)*.autoriteId
tableauDeBordAbsencesService.calculeTotalSansMotif(criteres, pref, tableauDeBord)
import org.lilie.services.eliot.absences.saisie.appelligne.AppelLigneService
import org.lilie.services.eliot.absences.AppelLigne
import org.lilie.services.eliot.absences.saisie.hebdomadaire.SaisieHebdomadaireService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
/**
* @author jbui
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
CalendrierService calendrierService
LocalStructureEnseignementService localStructureEnseignementService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
PlageHoraireService plageHoraireService
def 'findRechercherResultat'() {
1 * preferencesEtablissementAbsencesService.getPreferencesEtablissementForEtablissement(_) >>
preferencesEtablissementAbsences
1 * calendrierService.getCalendrierForEtablissement(_) >> calendrier
- 1 * localStructureEnseignementService.findAllPersonnesElevesForAllStructures(_) >> [eleve1, eleve2]
+ 1 * localStructureEnseignementPersonneService.findAllPersonnesElevesForAllStructures(_) >> [eleve1, eleve2]
1 * plageHoraireService.getPlageHorairesInfo(_, _) >> [plageHoraireInfo]
rechercherResultat.dateDebut == rechercherParams.dateDebut
import org.lilie.services.eliot.notes.AbstractNotesController
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import grails.converters.JSON
import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.impression.ImpressionInfoGenerale
import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementPersonneService
class PublipostageController extends AbstractNotesController {
- LocalStructureEnseignementService localStructureEnseignementService
NotesTypePeriodeService notesTypePeriodeService
ImpressionRequetageBulletinReleveService impressionRequetageBulletinReleveService
ImpressionRequetageBrevetService impressionRequetageBrevetService
BrevetClasseService brevetClasseService
ImpressionBulletinOptionsService impressionBulletinOptionsService
LocalClasseService localClasseService
+ LocalStructureEnseignementPersonneService localStructureEnseignementPersonneService
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.FRANCE)
-
def index = {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PUBLIPOST)
)
}
-
def recherche = {
Map result = tryCatch {
classes.each {verifieDroitAccesObjetDomaine(it)}
List<Personne> eleves =
- localStructureEnseignementService.findAllPersonnesElevesForAllStructures(
+ localStructureEnseignementPersonneService.findAllPersonnesElevesForAllStructures(
(Set) classes
)