* @author msan
*/
+import org.lilie.services.eliot.constantes.ConstFonct
+
public class Service {
Long id
StructureEnseignement classe = structureEnseignement.classes.toList().first()
return Service.createCriteria().get{
- eq('structureEnseignement', classe)
- eq('matiere', matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
+ eq(ConstFonct.MATIERE, matiere)
eq('servicePrincipal', servicePrincipal)
projections {
'count'('id')
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* The CahierDeTextes entity.
boolean estVide() {
def critActivites = Activite.createCriteria()
def listeActivites = critActivites.list {
- eq("cahierDeTextes", this)
+ eq(ConstFonct.CAHIER_DE_TEXTES, this)
}
if (listeActivites.size() > 0) {
return false
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.parametrages.calendrier.PasDeDecompteService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Permet de manipuler des informations d'emploi du temps
List<Evenement> evenementList = Evenement.withCriteria {
agendaMaitre {
- 'in'('structureEnseignement', allStructureEnseignement)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, allStructureEnseignement)
}
type {
List<Evenement> evenementList = Evenement.withCriteria {
agendaMaitre {
- 'in'('structureEnseignement', allStructureEnseignement)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, allStructureEnseignement)
}
type {
import org.lilie.services.eliot.textes.ContexteActivite
import org.lilie.services.eliot.textes.DateActivite
import org.springframework.web.servlet.support.RequestContextUtils
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Expose les fonctionnalités liées à la gestion des activités de cahier de
if (evenement) {
dates = DateActivite.withCriteria {
eq('evenement', evenement)
- fetchMode("activite", FetchMode.JOIN)
+ fetchMode(ConstFonct.ACTIVITE, FetchMode.JOIN)
}
}
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.TypeActiviteService
import org.lilie.services.eliot.securite.permission.partageauto.CahierDeTextesPartageAutoService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Classe de service exposant les opérations relatives aux cahier de textes
AnnuaireService annuaireService
RelDossierAutorisationCahierService relDossierAutorisationCahierService
AnneeScolaireService anneeScolaireService
- CiteScolaireService citeScolaireService
SessionFactory sessionFactory
EtablissementService etablissementService
TypeActiviteService typeActiviteService
List<CahierDeTextes> cahierDeTextesList = (List<CahierDeTextes>) c.list {
'service' {
- eq('matiere', matiere)
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.MATIERE, matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
}
'item' {
'in'('id', itemIdListe)
boolean inclureActivitesNonPubliees = false) {
List<Activite> activites = Activite.createCriteria().listDistinct {
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
if (!inclureActivitesNonPubliees) {
- eq('estPubliee', true)
+ eq(ConstFonct.EST_PUBLIE, true)
}
}
*/
List<Chapitre> findAllChapitreByCahierDeTextes(CahierDeTextes cahierDeTextes) {
List<Chapitre> chapitres = Chapitre.createCriteria().listDistinct {
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
}
return chapitres
import org.lilie.services.eliot.textes.Chapitre
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.Activite
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Expose les fonctionnalités de gestion des chapitres de cahier de textes
}
else {
isNull('chapitre')
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
}
}
projections {
def criteriaActivite = Activite.createCriteria()
def ordreMaxActivite = criteriaActivite.get {
and {
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
if (chapitreParent) {
eq('chapitre', chapitreParent)
}
import org.lilie.services.eliot.brevet.BrevetSerie
import org.hibernate.FetchMode
import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
if (services){
Service.createCriteria().listDistinct{
'in'('id', services*.id)
- fetchMode('structureEnseignement', FetchMode.JOIN)
+ fetchMode(ConstFonct.STRUCTURE_ENSEIGNEMENT, FetchMode.JOIN)
fetchMode('structureEnseignement.classes', FetchMode.JOIN)
projections{
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}?.each{ StructureEnseignement structureEnseignement ->
if (structureEnseignement.isClasse()){
import org.lilie.services.eliot.securite.EliotDroitsService
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.constantes.ConstFonct
class ServiceService {
// qu'un seul service principal d'origine AUTO.
// Ce service va etre utiliser dans Eliot-Notes.
return Service.createCriteria().get {
- eq('structureEnseignement', structureEnseignement)
- eq('matiere', matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
+ eq(ConstFonct.MATIERE, matiere)
eq('origine', origine)
eq('servicePrincipal', true)
projections {
// Récupération du service en base
Service service = (Service) Service.createCriteria().get {
- eq('structureEnseignement', structureEnseignement)
- eq('matiere', matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
+ eq(ConstFonct.MATIERE, matiere)
if (modaliteCours) {
eq('modaliteCours', modaliteCours)
} else {
def criteria = Service.createCriteria()
Service service = (Service) criteria.get {
- eq('matiere', matiere)
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.MATIERE, matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
eq('modaliteCours', modaliteCours)
}
}
return Service.withCriteria {
- eq('structureEnseignement', classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
}
}
localStructureEnseignementService.findAllStructuresForClasse(classe)
return Service.withCriteria {
- 'in'('structureEnseignement', structs)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, structs)
eq('servicePrincipal', true)
}
}
}
List<Service> services = Service.createCriteria().listDistinct {
- 'in'('structureEnseignement', structureEnseignements)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignements)
createAlias("relPeriodeServices", "relPS")
if (periodes) {
'in'('relPS.periode', periodes)
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.hibernate.FetchMode
import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.constantes.ConstFonct
class LocalGroupeService {
if (structures) {
List<ProprietesScolarite> groupesParents =
ProprietesScolarite.createCriteria().list {
- 'in'('structureEnseignement', structures)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, structures)
fonction {
eq('code', FonctionEnum.PERS_REL_ELEVE.code)
}
eq('anneeScolaire', anneeEnCours)
eq('fonction', fonction)
if (matiere) {
- eq('matiere', matiere)
+ eq(ConstFonct.MATIERE, matiere)
} else {
- isNull('matiere')
+ isNull(ConstFonct.MATIERE)
}
'in'('etablissement', etablissements)
}
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteHqlFactory
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Fonctions de base sur les propriétés de scolarités
*/
public List<ProprietesScolarite> findAllByStructureEnseignement(StructureEnseignement structureEnseignement) {
return ProprietesScolarite.withCriteria {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
}
}
eq('fonction', param.fonction)
if (param.structureEnseignement != null) {
- eq('structureEnseignement', param.structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, param.structureEnseignement)
} else if (param.etablissement != null) {
eq('etablissement', param.etablissement)
} else if (param.porteurEnt != null) {
}
if (param.matiere != null) {
- eq('matiere', param.matiere)
+ eq(ConstFonct.MATIERE, param.matiere)
}
if (param.responsableStructureEnseignement != null) {
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Cette classe permet d'avoir un objet capable de générer une requete hql
"etablissement",
"structureEnseignement",
"anneeScolaire",
- "matiere",
+ ConstFonct.MATIERE,
"mef",
"fonction",
"responsableStructureEnseignement"
import org.lilie.services.eliot.scolarite.personne.enseignant.EnseignantAnnuaireService
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.scolarite.OrigineEnum
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service général sur les enseignements
return (Enseignement) Enseignement.createCriteria().get {
eq('enseignant', enseignant)
'service' {
- eq('structureEnseignement', structure)
- eq('matiere', matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structure)
+ eq(ConstFonct.MATIERE, matiere)
'modaliteCours' {
eq('codeSts', codeStsModaliteCours)
}
import org.lilie.services.eliot.scolarite.OrigineEnum
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.AnneeScolaire
+import org.lilie.services.eliot.constantes.ConstFonct
class MatiereService {
matiere {
eq('etablissement', etablissement)
}
- fetchMode('matiere', FetchMode.JOIN)
+ fetchMode(ConstFonct.MATIERE, FetchMode.JOIN)
}
matieres = services*.matiere?.unique { it.id }?.toList()
return matieres
boolean isMatiereUtilise(SecuriteSession securiteSession, Matiere matiere) {
int nbServices = Service.createCriteria().count {
- eq('matiere', matiere)
+ eq(ConstFonct.MATIERE, matiere)
}
return (nbServices > 0)
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.notes.Note
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Ce service fournis des informations concernant les élèves à partir de
return (List<Personne>) PersonneProprietesScolarite.createCriteria().listDistinct {
proprietesScolarite {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
return (List<Personne>)PersonneProprietesScolarite.createCriteria().listDistinct{
proprietesScolarite{
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
fonction{
eq('code', FonctionEnum.ELEVE.getCode())
}
eq('estActive', false)
proprietesScolarite {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
evaluation {
enseignement {
service {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
}
}
}
eq('estActive', false)
proprietesScolarite {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
}
Long presence = PersonneProprietesScolarite.createCriteria().get {
proprietesScolarite {
- eq('structureEnseignement', classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
eq('fonction', Fonction.findByCode(FonctionEnum.ELEVE.getCode()))
}
eq('personne', eleve)
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Manipulation des données des enseignants dans l'annuaire
Enseignement.createCriteria().count {
eq('enseignant', enseignement.enseignant)
service {
- 'in'('structureEnseignement', structures)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, structures)
}
ne('id', enseignement.id)
maxResults(1)
structureEnseignement {
eq('etablissement', enseignement.service.structureEnseignement.etablissement)
}
- eq('matiere', enseignement.service.matiere)
+ eq(ConstFonct.MATIERE, enseignement.service.matiere)
}
ne('id', enseignement.id)
maxResults(1)
import org.lilie.services.eliot.notes.StructureEnseignementNotes
import org.hibernate.transform.Transformers
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service de gestion des structures d'enseignement pour l'annuaire local
def crit = Service.createCriteria()
List<Service> services = crit.list {
- eq('matiere', matiere)
+ eq(ConstFonct.MATIERE, matiere)
structureEnseignement {
eq('etablissement', etablissement)
}
eq('estActive', true)
'proprietesScolarite'{
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
}
'proprietesScolarite'{
eq('fonction', Fonction.getByCode(FonctionEnum.ENSEIGNANT))
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
}
eq('personne', eleve)
eq('estActive', true)
'proprietesScolarite'{
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
}
// qui sont responsables
eq('responsableStructureEnseignement', true)
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
}
// qui sont responsables
eq('responsableStructureEnseignement', true)
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
}
return PersonneProprietesScolarite.createCriteria().get {
proprietesScolarite {
- eq('structureEnseignement', groupe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, groupe)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
'id',
PersonneProprietesScolarite.createCriteria().list {
proprietesScolarite {
- eq('structureEnseignement', classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
eq('code', FonctionEnum.ELEVE.getCode())
}
projections {
- property('structureEnseignement')
+ property(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
}
order('dateDesactivation', 'desc')
}
proprietesScolarite {
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
- eq('structureEnseignement', structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignement)
}
projections {
class ConstFonct {
public static final String CAHIER_DE_TEXTES = 'cahierDeTextes'
+ public static final String ACTIVITE = 'activite'
public static final String DATE_ACTIVITE = 'dateActivite'
public static final String EST_PUBLIE = 'estPubliee'
public static final String SERVICE = "service"
import org.lilie.services.eliot.textes.TypeActivite
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.constantes.ConstFonct
+
class FicheEleveServiceTests extends GrailsUnitTestCase {
FicheEleveService ficheEleveService
private Note creeNote(Personne eleve, Periode periode) {
Enseignement enseignement = Enseignement.createCriteria().get{
service {
- eq('structureEnseignement', periode.classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, periode.classe)
}
maxResults(1)
}
import org.springframework.transaction.TransactionStatus
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.temps.udt.UdtEvenement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Import des services, enseignements, agendas et cdts à partir des imports udt
eq('etat', UdtEtatImport.EN_ATTENTE)
fetchMode('professeur', FetchMode.JOIN)
fetchMode('professeur.autorite', FetchMode.JOIN)
- fetchMode('structureEnseignement', FetchMode.JOIN)
+ fetchMode(ConstFonct.STRUCTURE_ENSEIGNEMENT, FetchMode.JOIN)
}
}
eq('id', udtEnseignement.id)
fetchMode('professeur', FetchMode.JOIN)
fetchMode('professeur.autorite', FetchMode.JOIN)
- fetchMode('structureEnseignement', FetchMode.JOIN)
+ fetchMode(ConstFonct.STRUCTURE_ENSEIGNEMENT, FetchMode.JOIN)
}
}
return udtEnseignement
import org.lilie.services.eliot.temps.udt.UdtImport
import org.springframework.transaction.TransactionStatus
import org.lilie.services.eliot.temps.udt.UdtSemaineImportee
+import org.lilie.services.eliot.constantes.ConstFonct
@SuppressWarnings("CatchException") // bper: les méthodes doivent être exception-safe
class UdtEvenementService {
if (udtEnseignementLot.structureId) {
eq('structureEnseignement.id', udtEnseignementLot.structureId)
} else {
- isNull('structureEnseignement')
+ isNull(ConstFonct.STRUCTURE_ENSEIGNEMENT)
}
if (udtEnseignementLot.enseignantId) {
if (udtEnseignementLot.matiereId) {
eq('matiere.id', udtEnseignementLot.matiereId)
} else {
- isNull('matiere')
+ isNull(ConstFonct.MATIERE)
}
- fetchMode('structureEnseignement', FetchMode.JOIN)
+ fetchMode(ConstFonct.STRUCTURE_ENSEIGNEMENT, FetchMode.JOIN)
fetchMode('professeur', FetchMode.JOIN)
- fetchMode('matiere', FetchMode.JOIN)
+ fetchMode(ConstFonct.MATIERE, FetchMode.JOIN)
}
}
import org.lilie.services.eliot.temps.importudt.rapport.UdtImportRapport
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.temps.udt.UdtEvenement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author jbui
eq('udtImport', udtImport)
eq('etat', UdtEtatImport.EN_ATTENTE)
fetchMode('professeur', FetchMode.JOIN)
- fetchMode('structureEnseignement', FetchMode.JOIN)
+ fetchMode(ConstFonct.STRUCTURE_ENSEIGNEMENT, FetchMode.JOIN)
}
}
import org.lilie.services.eliot.temps.udt.UdtEtatImport
import org.lilie.services.eliot.test.InitDonneesCommunesTestUdtImportService
import org.codehaus.groovy.grails.commons.GrailsApplication
-import org.codehaus.groovy.runtime.DateGroovyMethods
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.temps.udt.UdtImport
+import org.lilie.services.eliot.constantes.ConstFonct
/*
* author : onic
UdtEnseignement enseignement =
(UdtEnseignement) UdtEnseignement.withCriteria(uniqueResult: true) {
- eq('matiere', matiere)
- eq('structureEnseignement', classe)
+ eq(ConstFonct.MATIERE, matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
eq('professeur', professeur)
}
private Service assertImportService(StructureEnseignement classe, Matiere matiere) {
Service service = (Service) Service.createCriteria().get {
- eq('structureEnseignement', classe)
- eq('matiere', matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
+ eq(ConstFonct.MATIERE, matiere)
eq('modaliteCours', ModaliteCours.findByCodeSts(ModaliteCours.CODE_COURS))
maxResults(1)
}
import org.lilie.services.eliot.temps.udt.UdtEvenement
import org.lilie.services.eliot.temps.Evenement
import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.constantes.ConstFonct
import groovy.sql.Sql
import org.hibernate.classic.Session
private void assertEtatUdtEvenement(Map donnees, UdtEtatImport etatAttendu) {
List<UdtEvenement> evts = UdtEvenement.withCriteria {
- eq('structureEnseignement', donnees.classe)
- eq('matiere', donnees.francais)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, donnees.classe)
+ eq(ConstFonct.MATIERE, donnees.francais)
eq('professeur', donnees.professeur)
}
assertTrue("La liste ne doit pas être vide", evts.size() > 0)
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.notes.NotesFonctionnalite
+import org.lilie.services.eliot.constantes.ConstFonct
class ConsultationAuditNoteAppreciationController extends AbstractNotesController {
List data = sort.split('-')
if (data.size() > 0) {
- if (data[0] == 'matiere') {
- sortField = 'matiere'
+ if (data[0] == ConstFonct.MATIERE) {
+ sortField = ConstFonct.MATIERE
}
}
Audit sortedAudit = new Audit()
String field1 = 'libelle'
- String field2 = 'matiere'
+ String field2 = ConstFonct.MATIERE
- if (sortField == 'matiere') {
- field1 = 'matiere'
+ if (sortField == ConstFonct.MATIERE) {
+ field1 = ConstFonct.MATIERE
field2 = 'libelle'
}
import org.lilie.services.eliot.notes.parametrageclasse.CreationSousServicesEtat
import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author msan
return [
- 'matiere': libelleMatiere,
+ ConstFonct.MATIERE: libelleMatiere,
'sousMatiere': creation.creationSousServicesSousMatiere.modaliteMatiere.code,
'etat': creation.etat.name(),
'etatLibelle': creation.etat == TraitementEtat.EN_ATTENTE ?
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Periode
+import org.lilie.services.eliot.constantes.ConstFonct
class AuditNoteAppreciationService {
if (elevesByGroupe.keySet().size() > 0) {
enseignements = Enseignement.createCriteria().list {
'service' {
- 'in'('structureEnseignement', elevesByGroupe.keySet())
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, elevesByGroupe.keySet())
}
}
}
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.notes.scolarite.NotesServiceService
+import org.lilie.services.eliot.constantes.ConstFonct
class BrevetClasseService {
Boolean isClasseIncriteAuBrevet(StructureEnseignement classe) {
return PersonneProprietesScolarite.createCriteria().get {
proprietesScolarite {
- eq('structureEnseignement', classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, classe)
}
personne {
brevetFiches {
import org.lilie.services.eliot.brevet.BrevetNote
import org.hibernate.SessionFactory
import org.hibernate.FetchMode
+import org.lilie.services.eliot.constantes.ConstFonct
class BrevetFicheService {
}
proprietesScolarite {
- eq('structureEnseignement',classe)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT,classe)
}
eq('brevetFiches.anneeScolaire', classe.anneeScolaire)
import org.lilie.services.eliot.brevet.BrevetModeCalculNote\r
import org.lilie.services.eliot.notes.Note\r
import org.lilie.services.eliot.scolarite.NaturePeriode\r
+import org.lilie.services.eliot.constantes.ConstFonct\r
\r
/**\r
* Gestion des notes de brevet\r
'in'('eleve',eleves)\r
eq('anneeScolaire', anneeScolaireService.anneeScolaireEnCours())\r
}\r
- isNotNull('matiere')\r
+ isNotNull(ConstFonct.MATIERE)\r
epreuve {\r
eq('personnalisable', true)\r
}\r
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.constantes.ConstFonct
class BrevetRelEpreuveMatiereService {
List<Matiere> matieres = relsToSupprimer*.matiere
List<Service> services = Service.createCriteria().list {
- 'in'('structureEnseignement', classes)
- 'in'('matiere', matieres)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, classes)
+ 'in'(ConstFonct.MATIERE, matieres)
eq('servicePrincipal', true)
eq('choisiPourSport', true)
}
relsToSupprimer.each {BrevetRelEpreuveMatiere rel ->
List<BrevetNote> notes = BrevetNote.withCriteria {
eq('epreuve',rel.epreuve)
- eq('matiere',rel.matiere)
+ eq(ConstFonct.MATIERE,rel.matiere)
}
notes.each {
it.matiere = null
List<BrevetRelEpreuveMatiere> findAllRel(List<BrevetEpreuve> epreuves){
return BrevetRelEpreuveMatiere.createCriteria().listDistinct {
'in'('epreuve', epreuves)
- fetchMode('matiere', FetchMode.JOIN)
+ fetchMode(ConstFonct.MATIERE, FetchMode.JOIN)
fetchMode('matiere.etablissement', FetchMode.JOIN)
}
}
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite\r
import org.hibernate.FetchMode\r
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService\r
+import org.lilie.services.eliot.constantes.ConstFonct\r
\r
/**\r
* Gestion des series de brevet\r
eq('serie.anneeScolaire', classe.anneeScolaire)\r
\r
proprietesScolarite {\r
- eq('structureEnseignement',classe)\r
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT,classe)\r
}\r
eq('estActive', true)\r
}\r
}\r
\r
proprietesScolarite {\r
- eq('structureEnseignement',classe)\r
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT,classe)\r
}\r
\r
eq('brevetFiches.anneeScolaire', classe.anneeScolaire)\r
import org.lilie.services.eliot.scolarite.ModaliteMatiere
import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
import org.lilie.services.eliot.CodeComparator
+import org.lilie.services.eliot.constantes.ConstFonct
class EvaluationContexteService {
return Enseignement.createCriteria().listDistinct {
eq('enseignant', enseignant.autorite)
service {
- eq('structureEnseignement',structureEnseignement)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT,structureEnseignement)
relPeriodeServices {
eq('evaluable',true)
}
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.hibernate.FetchMode
import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.constantes.ConstFonct
class NotesMatiereService extends MatiereService {
}
eq('servicePrincipal', true)
- fetchMode('matiere', FetchMode.JOIN)
+ fetchMode(ConstFonct.MATIERE, FetchMode.JOIN)
projections {
- property('matiere')
+ property(ConstFonct.MATIERE)
}
}
matieres.sort {it.codeGestion}
import org.lilie.services.eliot.brevet.BrevetModeCalculNote
import org.lilie.services.eliot.brevet.BrevetSerie
import org.lilie.services.eliot.notes.notes.NotesNoteService
+import org.lilie.services.eliot.constantes.ConstFonct
class NotesServiceService extends ServiceService {
localStructureEnseignementService.findAllStructureEnseignementForEleve(eleve)
List<Service> services = Service.createCriteria().listDistinct {
- 'in'('structureEnseignement', structureEnseignements)
- 'in'('matiere', matieres)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, structureEnseignements)
+ 'in'(ConstFonct.MATIERE, matieres)
createAlias("relPeriodeServices", "relPS")
eq('relPS.periode', periode)
Boolean existeDeja = false
if (enseignants) {
List<Service> services = Service.withCriteria {
- eq('matiere', matiere)
- eq('structureEnseignement', struct)
+ eq(ConstFonct.MATIERE, matiere)
+ eq(ConstFonct.STRUCTURE_ENSEIGNEMENT, struct)
eq('servicePrincipal', true)
fetchMode('enseignements', FetchMode.JOIN)
fetchMode('enseignements.enseignant', FetchMode.JOIN)
}
List<Service> services = Service.createCriteria().listDistinct {
- 'in'('structureEnseignement', classes)
- 'in'('matiere', rels*.matiere)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, classes)
+ 'in'(ConstFonct.MATIERE, rels*.matiere)
eq('servicePrincipal', true)
}
return Service.createCriteria().listDistinct {
- 'in'('structureEnseignement', classes)
+ 'in'(ConstFonct.STRUCTURE_ENSEIGNEMENT, classes)
eq('choisiPourSport', true)
eq('servicePrincipal', true)
eq('servicePrincipal', true)
fetchMode('sousServices', FetchMode.JOIN)
- fetchMode('matiere', FetchMode.JOIN)
+ fetchMode(ConstFonct.MATIERE, FetchMode.JOIN)
}
}
fetchMode('structureEnseignementNotes', FetchMode.JOIN)
fetchMode('preferences', FetchMode.JOIN)
- eq('matiere', matiere)
+ eq(ConstFonct.MATIERE, matiere)
relPeriodeServices {
eq('evaluable', true)
import org.springframework.beans.factory.InitializingBean
import org.codehaus.groovy.grails.web.pages.TagLibraryLookup
import org.hibernate.FetchMode
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service de creation et d'envoie des notifications liées aux modifications
List<Notification> notifications = new ArrayList<Notification>()
List<Activite> nouvellesActivites = Activite.withCriteria {
and {
- eq('estPubliee', true)
+ eq(ConstFonct.EST_PUBLIE, true)
ge('dateCreation', dernierEnvoie)
- fetchMode('cahierDeTextes', FetchMode.JOIN)
+ fetchMode(ConstFonct.CAHIER_DE_TEXTES, FetchMode.JOIN)
}
}
nouvellesActivites.each { Activite activite ->
}
List<Activite> majActivites = Activite.withCriteria {
and {
- eq('estPubliee', true)
+ eq(ConstFonct.EST_PUBLIE, true)
ge('dateModification', dernierEnvoie)
// On exclue le cas où les 2 dates sont égales (cas d'une nouvelle act)
neProperty('dateCreation', 'dateModification')
- fetchMode('cahierDeTextes', FetchMode.JOIN)
+ fetchMode(ConstFonct.CAHIER_DE_TEXTES, FetchMode.JOIN)
}
}
majActivites.each { Activite activite ->
import org.lilie.services.eliot.api.rest.ChapitreCourt
import org.lilie.services.eliot.textes.activite.TextesActiviteService
import org.lilie.services.eliot.textes.arbre.DossierInfoAffichage
+import org.lilie.services.eliot.constantes.ConstFonct
class TextesCahierDeTextesService extends CahierDeTextesService {
boolean inclureActivitesNonPubliees = false) {
List<Activite> activites = Activite.createCriteria().listDistinct {
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
if (!inclureActivitesNonPubliees) {
- eq('estPubliee', true)
+ eq(ConstFonct.EST_PUBLIE, true)
}
}
*/
List<Chapitre> findAllChapitreByCahierDeTextes(CahierDeTextes cahierDeTextes) {
List<Chapitre> chapitres = Chapitre.createCriteria().listDistinct {
- eq('cahierDeTextes', cahierDeTextes)
+ eq(ConstFonct.CAHIER_DE_TEXTES, cahierDeTextes)
}
return chapitres
if (cdts) {
List relCahiersActeurs = RelCahierActeur.executeQuery(
TextesCahierDeTextesServiceHql.HQL_GET_RELCAHIERACTEUR, [
- cdtIds: cdts*.id,
- acteurId: autorite.id
- ])
+ cdtIds: cdts*.id,
+ acteurId: autorite.id
+ ])
cdts.each {
CahierDeTextes cdt ->
RelCahierActeur rel = (RelCahierActeur) relCahiersActeurs.find {
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.Chapitre
import org.lilie.services.eliot.GormUtils
+import org.lilie.services.eliot.constantes.ConstFonct
class TextesActiviteService implements ApplicationContextAware {
// Met à jout ou crée
Closure action = {
RelActiviteActeur rel = RelActiviteActeur.createCriteria().get {
- eq("activite", activite)
+ eq(ConstFonct.ACTIVITE, activite)
eq("acteur", autorite)
}
// Met à jout uniquement
Closure onDataIntegrityViolation = {
RelActiviteActeur rel = RelActiviteActeur.createCriteria().get {
- eq("activite", activite)
+ eq(ConstFonct.ACTIVITE, activite)
eq("acteur", autorite)
}
// cherche les rels à changer
List<RelActiviteActeur> rels = RelActiviteActeur.withCriteria {
and {
- eq("activite", activite)
+ eq(ConstFonct.ACTIVITE, activite)
// activite { neq("auteur",auteur) }
// ne marche pas !
eq("estLu", true)
def crit = Ressource.createCriteria()
List ressourcesPubliees = crit.list {
- 'in'('activite', activites)
- eq('estPubliee', true)
+ 'in'(ConstFonct.ACTIVITE, activites)
+ eq(ConstFonct.EST_PUBLIE, true)
}
ressourcesPubliees.each {