public enum TypeMoyenneEnum {
ELEVE_ENSEIGNEMENT_PERIODE(['eleve','enseignement','periode']), // moyenne d'un élève pour une période et un enseignement
- ELEVE_SERVICE_PERIODE(['eleve','service','periode']), // moyenne d'un élève pour une période et un service
+ ELEVE_SERVICE_PERIODE(['eleve',ConstFonct.SERVICE,'periode']), // moyenne d'un élève pour une période et un service
ELEVE_SOUS_SERVICE_PERIODE(['eleve','sousService','periode']), // moyenne d'un élève pour une période et un sous-service
ELEVE_PERIODE(['eleve','periode']), // moyenne d'un elève pour une période sur tous les services
ENSEIGNEMENT_PERIODE(['enseignement','periode']), // moyenne d'une structure d'enseignement pour une période et un enseignement
- CLASSE_SERVICE_PERIODE(['classe','service','periode']), // moyenne d'une classe pour une période et un service
+ CLASSE_SERVICE_PERIODE(['classe',ConstFonct.SERVICE,'periode']), // moyenne d'une classe pour une période et un service
CLASSE_SOUS_SERVICE_PERIODE(['classe','sousService','periode']), // moyenne d'une classe pour une période et un sous-servuce
CLASSE_PERIODE(['classe','periode']) // moyenne d'une classe pour une période sur tous les services
import org.lilie.services.eliot.notes.DirtyMoyenne
import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
import org.lilie.services.eliot.notes.TypeMoyenneEnum
+import org.lilie.services.eliot.constantes.ConstFonct
class DirtyMoyenneService {
eq('periode', params.periode)
}
if(params.service) {
- eq('service', params.service)
+ eq(ConstFonct.SERVICE, params.service)
}
if(params.enseignement){
enseignement {
- eq('service', params.enseignement.service)
+ eq(ConstFonct.SERVICE, params.enseignement.service)
eq('enseignant', params.enseignement.enseignant)
}
}
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.ArgumentUtils
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author bper
Periode periode) {
ArgumentUtils.verifieArgumentNotNull('classe', classe)
- ArgumentUtils.verifieArgumentNotNull('service', service)
+ ArgumentUtils.verifieArgumentNotNull(ConstFonct.SERVICE, service)
ArgumentUtils.verifieArgumentNotNull('periode', periode)
return ResultatClasseServicePeriode.createCriteria().get {
eq('classe', classe)
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('periode', periode)
}
}
Periode periode) {
ArgumentUtils.verifieArgumentNotNull('classe', classe)
- ArgumentUtils.verifieArgumentNotNull('service', service)
+ ArgumentUtils.verifieArgumentNotNull(ConstFonct.SERVICE, service)
ArgumentUtils.verifieArgumentNotNull('periode', periode)
ResultatClasseServicePeriode res = internalFind(classe, service, periode)
'in'('classe', classes)
}
if (services) {
- 'in'('service', services)
+ 'in'(ConstFonct.SERVICE, services)
}
if (periodes) {
'in'('periode', periodes)
}
}
fetchMode('periode', FetchMode.JOIN)
- fetchMode('service', FetchMode.JOIN)
+ fetchMode(ConstFonct.SERVICE, FetchMode.JOIN)
}
return ress
List<ResultatClasseServicePeriode> internalFindAllByServiceAndTypePeriode(
Service service, TypePeriode typePeriode) {
return ResultatClasseServicePeriode.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
periode {
eq('typePeriode', typePeriode)
}
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.ArgumentUtils
import org.lilie.services.eliot.scolarite.ServiceService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author msan
eq('modaliteMatiere', modaliteMatiere)
}
resultatClasseServicePeriode {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
}
if (res?.size()>0) {
Long resCount =
ResultatClasseSousServicePeriode.createCriteria().get {
resultatClasseServicePeriode {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
projections {
count('id')
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.ArgumentUtils
import org.lilie.services.eliot.notes.ResultatEnseignementPeriode
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Résultats d'une structure d'enseignement pour un enseignement et une période
List<ResultatEnseignementPeriode> res =
ResultatEnseignementPeriode.withCriteria {
enseignement {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
}
if (res?.size() > 0) {
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.notes.resultat.Moyenne
import org.lilie.services.eliot.scolarite.NaturePeriode
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Resultat pour un élève, enseignement et période
List<ResultatEleveEnseignementPeriode> res =
ResultatEleveEnseignementPeriode.withCriteria {
enseignement {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
}
if (res?.size() > 0) {
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.notes.resultat.Moyenne
import org.lilie.services.eliot.scolarite.NaturePeriode
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author bper
Periode periode) {
ArgumentUtils.verifieArgumentNotNull('eleve',eleve)
- ArgumentUtils.verifieArgumentNotNull('service',service)
+ ArgumentUtils.verifieArgumentNotNull(ConstFonct.SERVICE,service)
ArgumentUtils.verifieArgumentNotNull('periode',periode)
return ResultatEleveServicePeriode.createCriteria().get {
eq('eleve', eleve)
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('periode', periode)
}
}
Periode periode) {
ArgumentUtils.verifieArgumentNotNull('eleve',eleve)
- ArgumentUtils.verifieArgumentNotNull('service',service)
+ ArgumentUtils.verifieArgumentNotNull(ConstFonct.SERVICE,service)
ArgumentUtils.verifieArgumentNotNull('periode',periode)
ResultatEleveServicePeriode res = internalFind(eleve, service, periode)
'in'('eleve', eleves)
}
if (services) {
- 'in'('service', services)
+ 'in'(ConstFonct.SERVICE, services)
}
if (periodes) {
'in'('periode', periodes)
}
}
fetchMode('periode', FetchMode.JOIN)
- fetchMode('service', FetchMode.JOIN)
+ fetchMode(ConstFonct.SERVICE, FetchMode.JOIN)
}
return ress
List<ResultatEleveServicePeriode> internalFindAllByServiceAndTypePeriode(
Service service, TypePeriode typePeriode) {
return ResultatEleveServicePeriode.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
periode {
eq('typePeriode', typePeriode)
}
import org.lilie.services.eliot.ArgumentUtils
import org.lilie.services.eliot.notes.resultat.Moyenne
import org.lilie.services.eliot.scolarite.ServiceService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author msan
eq('modaliteMatiere', modaliteMatiere)
}
resultatEleveServicePeriode {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
}
if (res?.size() > 0) {
Long resCount =
ResultatEleveSousServicePeriode.createCriteria().get {
resultatEleveServicePeriode {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
projections {
count('id')
import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Périodes
StructureEnseignement classe) {
List<Periode> periodesDeService = RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
projections {
property('periode')
}
package org.lilie.services.eliot.scolarite
import org.hibernate.FetchMode
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.GormUtils
import org.hibernate.SessionFactory
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author bper
(List<Long>) RelPeriodeService.createCriteria().list {
createAlias('periode', 'periode')
'in'('periode.classe', service.structureEnseignement.classesFinales)
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
projections {
distinct('periode.id')
'in'('classe', service.structureEnseignement.classesFinales)
}
}
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
relsEnTrop.each {
// Get coeff de première trimestre
RelPeriodeService rel = (RelPeriodeService) RelPeriodeService.createCriteria().get {
eq('periode', premiereTrimestre)
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
if (rel) {
List<RelPeriodeService> rels =
(List<RelPeriodeService>) RelPeriodeService.createCriteria().list {
eq('periode', periode)
- 'in'('service', services)
+ 'in'(ConstFonct.SERVICE, services)
}
rels.each { RelPeriodeService rel ->
*/
RelPeriodeService getOrCreateRel(Service service, Periode periode) {
RelPeriodeService rel = (RelPeriodeService) RelPeriodeService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('periode', periode)
}
if (!rel) {
TypePeriode typePer) {
Long relCount = (Long) RelPeriodeService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('evaluable', true)
if (naturePeriodeEnum == NaturePeriode.NOTATION) {
periode {
*/
List<RelPeriodeService> internalFindAllByService(Service service) {
return RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
fetchMode('periode', FetchMode.JOIN)
}
}
*/
void initOrdresParDefautPeriodesNotation(Service service) {
List<RelPeriodeService> relsNotation = RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
isNull('ordre')
periode {
typePeriode {
StructureEnseignement classe, List<RelPeriodeService> relsParClasse ->
Integer maxOrdre = (Integer) RelPeriodeService.createCriteria().get {
- ne('service', service)
+ ne(ConstFonct.SERVICE, service)
'periode' {
'typePeriode' {
eq('nature', NaturePeriode.NOTATION)
*/
private void initOrdresParDefautPeriodesExamen(Service service) {
List<RelPeriodeService> relsExamen = RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
isNull('ordre')
periode {
typePeriode {
relsExamen.each { RelPeriodeService rel ->
Integer maxOrdre = (Integer) RelPeriodeService.createCriteria().get {
- ne('service', service)
+ ne(ConstFonct.SERVICE, service)
eq('periode', rel.periode)
projections {
max('ordre')
import org.lilie.services.eliot.securite.perimetre.PerimetreClasseEnseignantPrincipal
import org.lilie.services.eliot.securite.perimetre.PerimetreEnseignement
import org.lilie.services.eliot.scolarite.Enseignement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author jbui
List<StructureEnseignement> allStructureEnseignement = (List<StructureEnseignement>) Enseignement.withCriteria {
'in'('id', enseignementIds)
- createAlias('service', 'service')
+ createAlias(ConstFonct.SERVICE, 'service')
projections {
property('service.structureEnseignement')
}
eq('eleve', eleve.autorite)\r
evaluation {\r
enseignement {\r
- eq('service', serviceSport)\r
+ eq(ConstFonct.SERVICE, serviceSport)\r
}\r
periodes {\r
typePeriode {\r
import org.lilie.services.eliot.notes.notification.NotesNotificationService
import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service sur les évaluations
return Evaluation.withCriteria {
eq('modaliteMatiere', sousService.modaliteMatiere)
enseignement {
- eq('service', sousService.service)
+ eq(ConstFonct.SERVICE, sousService.service)
}
periodes {
eq('typePeriode', sousService.typePeriode)
List<Evaluation> internalFindAllEvaluationByEnseignement(Enseignement ens) {
return Evaluation.withCriteria {
enseignement {
- eq('service', ens.service)
+ eq(ConstFonct.SERVICE, ens.service)
eq('enseignant', ens.enseignant)
}
}
import org.lilie.services.eliot.notes.utils.NotesHibernateSessionService
import org.hibernate.FetchMode
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.notes.NoteService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service pour les Notes
return Note.withCriteria {
evaluation {
enseignement {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
if (listePeriodes) {
periodes {
evaluation {
eq('modaliteMatiere', sousService.modaliteMatiere)
enseignement {
- eq('service', sousService.service)
+ eq(ConstFonct.SERVICE, sousService.service)
}
periodes {
eq('id', periode.id)
eq('enseignement', ens)
eq('modaliteMatiere', sousService.modaliteMatiere)
enseignement {
- eq('service', sousService.service)
+ eq(ConstFonct.SERVICE, sousService.service)
}
periodes {
eq('typePeriode', sousService.typePeriode)
'in'('eleve', eleves)
evaluation {
enseignement {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
}
}
}
if (services) {
enseignement {
- 'in'('service', services)
+ 'in'(ConstFonct.SERVICE, services)
}
}
if (publiable != null) {
import java.util.Map.Entry
import org.lilie.services.eliot.notes.resultat.NoteInfo
import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Récuperation des tableaux de notes
params.enseignantCorrige &&
notesDroitService.hasPerimetre(securiteSession, PerimetreEtablissement)
- checkArgumentNotNull('service', service)
+ checkArgumentNotNull(ConstFonct.SERVICE, service)
checkArgumentNotNull('typePeriode', typePeriode)
checkArgumentNotNull('operateurSaisie', operateurSaisie)
import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.NaturePeriode
+import org.lilie.services.eliot.constantes.ConstFonct
class TableauNotesSportService {
return Evaluation.createCriteria().list{
enseignement {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
}
typeActivite {
import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.utils.ListeUtilsService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Service pour marquer que les données source d'une moyenne ont chagé.
fetchMode('classe.periodes', FetchMode.JOIN)
fetchMode('periode', FetchMode.JOIN)
fetchMode('periode.typePeriode', FetchMode.JOIN)
- fetchMode('service', FetchMode.JOIN)
+ fetchMode(ConstFonct.SERVICE, FetchMode.JOIN)
fetchMode('service.relPeriodeServices', FetchMode.JOIN)
fetchMode('service.sousServices', FetchMode.JOIN)
fetchMode('enseignement', FetchMode.JOIN)
import org.lilie.services.eliot.notes.domaine.PeriodeParams
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.applications.notes.BulletinOptionsService
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Services relatifs aux périodes de scolarité
if (typePeriodeEquivalent != null) {
return RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
periode {
or {
eq('typePeriode', typePeriode)
}
else {
return RelPeriodeService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
periode {
eq('typePeriode', typePeriode)
}
service.structureEnseignement)
return RelPeriodeService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
periode {
eq('classe', classe)
or {
import org.lilie.services.eliot.notes.resultat.ResultatNettoyageService
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
import org.lilie.services.eliot.scolarite.SousServiceService
+import org.lilie.services.eliot.constantes.ConstFonct
class NotesSousServiceService extends SousServiceService implements ApplicationContextAware {
List<ModaliteMatiere> mms = listeModaliteMatieres(service)
if (mms?.size() > 0) {
List<SousService> ssExistants = SousService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('typePeriode', typePeriode)
'in'('modaliteMatiere', mms)
}
)
return SousService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
if (typePeriodeEquivalent) {
or {
eq('typePeriode', typePeriode)
private Long internalFindOrdreSuivant(Service service,
TypePeriode typePeriode) {
Long max = SousService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('typePeriode', typePeriode)
projections {
max('ordre')
NaturePeriode nature,
TypePeriode typePer) {
Long relCount = SousService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
if (nature == NaturePeriode.NOTATION) {
typePeriode {
ModaliteMatiere modaliteMatiere,
List<TypePeriode> typePeriodes = null) {
return SousService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
if (typePeriodes && !typePeriodes.isEmpty()) {
'in'('typePeriode', typePeriodes)
TypePeriode typePeriodeSS
) {
return SousService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
typePeriode {
eq('id', typePeriodeSS.id)
}
List<SousService> sousServices = SousService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
'in'('typePeriode', typePeriodes)
}
TypePeriode typePer) {
Long ssCount = SousService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
eq('evaluable', true)
if (naturePeriodeEnum == NaturePeriode.NOTATION) {
// vérifie Notes et al.
List<SousService> sousServices = SousService.withCriteria {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('modaliteMatiere', modaliteMatiere)
}
TypePeriode typePeriode,
ModaliteMatiere modaliteMatiere) {
SousService sousService = SousService.createCriteria().get {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
eq('typePeriode', typePeriode)
eq('modaliteMatiere', modaliteMatiere)
}
import org.springframework.context.ApplicationContextAware
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.NaturePeriode
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* @author bper
}
List<TypePeriode> typePeriodes = RelPeriodeService.createCriteria().listDistinct {
- eq('service', service)
+ eq(ConstFonct.SERVICE, service)
if (seulementEvalauable) {
eq('evaluable', true)
}
import org.lilie.services.eliot.textes.CahierDeTextesType
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.textes.basculeannee.rapports.TextesBasculeAnneeAbstractRapport
+import org.lilie.services.eliot.constantes.ConstFonct
/**
* Services de bascule d'année pour les cahiers de textes de service
// récupére les ids de cdts privés pour les traiter par batch
List<Long> idsCahierPrive = CahierDeTextes.withCriteria {
- isNull('service')
+ isNull(ConstFonct.SERVICE)
projections {
property('id')
}
// récupére les ids de cdts privé vises pour les traiter par batch
List<Long> idsCahiersPriveVises = CahierDeTextes.withCriteria {
- isNull('service')
+ isNull(ConstFonct.SERVICE)
eq('estVise', true)
anneeScolaire {
eq('code', basculeAnneeInfo.anneeSource)