/**
* This is not a good general function for AstUtils.
* It is too specific and may not work across different ASTNode subtypes.
- * @param node
* node
*/
private static getLastStatement(node) {
* For instance, you may ask isMethodCallOnObject(e, 'this') to find a this reference. \r
* @param expression\r
* the expression\r
- * @param methodObjectPattern\r
* @param methodObjectPattern - the name of the method object (receiver) such as 'this'\r
* @return\r
* as described\r
\r
/**\r
* Supports discovering many common JDK types, but not all.\r
- * @param node\r
- * @param fieldName\r
- * @return\r
*/\r
static Class getFieldType(ClassNode node, String fieldName) {\r
while (node != null) {\r
\r
/**\r
* gets the first non annotation line number of a node, taking into account annotations. \r
- * @param node\r
* @param sourceCode @return\r
*/\r
static int findFirstNonAnnotationLine(ASTNode node, SourceCode sourceCode) {\r
/**
* Affiche un message dans le rapport
* @param message le message a faire apparaitre dans le rapport
- * @return
*/
def doWithMessage(String message) {
logger.info(message)
/**
* Liste des erreurs issus de l'accès aux fichiers
- * @return
*/
List<String> getErreurs()
/**
* Méthode permettant de retourner les statistiques
- * @return
*/
String statisticsAsString() {
def res = null
/**
* Desactive les ResponsableEleves perimes i.e. ceux qui n'ont pas
* été activés par l'import en cours.
- * @param sql
- * @param eleve
*/
def desactiveResponsablesElevesPerimes(Sql sql, Eleve eleve) {
def dateDesactivation = SqlUtils.getCurrentTimestamp()
/**
* Met à jour le libellé long de la mef
- * @param mefId
- * @param mefLibelle
- * @return
*/
def updateMef(Sql sql, Long mefId, String mefLibelle) {
sql.execute("""
/**
* Crée un mef et en retourne l'id
- * @param sql
- * @param mefCode
- * @return
*/
private Long insertMef(Sql sql, String mefCode, String mefLibelle) {
Long mefId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_ENT_MEF)
/**
* Inserte le snoes textuelles par defaut
- * @param sql
* @param etab etablissement
- * @return
*/
def insertNotesTextuellesParDefaut(Sql sql, Etablissement etab) {
NOTES_TEXTUELLES_PAR_DEFAUT.each { List<String> noteTextuelle ->
/**
* Inserte une note textuelle par defaut
- * @param sql
* @param etab etablissement
* @param code code de note
* @param libelle libelle de note
- * @return
*/
def insertNoteTextuelleParDefaut(Sql sql,
Etablissement etab,
/**
* Insert les préférences pour l'établissement (adresse)
- * @param sql
- * @param etab
*/
def insertPreferenceEtablissement(Sql sql, Etablissement etab) {
Long prefEtabId = SqlUtils.getNextValueFromSequence(
/**
* Insert les préférences pour l'établissement specifique pour eliot-notes
- * @param sql
- * @param etab
*/
def insertEtablissementNotes(Sql sql, Etablissement etab) {
Long etabNotesId = SqlUtils.getNextValueFromSequence(
* Permet d'alimenter la map de correspondance d'identifiants entre l'établissement et son
* établissement de rattachement
* @param etabId ,
- * @param etabRattachementIdExterne
*/
private void alimenteEtablissementCorrespondanceRattachement(Long etabId,
String etabRattachementIdExterne) {
/**
* Traitement spécifique aux objets de même entité avant la finalisation de l'import.
* @param sql le canal SQL
- * @return
*/
abstract def doAfterProcessImportObjets(Sql sql)
* @param sql le canal SQL
* @param nomEntite le nom de l'entité
* @param entiteId l'id de l'entité
- * @return
*/
Long insertProprietesScolarite(Sql sql, ProprietesScolarite props) {
Long idProps = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_ENT_PROPRIETES_SCOLARITE)
/**
* Insère ou met à jour le niveau et en retourne l'id
- * @param niveauLibelle
- * @return
*/
Long getNiveau(Sql sql, String niveauLibelle) {
if (niveauLibelle == null) {
/**
* Crée un niveau et retourne son id
- * @param sql
- * @param niveauLibelle
* @return l'id du niveau
*/
Long insertNiveau(Sql sql, String niveauLibelle) {
* Desactive les personnes non mise à jour par l'import en cours :
* desactive les autorites, desactive les roles
* @param sql le canal SQL
- * @return
*/
def desactiveToutesLesPersonnesNonMisAJour(Sql sql) {
// desactive les autorites
/**
* Retourne le nom d'affichage d'un utilisateur identifié par son id dans le référentiel de
* l'annuaire distant (id AAF)
- * @param personneIdExterne
- * @return
*/
String getPersonneNomAffichage(String personneIdExterne)
/**
* Retourne les fonctions / établissement d'un utilisateur
- * @param personneIdExterne
- * @param codePorteurENT
* @param typeUtilisateur le type de l'utilisateur (admin, correspondant de déploiement, ou
* normal)
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForPersonne(String personneIdExterne,
/**
* Récupère les niveaux qu'un acteur peut voir en fonction des établissements
* et du profil passé.
- * @param securiteSession
* @param etablissements une liste d'ids d'établissement
* @param profil le profil sélectionné
* @return une Map associant les code niveau, avec les libellés des niveau
/**
* Récupère les fonctions visibles par un utilisateur en fonction d'
* établissements.
- * @param securiteSession
* @param etablissements les établissements
* @return une Map associant les code fonction avec les libellé des fonctions
*/
* @param niveau le niveau à chercher
* @param etablissements une liste d'ids établissement dans lesquels chercher
* @param tous flag indiquant si la recherche doit renvoyer tous les résultats
- * @param securiteSession
*
* @return une Map devant contenir les résultats de recherche ainsi que
* les méta données concernant les résultats.
* @param niveau le niveau à chercher
* @param etablissements une liste d'ids établissement dans lesquels chercher
* @param tous flag indiquant si la recherche doit renvoyer tous les résultats
- * @param securiteSession
*
* @return une Map devant contenir les résultats de recherche ainsi que
* les méta données concernant les résultats.
* Spécifique à la simulation de CAS en mode dév
* Retourne la liste des ids de groupes qui sont normalement ajoutés à la session par CAS
* pour un utilisateur sur un porteurENT
- * @param codePorteurENT
- * @param utilisateurIdExterne
- * @param utilisateurType
- * @return
*/
List<Long> getGroupesIdsSimulationCas(String codePorteurENT,
String utilisateurIdExterne,
/**
* Retourne les informations de groupes étendus associé à un utilisateur
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
*/
public List<GroupeEtenduInfo> getGroupeEtenduInfoForIdExterneEleve(String personneIdExterne,
String codePorteurENT)
/**
* Teste si cette session possède une des fonctions désignées par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
- * @return
*/
public boolean hasFonctionIn(List<FonctionEnum> fonctionEnum)
/**
* Teste si cette session possède une des fonctions désignées par fonctionEnum
* sur un établissement donné.
- * @param fonctionEnum
* @param id de l'établissement
- * @return
*/
public boolean hasFonctionIn(List<FonctionEnum> fonctionEnum, Long idEtablissement)
/**
* Liste des groupes étendus auxquels l'utilisateur a accès
- * @return
*/
public List<RessourceIndexeeInfo> getGroupesEtendusInfo()
/**
* Construit un objet EtablissementInfo à partir d'un OrganisationInfo
- * @param organisationInfo
- * @return
* @author jtra
* @throws IllegalArgumentException si l'organisation n'est pas de type
* ETABLISSEMENT
/**
* Génère les données test des Des DTOs de annuaire Interface pour plusieurs imports
- * @param nbrImports
- * @param criteres
*/
public void populate(
int nbrImports,
/**
* Génère les données test des Des DTOs de annuaire Interface pour un seul import
- * @param criteres
*/
public void populate(DemandeImportCriteres criteres) {
Sql sql = connectionService.getImportAnnuaireSql()
/**
*
- * @param sql
- * @param criteres
- * @param estDoublon
- * @param typeRequete
* @param donneesAleatoires si true, le nom d'academie et le code porteur est aleatoire
- * @return
*/
public DemandeImportResultat populate(
Sql sql,
/**
* Crée une demande import grâce à une DemandeImport déjà préparée
- * @param demandeImport
*/
public DemandeImport creeDemandeImport(Sql sql, DemandeImport demandeImport) {
demandeImport.load(sql)
/**
* Crée une demande import grâce aux paramètres minimaux à fournir
- * @param codePorteur
- * @param academie
- * @param mode
- * @param statut
*/
public DemandeImport creeDemandeImport(Sql sql, String codePorteur) {
/**
* Crée une demande d'entité élève
- * @param eleve
* @return eleve
*/
public Eleve creeEleveDemande(Sql sql, Eleve eleve) {
/**
* Crée une demande d'entité établissement
- * @param etablissement
* @return etablissement
*/
public Etablissement creeEtablissementDemande(Sql sql, Etablissement etablissement) {
/**
*
- * @param sql
- * @param demandeImport
- * @param etablissementRattachementIdExterne
- * @param estDoublon
- * @param typeRequete
- * @param statut
* @param forceTypeRequeteAjout utilise pour le test de suppresion d'admins locaux
- * @return
*/
public PersEducNat creeDemandePersEducNat(
Sql sql,
/**
* Crée une demande de porteur ent
* @param porteurEnt le porteur ent à créer
- * @return
*/
public PorteurEnt creePorteurEntDemande(Sql sql, PorteurEnt porteurEnt) {
porteurEnt.load(sql)
/**
* Permet de créer une demande de type 'typeRequete' de porteurEnt
- * @param demandeImport
* @param typeRequete le type de la requête
* @return porteurEnt le porteur ent crée
*/
/**
* Crée une demande de type "typeRequete" de structure d'enseignement
- * @param sql
- * @param demandeImport
- * @param etablissementIdExterne
- * @param estDoublon
- * @param typeRequete
- * @param statut
* @param typeStructureAleatoire si false, le type est toujours CLASSE
- * @return
*/
public StructureEnseignement creeStructureEnseignementDemande(
Sql sql,
/**
* Récupère une seule instance d'application contexte (toujours la même)
- * @return
*/
static public ApplicationContext getApplicationContext() {
if (!applicationContext) {
/**
* Récupère un objet Sql sur l'application contexte de l'application
- * @return
*/
public static Sql getSql() {
/**
* Cree une demande de suppression
- * @param importMode
*/
DemandeImportResultat creeDemandeSupression(ImportMode importMode) {
/**
* Verifie que l'entite qui ne devrait pas etre implactee par la desactivation
* est toujours active
- * @param adminLocal
*/
private void verifieAutreEntitePasDesactivee(AdminLocal adminLocal) {
chargePersonne.load(
/**
* Cree une entite qui ne devrait pas etre implactee par la desactivation
- * @param dirInitial
* @param recree si on recree les entites pour le test de desactivation en mode Complet
- * @return
*/
private AdminLocal creeAutreEntite(DemandeImportResultat dirInitial, Boolean recree = false) {
/**
* Verifie que l'entite qui ne devrait pas etre implactee par la desactivation
* est toujours active
- * @param eleve
*/
private void verifieAutreEntitePasDesactivee(Eleve eleve) {
chargePersonne.load(
/**
* Cree une entite qui ne devrait pas etre implactee par la desactivation
- * @param dirInitial
* @param recree si on recree les entites pour le test de desactivation en mode Complet
- * @return
*/
private Eleve creeAutreEntite(DemandeImportResultat dirInitial,
Boolean recree = false,
/**
* Cree une demande de suppression
- * @param importMode
*/
void creeDemandeSupression(ImportMode importMode,
EtatDesactivation etatDesactivation) {
/**
* Verifie que l'entite qui ne devrait pas etre implactee par la desactivation
* est toujours active
- * @param horsAaf
*/
private void verifieAutreEntitePasDesactivee(HorsAaf horsAaf) {
chargePersonne.load(
/**
* Cree une entite qui ne devrait pas etre implactee par la desactivation
- * @param dirInitial
* @param recree si on recree les entites pour le test de desactivation en mode Complet
- * @return
*/
private HorsAaf creeAutreEntite(DemandeImportResultat dirInitial,
Boolean recree = false,
/**
* Cree une entite qui ne devrait pas etre implactee par la desactivation
- * @param dirInitial
* @param recree si on recree les entites pour le test de desactivation en mode Complet
- * @return
*/
private PersEducNat creeAutreEntite(DemandeImportResultat dirInitial,
Boolean recree = false,
/**
* Cree une demande de suppression
- * @param importMode
*/
private DemandeImportResultat creeDemandeSupression(ImportMode importMode,
EtatDesactivation etatDesactivation) {
/**
* Verifie que l'entite qui ne devrait pas etre implactee par la desactivation
* est toujours active
- * @param persEducNat
*/
private void verifieAutreEntitePasDesactivee(PersEducNat persEducNat) {
chargePersonne.load(
/**
* Cree unu demande de suppression d'un porteur
- * @param demandeImport
*/
private void creeDemandeSuppression(DemandeImport demandeImport) {
porteurEntService.creePorteurEntDemande(
/**
* Cree une demande d'import
- * @param importMode
- * @return
*/
private DemandeImport creeDemandeImport(ImportMode importMode) {
return demandeImportService.creeDemandeImport(sql,
/**
* Verifie que l'entite qui ne devrait pas etre implactee par la desactivation
* est toujours active
- * @param eleve
*/
private void verifieAutreEntitePasDesactivee(ResponsableEleve responsableEleve) {
chargePersonne.load(
/**
* Cree une entite qui ne devrait pas etre implactee par la desactivation
- * @param dirInitial
* @param recree si on recree les entites pour le test de desactivation en mode Complet
- * @return
*/
private ResponsableEleve creeAutreEntite(
DemandeImportResultat dirInitial,
/**
* Initialise le comparateur avec l'etat de debut
- * @param chargePersonne
*/
void stockePersonneAvantImport(ChargePersonne chargePersonne) {
lectureAutorite = chargePersonne.autorite.clone()
/**
* Compare avec l'etat actuel
- * @param chargePersonne
* @param seulementPSPPS si true, seuelemnt les PS et les PPS sont comparees
*/
void comparePersonneAvantEtApresImport(ChargePersonne chargePersonne, Boolean seulementPSPPS = false) {
/**
* Retourne la liste des valeurs lié aux paramètres
- * @param params
- * @return
*/
protected List<Object> getParams(Map params) {
List<Object> resultat = []
/**
* Chargement à partir de l'id
- * @param id
*/
public void load(Long id) {
load(["name": "id",
/**
* Chargement à partir d'un couple nom/valeur
- * @param params
*/
public void load(Map params) {
/**
* copie des données d'un enregistrement lues en base sur les propriétés
* de l'objet
- * @param resultat
*/
public void copyFrom(GroovyRowResult resultat) {
/**
* Retourne une liste d'objet du domaine correspondant au critère passé en paramètre
- * @param params
- * @return
*/
public List<? extends DataLoader> findAll(Map params, Sql sql) {
/**
* Retourne une liste de toutes les occurences d'une Classe de domaine
- * @return
*/
public List<? extends DataLoader> findAll(Sql sql) {
/**
* compare un objet quelconque avec l'objet du domaine. Sert
* pour comparer les objets avant et après chargement
- * @param object
- * @return
*/
public Boolean isSame(Object object) {
Boolean resultat = true
/**
* Recule la date de désactivation de l'autorite de 61 jours pour tester le
* passage de l'état de "ACCES_RESTREINT" à "INACTIF"
- * @param autoriteIdExterne
*/
void modifieDateDesactivationAutorite(String autoriteIdExterne) {
String sqlString = """
/**
* Vérifie que l'état de désactivation de l'autorité est celui que l'on attend
- * @param autoriteIdExterne
- * @param fonctionCode
- * @param etatDesactivation
*/
void verifieEtatDesactivationAutorite(String autoriteIdExterne,
String fonctionCode,
/**
* commande sql select
- * @param requete
- * @return
*/
protected def select(String requete) {
return sql.rows(requete)
/**
* commande sql insert avec paramètres
- * @param requete
- * @param params
- * @return
*/
protected def insertParams(String requete, List params) {
sql.execute(requete, params)
/**
* compte le nombre d'enregistrements dans la base
- * @param table
- * @return
*/
protected long count(String table) {
String sqlQuery = "select distinct count(*) as r from " + table
/**
* Recherche le dernier id de la table
- * @param table
- * @return
*/
protected long lastId(String table) {
String sqlQuery = "select max(id) as r from " + table
/**
* lancement du script de traitement d'import
- * @param sql
*/
protected void runScript(Sql sql, CompositeScript script) {
script.execute(sql, false)
/**
* Vérifie une autorité
- * @param lectureAutorite
* @param personneId l'identifiant de la personne crée
* @param autoriteIdExterne l'autorité id externe de l'entité importée
*/
/**
* Vérification des droits d'accés par rapport au profil
* NOM_VERIFICATEUR_ACCES devrait être implementé dans les modules
- * @param session
* @return true/false
*/
private Boolean verifieDroitsAcces(def session) {
/**
* Retourne la liste des pages accessibles pour l'utilisateur connecté
- * @return
*/
protected List<Object> findAllPageAccessibles(Object pages) {
/**
* Retourne l'id de l'établissement courant associé à la session courante
- * @return
*/
protected Long etablissementCourantId() { // Note jtra : cette méthode devrait retourner un Etablissement, pas son id
SecuriteSession securiteSession = getSecuriteSession()
/**
* Indique si le compte de l'utilisateur est restreint
- * @return
*/
protected boolean isAccesRestreint() {
getSecuriteSession().defaultAutorite.aUnAccesRetreint()
/**
* Récupère le MenuInfo correspondant à la page passée en paramètre
- * @param page
* @return le menu de la page
*/
protected MenuInfo readMenuInfo(Object page) {
* - controleur
* - action
* - params
- * @param item
* @return l'url
*/
protected String encodeUneUrl(UrlLabelInfo item) {
/**
* encode toutes les urls des éléments de menu
- * @param lst
*/
protected void encodeToutesLesUrl(List<UrlLabelInfo> lst) {
lst.each {
/**
* A surcharger par les modules
- * @return
*/
protected Collection<ExceptionHandler> getExceptionHandlers() {
return []
}
/**
- * @param typePeriode
* @return le libellé traduit du type de période
*/
String getPeriodeLibelle(TypePeriode typePeriode) {
class FicheEleveMarshallerService {
/**
- * @param ficheEleve
* @return les données de la fiche élève sous forme de map
*/
Map marshallFicheEleve(FicheEleve ficheEleve) {
/**
*
- * @param classe
* @param periodesInfo ajoute l'info sur ses periodes
* @param naturesInfo ajoute l'info sur ses natures de periodes
- * @return
*/
Map marchalleClasse(StructureEnseignement classe,
Boolean periodesInfo,
/**
* Retourne une map : [serviceId:[profs:[[nom:..., prenom:...]], matiere:...]]
* Anti N+1 select
- * @param services
- * @return
*/
private Map mapServiceInfos(List<Service> services) {
/**
* Enregistre le commentaire da la fiche d'élève.
- * @param commentaire
- * @param eleveId id de Personne
+ * @param eleveId id de Personne
* @author bper
*/
def saveCommentaire = {
/**
* Retourne l'autorité associée à l'id d'une personne
- * @param utilisateurPersonneId
- * @return
*/
protected Autorite getAutorite(long utilisateurPersonneId) {
Personne auteur = Personne.get(utilisateurPersonneId)
/**
* Retourne une sécuritéSession associée à l'autorité
- * @param autorite
- * @param codePorteur
* @param chargeGroupes charge les groupes d'utilisateur.
* Vu que ca necessite une requete vers l'annuaire, la valeur par defaut est false.
- * @return
*/
protected SecuriteSession getSecuriteSession(Autorite autorite,
String codePorteur,
/**
* Cherche les ids de groupes d'utilisatuer dans l'annuaire distant
- * @param autoriteIdExterne
- * @return
*/
private List<Long> findGroupeIdsForAutoriteIdExterne(String codePorteur, String autoriteIdExterne) {
distantAutoriteService.getGroupeAutoritesForActeur(
/**
* Vérifie que l'on passe bien par le mapping pour le GET
- * @param params
*/
protected void controleActionShow(Map params) {
/**
* Vérifie que l'on passe bien par le mapping pour le POST
- * @param params
*/
protected void controleActionSave(Map params) {
/**
* Vérifie que l'on passe bien par le mapping pour le PUT
- * @param params
*/
protected void controleActionUpdate(Map params) {
/**
* Vérifie que l'on passe bien par le mapping pour le PUT
- * @param params
*/
protected void controleActionDelete(Map params) {
/**
* controle que l'on fait un appel REST. L'appel direct met un string dans
* la valeur action, l'appel REST met une map dans la valeur action.
- * @param params
*/
private void controleAppelRest(Map params) {
if (params.action instanceof String) {
/**
* retourne un texte descriptif des informations de charset
- * @return
*/
private String findCharsetInfo() {
String resultat =
/**
* retourne un texte descriptif des infos jmx
- * @return
*/
private String findAllJmxSysteme() {
org.lilie.services.eliot.maintenance.jmx.RapportJmx maintenanceJmx =
/**
* Retourne un texte descriptif des variables système
- * @return
*/
private String findAllVarSysteme() {
String resultat = ""
/**
* Déclenche une erreur http xxx lorsqu'un document demandé porte l'id
* "ERRORxxx". Utilisé pour test.
- * @param docIds
* @return true si une erreur a été déclenchée.
*/
private boolean declencheErreur(List<String> docIds) {
/**
* Parse la liste des documents demandés
- * @param params
* @return une liste de String
*/
private List<String> parseDocIds(def params) {
/**
* Traite les paramèters fileds
- * @param params
* @return un FieldsParams
*/
private FieldsParams parseFieldsParams(def params) {
/**
* Récupère les param de pagination
- * @param params
* @return un PaginationParams
*/
private PaginationParams parsePaginationParams(def params) {
}
/**
- * @param e
* @return une erreur comportant un message
*/
private Map getError(WsException e) {
/**
* retourne une chaine décrivant l'état du message pour l'indexation
* seulement
- * @return
*/
String getEtatPourIndexation() {
if (this.etatBrouillon) {
/**
* Constructeur pour le type de moyenne ELEVE_ENSEIGNEMENT_PERIODE.
- * @param eleve
- * @param enseignement
- * @param periode
*/
DirtyMoyenne(Autorite eleve, Enseignement enseignement, Periode periode) {
this.eleve = eleve
/**
* Constructeur pour le type de moyenne ELEVE_SERVICE_PERIODE.
- * @param eleve
- * @param service
- * @param periode
*/
DirtyMoyenne(Autorite eleve, Service service, Periode periode) {
this.eleve = eleve
/**
* Constructeur pour le type de moyenne ELEVE_SOUS_SERVICE_PERIODE.
- * @param eleve
- * @param sousService
- * @param periode
*/
DirtyMoyenne(Autorite eleve, SousService sousService, Periode periode) {
this.eleve = eleve
/**
* Constructeur pour le type de moyenne ELEVE_PERIODE.
- * @param eleve
- * @param periode
*/
DirtyMoyenne(Autorite eleve, Periode periode) {
this.eleve = eleve
/**
* Constructeur pour le type de moyenne ENSEIGNEMENT_PERIODE.
- * @param classe
- * @param enseignement
- * @param periode
*/
DirtyMoyenne(Enseignement enseignement, Periode periode) {
this.classe = enseignement.service.structureEnseignement // attention! c'est une structure, pas une classe
/**
* Constructeur pour le type de moyenne CLASSE_SERVICE_PERIODE.
- * @param classe
- * @param service
- * @param periode
*/
DirtyMoyenne(StructureEnseignement classe, Service service, Periode periode) {
this.classe = classe
/**
* Constructeur pour le type de moyenne CLASSE_SOUS_SERVICE_PERIODE.
- * @param classe
- * @param sousService
- * @param periode
*/
DirtyMoyenne(StructureEnseignement classe, SousService sousService, Periode periode) {
this.classe = classe
/**
* Constructeur pour le type de moyenne CLASSE_PERIODE.
- * @param classe
- * @param periode
*/
DirtyMoyenne(StructureEnseignement classe, Periode periode) {
this.classe = classe
/**
* Coefficient avec le ramenage sur 20 si requis par l'evaluation
- * @return
*/
BigDecimal getCoefficientReel() {
if (!isRamenageSur20Necessaire()) {
/**
* NoteMax avec le ramenage sur 20 si requis par l'evaluation
- * @return
*/
BigDecimal getNoteMaxPossibleAffichee() {
if (!isRamenageSur20Necessaire()) {
/**
* Ramenage sur 20 est applique si l'utilisateur a choisi qu'il veut qu'on
* applique le ramenage et si la note maximale est different de 20.
- * @return
*/
Boolean isRamenageSur20Necessaire() {
return (ramenerSur20 && noteMaxPossible != 20)
/**
* La classe moyenne englobant la veleur numerique ou textuelle
- * @return
*/
Moyenne getObjetMoyenne() {
if (noteTextuelle) {
/**
* La classe moyenne englobant la veleur numerique ou textuelle
- * @return
*/
Moyenne getObjetMoyenne() {
if (noteTextuelle) {
/**
* La classe moyenne englobant la veleur numerique ou textuelle
- * @return
*/
Moyenne getObjetMoyenne() {
if (noteTextuelle) {
/**
* La classe moyenne englobant la veleur numerique ou textuelle
- * @return
*/
Moyenne getObjetMoyenne() {
if (noteTextuelle) {
/**
* Constructeur
- * @param proprieteRequises
*/
TypeMoyenneEnum(List<String> proprieteRequises) {
this.proprieteRequises = proprieteRequises
/**
* Retourne une intervalle "équivalent" :
* T1 <=> S1, T2 <=> S2, T3 => null, ANNEE => null
- * @param intervalle
- * @return
* @author bper
*/
public IntervalleEnum getIntevalleEquivalent() {
/**
* Recupere la nature de periode depuis son nom
- * @param nomNature
- * @return
*/
static NaturePeriode parseNom(String nomNature) {
NaturePeriode naturePeriode = values().find {it.toString() == nomNature}
/**
* Permet de trier les périodes
* @param o - periode
- * @return
* @author bper
*/
public int compareTo(Object o) {
/**
* Retourne la ou les initiales du prénom de la personne
- * @return
*/
public String initiales() {
localPersonneService.getInitiales(prenom)
/**
* retourne les noms d'affichages avec initiales sur le prénom
- * @return
*/
String nomAffichageInitiales() {
if (nom) {
/**
* Retourne le nom personnalisé du cahier.
- * @param acteur
*/
String nomAffichage(Autorite acteur) {
return nomAffichage(acteur, true)
\r
/**\r
* Action déclenchée avant l'insertion en base\r
- * @return\r
*/\r
def beforeInsert() {\r
if (dataStoreId == org.lilie.services.eliot.textes.DataStoreId.DB) {\r
\r
/**\r
* Action déclenchée avant la mise à jour. Ne pas jamais être appelé.\r
- * @return\r
*/\r
def beforeUpdate() {\r
if (dataStoreId == org.lilie.services.eliot.textes.DataStoreId.DB) {\r
\r
/**\r
* Accesseur du blob\r
- * @return\r
*/\r
InputStream getBlob() {\r
return fichierFluxService.getFlux(this)\r
\r
/**\r
* Setter du blob\r
- * @param blob\r
- * @param inputStream\r
- * @return\r
*/\r
def setBlob(InputStream inputStream) {\r
if (!dataStoreId) {\r
/**
* URL formatee pour l'affichage.
* Utile quand on a des caracteres acentues dans l'URL.
- * @return
*/
String getUrlAffichage() {
return (this.url ? URLDecoder.decode(this.url, 'UTF-8') : null)
/**
* Retourne un rapport textes sur la mémoire.
* TODO : récupérer les informations JMX
- * @return
*/
public String rapport(String requete) {
/**
* Permet de loger des informations concernant le cache de niveau 2
- * @param cacheStatistics
- * @return
*/
private List<String> cachetoString(SecondLevelCacheStatistics cacheStatistics) {
List<String> resultat = []
/**
* Retourne un rapport textes sur la mémoire.
* TODO : récupérer les informations JMX
- * @return
*/
public String rapport(String requete) {
/**
* Retourne un rapport textes sur la mémoire.
* TODO : récupérer les informations JMX
- * @return
*/
public String rapport(def params, def request) {
if (log.debugEnabled) {
/**
* Retourne un rapport texte sur le datasource
- * @return
*/
public String rapport(String requete) {
"\n" + rapportAll(dataSource) + "\n"
/**
* Retourne un rapport textes sur la mémoire.
* TODO : récupérer les informations JMX
- * @return
*/
public String rapport(String requete) {
* true
* - ajouter les permissions établies par valeurPermissionsExplicite aux
* permissions existantes
- * @param autorite
- * @param item
- * @param estProprietaire
- * @param valeurPermissionsExplicite
- * @return
*/
public Autorisation insertUpdateAutorisation(Autorite autorite,
Item item,
/**
* Recherche une autorisation à partir de l'autorité et de l'item
- * @param autorite
- * @param item
* @return l'autorisation de l'autorité sur l'item si elle existe, sinon null
*/
Autorisation findAutorisation(Autorite autorite, Item item) {
* automatiquement créée si elle n'existe pas en base
* @param type le type de l'autorité
* @param idExterne l'idExterne de l'autorité
- * @param forceCreation
* @return l'autorité
*/
Autorite getAutoriteForTypeAndIdExterne(String type,
* automatiquement créée si elle n'existe pas en base
* @param type le type de l'autorité
* @param idExterne l'idExterne de l'autorité
- * @param forceCreation
* @return l'autorités
* @author bahj
*
* Si le flag forceCreation est positionné à true, l'autorité est
* automatiquement créée si elle n'existe pas en base
* @param autoriteEncodee une autorité encodée
- * @param forceCreation
* @return l'autorité
*/
Autorite getAutoriteForAutoriteEncodee(String autoriteEncodee,
* Si le flag forceCreation est positionné à true, l'autorité est
* automatiquement créée si elle n'existe pas en base
* @param autoriteEncodee une autorité encodée
- * @param forceCreation
* @return l'autorités
* @author bahj
*/
/**
* Retourne l'encodage d'une autorité à partir de son type et de son idExterne
- * @param type
- * @param idExerne
- * @return
*/
String getAutoriteEncodeeForTypeAndIdExterne(String type, String idExterne) {
return "T$type-ID$idExterne"
/**
* Indique si l'autorité encodée est un compte restreint
- * @param autoriteEncodee
- * @return
*/
public boolean isCompteRestreint(String autoriteEncodee) {
getAutoriteForAutoriteEncodee(autoriteEncodee).aUnAccesRetreint()
/**
* Vérifie que le version de la BDD est compatible avec celle de l'application.
- * @param grailsApplication
* @throws IllegalStateException
* @throws IllegalArgumentException
* @author bper
/**
* Retourne les groupes distants qui correspondent aux groupes locaux en paramètre
- * @param securiteSession
- * @param groupesLocaux
- * @return
*/
public List<GroupeInfo> findAllGroupeDistantByGoupesLocaux(SecuriteSession securiteSession, List<ProprietesScolarite> groupesLocaux) {
/**
* Supprime tous les Items de liste
- * @param items
*/
void supprimeTous(List<Item> items) {
if (items?.size() > 0) {
/**
* Verifie si l;autorite est active
- * @param idExterne
* @param typeAutorite type d'autorite, null par defaut
* @return true si l'autorite est active
*/
/**
* Supprime toutes les Autorités de liste
- * @param autorites
*/
void supprimeToutes(List<Autorite> autorites) {
if (autorites?.size() > 0) {
}
/**
- * @param autoriteIds
* @return La liste des autorites correspondant à la liste des ids
*/
List<Autorite> findAllAutorites(List<Long> autoriteIds) {
/**
* Retourne le Calendar correspondant aux coordonnées
- * @return
*/
Calendar getCalendar() {
Calendar cal = Calendar.getInstance()
/**
* Indique que le jour n'existe pas dans le calendrier (ex 30/02)
- * @return
*/
Boolean isJourInexistant() {
Calendar cal = Calendar.getInstance()
* @param eleves : liste des élèves
* @param pref : PreferenceEtablisement de l'étab
* @param tableauDeBordParams : paramètres de la requête
- * @return
*/
private RegistreMensuelDataCollector getDataCollectorForAllElevesAndMois(List<Personne> eleves,
PreferencesEtablissementAbsences pref,
* @param curseur : coordonnées de la cellule de tableau à traiter
* @param dataCollector : objet contenant toutes les données nécessaires
* au calcul
- * @return
*/
RegistreDemiJourInfo getInfoDemiJour(RegistreMensuelCurseurCellule curseur,
RegistreMensuelDataCollector dataCollector
/**
* Indique si l'heure est du matin selon le CalendrierInfo
- * @param dateHeureDebut
- * @param calendrierInfo
- * @return
*/
private Boolean isMatin(Date dateHeureDebut, CalendrierInfo calendrierInfo) {
Calendar cal = Calendar.getInstance()
/**
* Indique si la demi-journée est fermée dans le calendrier annuel
- * @param calendar
- * @param matin
- * @param jourFerieInfos
- * @return
*/
boolean isDemiJourFermeAnnuel(Calendar calendar,
boolean matin,
/**
* Indique si la demi-journée est fermée dans le calendrier hebdo
- * @param cal
- * @param matin
- * @param plageHoraires
- * @return
*/
private boolean isDemiJourFermeHebdo(Calendar cal,
boolean matin,
/**
* Constitue un objet regroupant les données nécessaires aux calculs
* du détail du jour
- * @param command
- * @param pref
- * @return
*/
RegistreMensuelDataCollector getDataCollectorForDetailJour(
DetailJourCommand command,
/**
* Transforme les AbsenceDatas en DetailJourInfo
- * @param datas
- * @return
*/
DetailJourInfo formateDetailJour(DetailJourCommand command,
RegistreMensuelDataCollector dataCollector) {
/**
* Extrait l'absenceData correspondant à la plage
- * @param dataCollector
- * @param plage
- * @return
*/
AbsenceInfo getAbsenceData(RegistreMensuelDataCollector dataCollector,
PlageHoraire plage) {
/**
* Indique si la plage horaire est ouverte selon le planning hebdo
- * @param command
- * @param plage
- * @return
*/
Boolean isPlageFermeeHebdo(DetailJourCommand command, PlageHoraire plage) {
String nomProp
/**
* Recherche les données d'absences pour un jour et un élève donné
- * @param eleve
- * @param jour
- * @return
*/
List<AbsenceInfo> getAbsenceDatasForEleveAndJour(DetailJourCommand command) {
/**
* Recherche les données d'absences pour un mois et une liste d'élèves donnés
- * @param eleve
- * @param jour
- * @return
*/
List<AbsenceInfo> getAbsenceDatasForAllElevesAndDates(List<Personne> eleves,
RegistreMensuelCommand command) {
/**
* Construit les paramètres de la requête pour récupérer les données d'absences
* pour une liste d'élèves et un mois
- * @param command
- * @return
*/
Map getParametresAllElevesAndDates(List<Personne> eleves,
RegistreMensuelCommand command) {
/**
* Crée la chaine hql pour la récupération des données d'absence
- * @param command
- * @return
*/
String getHqlAbsenceDatasForAllElevesAndDates(RegistreMensuelCommand command) {
String hql = """select al, appel, absenceJournee, autorite.id
/**
* Transforme les résultats bruts en liste d'AbsenceData
- * @param datas
- * @return
*/
List<AbsenceInfo> creeListeAbsenceData(List datas) {
List<AbsenceInfo> result = []
/**
* Construit les paramètres de la requête pour récupérer les données d'absences
* pour un jour et un élève donnés
- * @param command
- * @return
*/
private Map getParametresEleveAndJour(DetailJourCommand command) {
Personne eleve = localPersonneService.findPersonneByAutoriteId(command.eleveId)
/**
* Retourne le nombre de plages horaires de la chronologie
- * @return
*/
public Integer getPlageHoraireCount() {
/**
* Retourne le nombre de journée de la chronologie
- * @return
*/
public Integer getJourneeCount() {
allJournee.size()
/**
* Retourne le nombre de 1/2 journée de la chronologie
- * @return
*/
public Integer getDemiJourneeCount() {
/**
* Retourne la journée correspondant à la date. si celle-ci n'existe pas, elle sera construite
- * @param date
- * @return
*/
public Journee findJournee(Date date) {
Journee evenementJournee = allJournee.find {
/**
* Retourne le nombre de 1/2 journée de la valeur
- * @return
*/
public Integer getNbDemiJour() {
nbDemiJour
}
/**
- * @param code
- * @return
*/
private DemiJourneeEnum getDemiJournee(Integer code) {
* APRES_MIDI + MATIN_ET_APRES_MIDI= MATIN_ET_APRES_MIDI
* MATIN_ET_APRES_MIDI + MATIN_ET_APRES_MIDI= MATIN_ET_APRES_MIDI
*
- * @param demiJournee
- * @return
*/
public DemiJourneeEnum plus(DemiJourneeEnum demiJournee) {
PasDeDecompteService pasDeDecompteService
/**
- * @param securiteSession
- * @param eleve
- * @param dateDebut
- * @param dateFin
- * @param plageHoraires
* @return les infos d'emploi du temps pour un élève et une période
*/
public List<EmploiDuTemps> findEmploiDuTempsEleveForPeriode(SecuriteSession securiteSession,
* Remonte l'emploi du temps de la structure d'enseignement
* Si c'est une classe, l'emploi du temps des groupes de la classe est remonté aussi
* Si c'est un groupe, seul l'emploi du temps du groupe est remonté
- * @return
*/
public List<EmploiDuTemps> findEmploiDuTemps(StructureEnseignement structure,
Date dateDebut,
}
/**
- * @param evenements
- * @param appels
- * @param plageHoraires
* @return la liste des EmploiDuTemps à partir des données fournies
*/
private List<EmploiDuTemps> getAllEmploiDuTempsInfo(
}
/**
- * @param evenement
- * @param plageHoraires
* @return Une liste de EmploiDuTemps correspondant à l'événement
*/
private List<EmploiDuTemps> getAllEmploiDuTempsInfoForEvenement(
}
/**
- * @param appel
* @return une liste de EmploiDuTemps correspondant à l'appel
*/
private List<EmploiDuTemps> getAllEmploiDuTempsInfoForAppel(
/**
* Retourne un volume horaire pour une liste de structures d'enseignement et sur une période donnée
* L'unité de la valeur de retour dépend du pas de décompte (heure, 1/2 journée ou journée)
- * @param pref
- * @param allStructureEnseignement
- * @param pasDecompte
* @param dateDebut : début période
* @param dateFin : fin période
- * @return
*/
public Float volumeHorairePourAllClasse(PreferencesEtablissementAbsences pref,
List<StructureEnseignement> allStructureEnseignement,
/**
* Retourne un volume horaire en fonction d'une liste d'évènements. L'unité de retour dépend de la valeur
* du pas de décompte (heure, 1/2 journée, journée)
- * @param pref
- * @param allEvenement
- * @param pasDecompte
- * @return
*/
public Float volumeHoraire(PreferencesEtablissementAbsences pref,
List<Evenement> allEvenement,
/**
* Permet de classer les évènement par rapport à leur chronologie, et déterminer une durée globale en fonction
* du pas de décompte
- * @param pref
- * @param allEvenement
- * @param pasDecompte
- * @return
*/
private ChronologieEvenement construitChronologieEvenement(
PreferencesEtablissementAbsences pref,
/**
* volume horaire par rapport à une liste d'élèves
- * @param pref
- * @param allEleves
- * @param pasDecompte
- * @param dateDebut
- * @param dateFin
- * @return
*/
public Float volumeHorairePourListeEleves(PreferencesEtablissementAbsences pref,
List<Personne> allEleves,
/**
* Calcule les volumes horaires mensuels d'une liste de structure d'enseignements
- * @param criteres
- * @param pref
* @return une VolumesAllStructureEnseignements
*/
VolumesAllStructureEnseignements getVolumeHoraireStructures(
/**
* Retourne le volume horaire mensuels par structure d'enseignement selon
* le calendrier de l'établissement
- * @param criteres
* @return VolumesAllStructureEnseignements
*/
private VolumesAllStructureEnseignements getVolumeHoraireStructureAvecCalendrier(
/**
* Calcule les volumes horaires mensuel des structures selon l'emploi du temps
- * @param criteres
* @return VolumesAllStructureEnseignements
*/
private VolumesAllStructureEnseignements getVolumeHoraireStructuresAvecEmploiDuTemps(
/**
* Indique si on a des evenement le matin, l'après midi ou les
- * @return
*/
public DemiJourneeEnum getDemiJourneeEnum() {
/**
* Compte le nombre de demi journée de la journée
- * @return
*/
public Integer getDemiJourneeCount() {
getDemiJourneeEnum().nbDemiJour
/**
* Compte le nombre de plage horaire
- * @return
*/
public Integer getPlageHoraireCount() {
/**
* Retourne le code correspondant au paramètre de longueur de plage
- * @param preferences
* @return 1 pour une heure, 2 pour une demi-heure
*/
Byte getCodeLongueurPlage(preferences) {
/**
* Retourne l'enum pas de décompte à partir de son libelle
- * @param libelle
* @return pas de décompte correspandant au libellé
*/
static PasDeDecompteEnum parseByLibelle(String libelle) {
/**
* Retourne l'enum pas de décompte à partir de son code
- * @param code
* @return pas de décompte correspandant au code
*/
static PasDeDecompteEnum parseByCode(int code) {
/**
* Récupère les types d'incidents
* Si aucun types d'incidents n'est crées, il crée les types par défauts
- * @param pref
* @return typeIncidents : la liste des types d'incidents
*/
List<TypeIncident> getTypesIncident(PreferencesEtablissementAbsences pref) {
* vérifie les propriétés du type
* - le nombre de caractères mpax
* - l'unicité
- * @param type
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Récupère les types de punition
* Si aucun types de punition n'est crées, il crée les types par défauts
- * @param pref
* @return typePunition : la liste des types de punition
*/
List<TypePunition> getTypesPunition(PreferencesEtablissementAbsences pref)
* vérifie les propriétés du type
* - le nombre de caractères mpax
* - l'unicité
- * @param type
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Récupère les types de sanctions
* Si aucun types de sanction n'est crées, il crée les types par défauts
- * @param pref
* @return TypesSanction : la liste des types de sanction
*/
List<TypeSanction> getTypesSanction(PreferencesEtablissementAbsences pref)
* vérifie les propriétés du type
* - le nombre de caractères mpax
* - l'unicité
- * @param type
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Retourne la somme des pas de décompte du jour à évaluer
- * @param pasDeDecompte
* @return nbPasDeDecompteJourAEvaluer
*/
Float getNbPasDeDecompte(String pasDeDecompte){
/**
* Ajoute un jour à évaluer à la liste des jours à évaluer
- * @param date
- * @param nbPasDeDecompteMatin
- * @param nbPasDeDecompteApresMidi
*/
void addJourAEvaluer(Date date, Float nbPasDeDecompteMatin, Float nbPasDeDecompteApresMidi){
/**
* Retourne la somme des pas de décompte de tous les jours à évaluer
- * @param pasDeDecompte
* @return nbPasDeDecompteAllJourAEvaluer
*/
Float countPasDeDecompte(String pasDeDecompte) {
/**
* Ajoute un incrément à la valeur correspondant à l'élève et à la période
- * @param structureEnseignement
- * @param eleve
- * @param date
- * @param valeur
*/
void incrementeValeur(
StructureEnseignement structureEnseignement,
/**
* Retourne la bonne ligne de statistiques selon les paramètres
- * @param struct
- * @param personne
* @return une StatsMensuellesLigne
*/
StatsMensuellesLigne getLigne(StructureEnseignement structureEnseignement,
/**
* Transforme les résultats en résultats en pourcentage en utilisant les
* données de volume horaires des structures d'enseignement
- * @param volumesAllStructureEnseignements
*/
void calculeVolumesEffectifs(
VolumesAllStructureEnseignements volumesAllStructureEnseignements,
/**
* Déduit le niveau de détail demandé en fonction des critères
- * @return
*/
NiveauDetail getNiveauDetail() {
if(isResultatsParNiveau){
/**
* Calcule les stats selon les critères passés en paramètre
- * @param criteres
- * @return un StatsMensuelles
+ * @return un StatsMensuelles
*/
StatsMensuelles calculeStatsMensuelles(SecuriteSession securiteSession,
StatsMensuellesParams criteres,
/**
* Opération de comptage des infos d'absences/retard sur une période
- * @param criteres
- * @param pref
* @return un objet stat mensuelle contenant les infos de comptage définie par le paramètre critères
*/
private StatsMensuelles comptageStatistique(SecuriteSession securiteSession,
/**
* Transforme les résutlats en pourcentage par rapport à l'emploi du temps
- * @param criteres
- * @param securiteSession
- * @param pref
* @param result : les stats mensuelles transformées
*/
private StatsMensuelles transformeEnPourcentageSurEmploiDuTemps(
/**
* Crée les lignes vides
- * @param statsMensuelles
- * @param statsMensuellesParams
* @return les stats initialisées
*/
private StatsMensuelles initialiseLignes(
/**
* Crée les lignes vides pour les niveaux de l'établissement
- * @param statsMensuelles
- * @param statsMensuellesParams
* @return les stats modifiées
*/
private StatsMensuelles initialiseLignesNiveaux(
/**
* Crée les lignes vides pour la liste des classes
- * @param statsMensuelles
- * @param statsMensuellesParams
* @return Les statistiques modifiées
*/
private StatsMensuelles initialiseLignesStructures(
/**
* Crée les lignes vides pour la liste d'élèves
- * @param statsMensuelles
- * @param statsMensuellesParams
* @return les StatsMensuelles modifiées
*/
private StatsMensuelles initialiseLignesEleves(
/**
* Calcule les stats des retards ou des départs selon les critères
- * @param criteres
- * @param stats
*/
private void calculeStatsMensuellesRetardOrDepart(StatsMensuellesParams criteres,
StatsMensuelles stats
* @param structuresIds : liste des structures d'enseignements
* @param motifsIds : liste des motifs ids
* @param isRetard : définit si c'est un retard ou un départ
- * @param debut
- * @param fin
- * @return
*/
private List executeRequeteRetardsOrDeparts(StatsMensuellesParams criteres,
Boolean isRetard,
* @param typesPunitioIds : liste de type punitions ids
* @param debut : date de début de la recherche
* @param fin : date de fin de la recherche
- * @return
*/
private final static Closure EXECUTE_REQUETE_PUNITIONS = {List<Long> structuresIds,
List<Long> typesPunitionIds,
* @param typesSanctionIds : liste de type de sanctions ids
* @param debut : date de début de la recherche
* @param fin : date de fin de la recherche
- * @return
*/
private static final Closure EXECUTE_REQUETE_SANCTIONS = { List<Long> structuresIds,
List<Long> typesSanctionIds,
* @param typesIncidentsIds : liste de type des incidents ids
* @param debut : date de début de la recherche
* @param fin : date de fin de la recherche
- * @return
*/
private static final Closure EXECUTE_REQUETE_INCIDENTS = { List<Long> structuresIds,
List<Long> typesIncidentsIds,
/**
* Calcule la liste des mois selon les critères
- * @param criteres
* @return une List<Mois>
*/
private List<Mois> calculeListeMois(StatsMensuellesParams criteres) {
/**
* Retourne la ligne de valeur correspondant au mois passé en paramètre
- * @param mois
* @return une StatsMensuellesValeur
*/
StatsMensuellesValeur findOrCreateStatValeur(Mois mois) {
/**
* Retourne la date de fin d'une période
* si c'est null, on renvoit la date de fin de l'objet calendrier
- * @param periode
- * @return
*/
Date getPeriodeDateFin(Periode periode){
if(periode.dateFin){
}
/**
- * @param date
* @return la Periode correspondant à la date
*/
private Periode getPeriode(Date date) {
/**
* Ordonne les lignes de résultat selon les critères
- * @param tableauDeBordParams
*/
void ordonneResultat(TableauDeBordParams tableauDeBordParams) {
Closure comparateur = null
/**
* Recherche les données d'absences nécessaires au calcul en fonction
* des critères et/ou de la liste des élèves
- * @param criteres
- * @param tableauDeBord
- * @return une List<AbsenceInfo>
+ * @return une List<AbsenceInfo>
*/
List<AbsenceInfo> findAbsenceInfos(
TableauDeBordParams criteres,
/**
* Retourne les données d'absences pour les structures et la période
- * @param tableauDeBordParams
* @return une liste contenant des tableaux avec
* - la ligne d'appel
* - l'appel
/**
* Contruit la portion de hql permettant de filtrer sur le type d'absences
- * @param typeAbsence
* @return une chaine
*/
private String construitHqlRestriction(TypeAbsencesACompterEnum typeAbsence) {
/**
* Calcule le nombre d'absences non valables
- * @param criteres
- * @param tableauDeBord
- * @param pref
*/
void calculeLignesAbsencesNonValables(TableauDeBordParams criteres,
TableauDeBord tableauDeBord,
/**
* Calcule le nombre d'absences (avec ou sans motif)
- * @param criteres
- * @param tableauDeBord
- * @param pref
*/
void calculeLignesAbsencesToutes(TableauDeBordParams criteres,
TableauDeBord tableauDeBord,
}
/**
* Calcule le nombre d'absences "avec motif"
- * @param criteres
- * @param tableauDeBord
- * @param pref
*/
void calculeLignesAbsencesAvecMotif(TableauDeBordParams criteres,
TableauDeBord tableauDeBord,
/**
* Calcule le nombre d'absences "sans motif"
- * @param criteres
- * @param tableauDeBord
- * @param pref
*/
void calculeLignesAbsencesSansMotif(TableauDeBordParams criteres,
TableauDeBord tableauDeBord,
/**
* Recherche un la ligne de tableau de bord d'un élève dans le tableau de bord
- * @param tableauDeBord
- * @param idEleve
- * @return
*/
private TableauDeBordLigne findTableauDeBordLigne(
TableauDeBord tableauDeBord, Long idEleve) {
/**
* Retourne les événements par mois d'une structure d'enseignement
- * @param structureEnseignement
* @return EvenementsUneStructureParMois
*/
EvenementsUneStructureParMois findOrCreateEvenementStructure(
/**
* Ajoute un événement à un mois
- * @param evenement
- * @param mois
*/
void addEvenementMois(Evenement evenement, Mois mois){
getEvenementDuMois(mois).add(evenement)
/**
* Retourne les événements du mois
- * @param mois
* @return List<Evenement>
*/
List<Evenement> getEvenementDuMois(mois){
/**
* Retourne les infos du menu d'aide
- * @param securiteSession
* @return BreadCrumbsItemInfo
*/
AideItemInfo getMenuAideInfo(SecuriteSession securiteSession) {
/**
* Retourne la liste des docs accessibles par l'utilisateur.
* Méthode surchargée dans chaque application
- * @param fonctions
* @return une liste d'URL relatives
*/
protected List<MenuAideInfo> getListeDocs(SecuriteSession securiteSession,
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
return null
/**
* Retourne la liste des fonctions de l'utilisateur courant
- * @param securiteSession
* @return List < FonctionEnum >
*/
private List<FonctionEnum> getListeFonctionsForSecuriteSession(
/**
* Récupère la liste des groupes étendus à partir des informations de
* la session
- * @param securiteSession
- * @return
*/
public List<RessourceIndexeeInfo> findAllGroupeEtendu(SecuriteSession securiteSession) {
return internalFindAllGroupeEtendu(securiteSession.acteur.idExterne, securiteSession.codePorteurENT)
/**
* Récupère la liste des groupes etendus qui sont accessibles à l'utilisateur
* @param idExterne : id externe de l'utilisateur
- * @return
*/
public List<RessourceIndexeeInfo> findAllGroupeEtenduByIdExterne(String idExterne, String codePorteur) {
internalFindAllGroupeEtendu(
/**
* Retrouve le libelle d'un groupe par rapport à son id
- * @param securiteSession
- * @param id
- * @return
*/
public String findLibelleById(SecuriteSession securiteSession, String idExterne) {
/**
* Retourne le Mef de l'élève
- * @param eleve
- * @param anneeScolaire
* @return mef
* @author bper
*/
}
/**
- * @param id
* @return l'AbsenceType identifiée par id
* @throws IllegalArgumentException si id ne correspond pas à un id valide
*/
/**
* Ajoute une absence associée à une personne
- * @param personne
- * @param absenceInfo
*/
public void ajouteAbsence(Personne personne, BilanAbsenceInfo absenceInfo) {
estTrie = false
/**
* Retourne les appels de la liste avec leurs plages horaires fetchées
- * @param appels
* @return une List<Appel>
*/
private List findAllAppelsWithPlages(List<Long> appelIds) {
}
/**
- * @param priseEnCompteMotif
* @return la restriction HQL pour tenir compte de la prise en compte des
* motifs dans les bulletins ou les stats
*/
/**
* Calcule le noombre d'absences non excusées pour un élève et une période
* @param pref : les préférences de l'établissement
- * @param eleve
- * @param dateDebut
- * @param dateFin
* @return un Float
*/
private Float calculeAbsencesNonExcuseesForEleveAndPeriode(
/**
* Fait le compte des absences excusées pour l'élève sur la période
* @param pref : les préférences établissement
- * @param eleve
- * @param dateDebut
- * @param dateFin
* @return un float
*/
private Float calculeAbsencesExcuseesForEleveAndPeriode(
/**
* Fait le comptage des absences en jours
- * @param appelsDatas
* @return un Float
*/
private Float calculeCountJour(List appelsDatas) {
/**
* Fait le comptage des absences en demi-journées
- * @param appelsDatas
* @return un Float
*/
private Float calculeCountDemiJour(List appelsDatas, List<PlageHoraire> plages) {
/**
* Retourne la date et heure de début d'une ligne de data
- * @param data
- * @return
*/
private Date getDateDebut(def data) {
Appel appel = (Appel) data[1]
/**
* Fait le comptage des absences en heures
- * @param appelsDatas
* @return un Float
*/
private Float calculeCountHeure(PreferencesEtablissementAbsences pref,
/**
* Retourne le numéro (1 ou 2) de la dernière demi-journée de l'appelLigne
- * @param appelLigne
* @param plages : plages horaires de l'établissement
* @return 1 si l'appel se termine le matin, 2 pour l'après-midi
*/
/**
* Retourne le nombre de demi-journées concernées par un AppelLigne
- * @param appelLigne
* @param plages : les plages horaires de l'établissement
* @return un Byte
*/
}
/**
- * @param value
* @return l'arrondi supérieur
*/
private int arrondiSuperieur(Float value) {
* - la Personne élève
* - l'absenceJournee
* @param preferences les préférences de l'établissement courant
- * @return
*/
List<StatAbsences> getStatsAbsencesByEleveFromData(
BilanAbsencesParPersonneInfo datas,
/**
* Retourne la liste des absences excusées
- * @param absencesParType
- * @param preferences
* @return List < StatAbsences >
*/
private extraitAbsencesExcusees(
/**
* Retourne la ligne de stats correspondant à l'élève en la créant si nécessaire
- * @param eleve
- * @param listEleveStats
* @return une ligne de stats : StatAbsences
*/
private StatAbsences getStatsForEleve(Personne eleve,
/**
* Extrait les absences non excusées
- * @param absencesParType
- * @param preferences
- * @param listEleveStats
*/
private extraitAbsencesNonExcusees(
Map<String, BilanAbsencesParPersonneInfo> absencesParType,
/**
* Extrait les absences justifiées recevables
- * @param absencesParType
- * @param preferences
- * @param listEleveStats
*/
private extraitAbsencesJustifieesRecevables(
Map<String, BilanAbsencesParPersonneInfo> absencesParType,
/**
* Extrait les absences justifiées non recevables
- * @param absencesParType
- * @param preferences
- * @param listEleveStats
*/
private extraitAbsencesJustifieesNonRecevables(
Map<String, BilanAbsencesParPersonneInfo> absencesParType,
/**
* Retourne une map associant à chaque élève le nombre
- * @param datas
- * @param pref
- * @return
*/
Map calculeNbAbsencesParEleve(BilanAbsencesParPersonneInfo datas,
PreferencesEtablissementAbsences pref
/**
* Calcul le nombre de retard pour chaque élève
- * @param datas
* @return une map sous la forme [
* eleve (personne) : nb de retard
* ]
/**
* Calcul le nombre de départs anticipés pour chaque élève
- * @param datas
* @return une map sous la forme [
* eleve (personne) : nb de retard
* ]
class IncidentService {
/**
- * @param criteres
* @return une liste d'incidents correspondant aux critères
*/
List<Incident> findIncidentsForCriteres(DisciplineCriteresRecherche criteres) {
class PunitionService {
/**
- * @param criteres
* @return une liste de punitions correspondant aux critères
*/
List<Punition> findPunitionsForCriteres(DisciplineCriteresRecherche criteres) {
*/
class SanctionService {
/**
- * @param criteres
* @return une liste de sanctions correspondant aux critères
*/
List<Sanction> findSanctionsForCriteres(DisciplineCriteresRecherche criteres) {
/**
* Permet de retrouver la valeur de l'enum par rapport
* au fichier
- * @param fichier
- * @return
*/
private AffichageEnum getAffichageEnum(Fichier fichier) {
/**
* construction d'un objet chemin pour l'affichage
- * @param fichier
* @return un objet affichage contenant le texte du chemin
* @author : othe
*/
/**
* récupération du chemin à afficher
- * @param securiteSession
- * @param fichier
* @param cheminParent : indique si on doit afficher uniquement le chemin parent
* Dans le cas contraire on affiche le chemin complet
* @return la chaine à afficher
* Supprime les 'nbElements' premiers éléments d'un chemin sous forme de String
* @param pathStr un chemin absolu sous forme de String
* @param nbElements le nombre d'éléments à supprimer (à partir de la racine)
- * @param cheminParent
* @return un chemin relatif obtenu en supprimant les 'nbElements' premiers
* éléments du chemin 'pathStr'
*/
/**
* Reconstruit le chemin en enlevant les suffixes pour chaque nom de noeud
- * @param chemin
- * @return
*/
protected String traitementSuffixeNoeuds(String chemin) {
String[] pathStrElements = chemin.split('/')
/**
* Sépare les différents nom de noeud sous forme d'un tableau de chaines
- * @param path
- * @return
*/
public String[] splitPath(String path) {
if (path.substring(0, 1) == '/') {
/**
* Recherche le nom d'une organisation par son Id
- * @param orgIdRecherche
* @return le nom de l'organisation
*/
protected String findOrganisationNom(String orgIdRecherche) {
/**
* * Créee un verrou
- * @param securiteSession
*/
synchronized static void creeVerrou(SecuriteSession securiteSession) {
creeFichierVerrou(securiteSession)
/**
* Libère un fichier verrou associé à un traitement de bascule d'année
- * @param securiteSession
- * @param basculeAnneeInfo
*/
private synchronized static void libereFichierVerrou() {
File fichierVerrou = new File(getVerrouAbsoluePath())
/**
* Extrait l'acteur des metaDonnées
- * @param metaDonneesInfo
- * @param securiteSession
- * @param rapport
* @return un Acteur
*/
private Acteur extraitActeurProprietaire(DocsImportEspacePersoMetaDonneesInfo metaDonneesInfo,
/**
* Calcule un nom de fichier disponible
- * @param securiteSession
- * @param dossierParent
- * @param nomFichier
* @return Le nom du fichier suffixé par un indice
*/
String calculeNomFichier(SecuriteSession securiteSession,
/**
* Traite une erreur à la création d'un chapitre
* @param uai : code d'établissement
- * @param rapportPrincipal
*/
private void traiteErreurValiderRepertoire(String urlRacine,
DocsImportRapport rapportPrincipal) {
* @param e : exception
* @param dossierParent : le dossier dans lequel le document aurait du être
* créé
- * @param autoriteProprietaire
* @param rapport : ajouter les erreurs dans ce rapport
*/
private void traiteErreurParseDocument(Exception e,
/**
* Traite une erreur survenue durant la recherche d'un acteur
- * @param e
- * @param proprietaireInfo
- * @param rapport
*/
private void traiteErreurRechercheActeur(Exception e,
DocsImportProprietaireInfo proprietaireInfo,
* Si le message est en état 'ERREUR_DETECTE' il passe en 'ERREUR_PERSISTANTE',
* autrement le message le message passe en 'ERREUR_DETECTE'.
* La méthode est exception-save et session-independent.
- * @param message
*/
@SuppressWarnings('CatchException') // JTRA
void marqueMessageEnErreur(Message message) {
/**
* Gère la création ou la modification d'un brouillon
- * @param securiteSession
- * @param params
- * @return
*/
Message enregistreBrouillon(SecuriteSession securiteSession,
EnvoiMessageParams params) {
/**
* Modifie un brouillon
- * @param securiteSession
* @param brouillon brouillom
* @param params nouvelles valeurs
- * @return
*/
Message modifieBrouillon(SecuriteSession securiteSession,
Message brouillon,
/**
* Envoi du brouillon. Le brouillon est changé en message normal
- * @param securiteSession
- * @param brouillon
* @return le message envoyé
*/
Message envoyerBrouillon(SecuriteSession securiteSession, Message brouillon)
/**
* Envoi un message existant
- * @param message
- * @param securiteSession
- * @return
*/
private Message envoyerMessage(SecuriteSession securiteSession, Message message)
throws EnvoiMessageSansSujetException, EnvoiMessageSansDestinataireException {
/**
* Mettre les messages à la corbeille
- * @param messageLecteursASupprimer
*/
def metListeMessageLecteurALaCorbeille(List<MessageLecteur> messageLecteursASupprimer) {
messageLecteursASupprimer.each { MessageLecteur messageLecteur ->
/**
* Vérifie que la securiteSession et les messageLecteurs concernent la même
* autorité
- * @param securiteSession
- * @param messageLecteurs
*/
void verifieDroitsSuppressionMessageLecteur(SecuriteSession securiteSession,
List<MessageLecteur> messageLecteurs) {
/**
* Vérifie pour chaque message s'il a encore des messageLecteurs et le
* supprime s'il n'en a plus
- * @param messages
*/
private void tenteSuppressionMessages(Set<Message> messages) {
if (messages.size() == 0) {
/**
* Marque un message comme lu
- * @param securiteSession
* @param message message qui est lu
*/
void lisMessage(SecuriteSession securiteSession, Message message) {
/**
* Retourne le message correspondant à l'ID
- * @param messageId
* @return un Message
*/
Message getMessage(Long messageId) {
/**
* Crée MessageMessagerieDto à partir de Message.
- * @param message
* @return MessageMessagerieDto
* @author msan
* @author bper
/**
* Distribution d'un message par email
- * @param redirectionInfo
* @author jtra , msan
*/
@SuppressWarnings('CatchException')
/**
* Traite une erreur qui se produit durant l'envoi d'un message par email
- * @param messageLecteur
- * @param e
* @author jtra
*/
private void traiteErreurEnvoiEmail(MessageLecteur messageLecteur,
/**
* Cherche tous les message lecteurs en attente de redirection associés à
* leur adresses email de redirection.
- * @param porteurENTInfo
* @return une liste de [MessageLecteur, String - email]
* @author msan
*/
/**
* Cherche tous les message lecteurs en erreur de redirection associés à
* leur adresses email de redirection.
- * @param porteurENTInfo
* @return une liste de [MessageLecteur, String - email]
* @author msan
*/
/**
* Copie des options de bulletin d'une classe source vers une classe cible et pour une portée donnée
- * @param classeSource
- * @param classeCible
- * @param portee
*/
private void copie(StructureEnseignement classeSource, StructureEnseignement classeCible, String portee) {
/**
* Permet de copier les propriétés
- * @param bulletinOptionsSource
- * @param bulletinOptionsCible
*/
private void copyProperties(BulletinOptions bulletinOptionsSource, BulletinOptions bulletinOptionsCible) {
bulletinOptionsCible.moyenneGenerale = bulletinOptionsSource.moyenneGenerale
}
/**
- * @param activiteAvecDoc
* @return une Map représentant les pièces jointes de l'activité
*/
private Map getDocumentsModele(ActiviteAvecDocumentsCatalogue activiteAvecDoc) {
}
/**
- * @param activiteAvecDoc
* @return la date "Donnée le formatée
*/
private String getDateDonneeLe(ActiviteAvecDocumentsCatalogue activiteAvecDoc) {
}
/**
- * @param activiteAvecDoc
* @return le libellé traduit de l'état de la discussion
*/
String getLibelleEtatDiscussion(ActiviteAvecDocumentsCatalogue activiteAvecDoc) {
/**
* Initialise l'objet avec les données reçues du frontoffice
- * @param datas
*/
void loadFromActiviteDatas(Map datas, def request) {
}
/**
- * @param prop
* @return La propriété en testant la valeur JSONObject.NULL
*/
private String getJSONProp(def prop) {
/**
* Charge les dates
- * @param dates
*/
private void loadDates(List dates) {
dates.each {Map date ->
/**
* Traite le travail à la maison
- * @param datas
*/
private loadTravailALaMaison(Map travailALaMaisonDatas, def request) {
if (!travailALaMaisonDatas || !travailALaMaisonDatas.ajouterLeTravail){
/**
* Traite la liste des docs à supprimer
- * @param aSupprimer
*/
private void loadListeDocumentsASupprimer(List aSupprimer) {
if (!aSupprimer) { return }
/**
* Traite une ressource à supprimer
- * @param id
*/
private void loadUnDocumentASupprimer(long id) {
this.ressourceASupprimerIds << id
/**
* Traite la liste des documents à modifier
- * @param aModifier
*/
private void loadListeDocumentsAModifier(List aModifier) {
if (!aModifier) { return }
/**
* Traite un document à modifier
- * @param docAModifier
*/
private void loadUnDocumentAModifier(Map docAModifier) {
switch (docAModifier.type) {
/**
* Traite un document catalogue à modifier
- * @param docAModifier
*/
private void loadUnDocCatalogueAModifier(Map docAModifier) {
this.documentCatalogues.add(new RessourceDocumentCatalogueParams(
/**
* Traite un fichier à modifier
- * @param docAModifier
*/
private void loadUnFichierAModifier(Map docAModifier) {
this.fichiers.add(
/**
* Traite une url à modifier
- * @param docAModifier
*/
private void loadUneUrlAModifier(Map docAModifier) {
this.urls.add(
/**
* Traite la liste des documents à créer
- * @param aCreer
- * @param datas
- * @param request
*/
private void loadListeDocumentsACreer(List aCreer, def request) {
if (!aCreer) { return }
/**
* Traite un document à créer
- * @param docACreer
- * @param datas
- * @param request
*/
private void loadUnDocumentACreer(Map docACreer, def request) {
switch (docACreer.type) {
/**
* Charge une ressource de type document de catalogue
- * @param docACreer
*/
private loadUnDocCatalogueACreer(Map docACreer) {
this.documentCatalogues << new RessourceDocumentCatalogueParams(
/**
* Charge une ressource de type FICHIER
- * @param docACreer
- * @param datas
*/
private loadUnFichierACreer(Map docACreer, def request) {
MultipartFile multipartFile = ((MultipartHttpServletRequest) request).getFile(
/**
* Charge une ressource de type URL
- * @param docACreer
*/
private loadUneUrlACreer(Map docACreer) {
String url = docACreer.url
/**
* Activites liees a une evenement, visibles pour l'utilisateur loggue
- * @param securiteSession
- * @param evenementId
- * @return
*/
List findActiviteInfosForEvenement(SecuriteSession securiteSession, Long evenementId) {
Evenement evenement = Evenement.get(evenementId)
/**
* Crée une activité
- * @param securiteSession
* @param infos les informations sur l'activité à créer
* @return l'activité créée
* @throws AutorisationException si l'utilisateur ne dispose des permissions
/**
*
- * @param activite
- * @param activiteParams
- * @return
*/
public Activite appliqueParamsToActivite(Activite activite, ActiviteParams activiteParams) {
activite.titre = activiteParams.titre
/**
* Vérifie la validité de l'activité et déclenche les exceptions si besoin
- * @param activite
*/
private void verifieActiviteParams(ActiviteParams activiteParams)
throws ActiviteValidationException {
/**
* Fournit le modèle pour la consultation d'une activité
- * @param activiteId
- * @return
*/
def getActiviteModeleConsultation(Long activiteId,
Boolean isCatalogueActif,
/**
* Indique si l'espace de discussion est visible
- * @param activite
- * @return
*/
private Boolean isPanelDiscussionVisible(SecuriteSession securiteSession,
Activite activite) {
/**
* Visibilite d'activite pour la personne loggue
- * @param securiteSession
- * @param activite
* @return true si l'activite est visible
*/
public Boolean isVisible(SecuriteSession securiteSession, Activite activite) {
/**
* Enregistre le statut d'une activité
- * @param activite
- * @param terminee
*/
def ajouteStatut(Activite activite, Boolean terminee) {
statuts.put(activite, terminee)
/**
* Retourne le statut d'une activité
- * @param activite
* @return un booléen
*/
Boolean getStatutTermineForActivite(Activite activite) {
/**
* Vérifie que le cahier de textes du chapitre fournit correspond au
* cahier de textes fournit
- * @param cahierDeTextes
- * @param chapitre
* @throws IllegalStateException si les cahiers de textes ne correspondent pas
*/
private void verifieCoherenceCahierChapitre(CahierDeTextes cahierDeTextes,
/**
* Retourne le 1er numéro d'ordre disponible pour le chapitreParent (ou à la
* racine du cahier de textes si le chapitre parent n'est pas fournit)
- * @param cahierDeTextes
- * @param chapitreParent
- * @return
*/
public Long getOrdreSuivant(CahierDeTextes cahierDeTextes,
Chapitre chapitreParent) {
/**
* Sérialise le contenu de la discussion
- * @param activiteAvecDoc
- * @return
*/
Map marshallContenuDiscussion(ActiviteAvecDocumentsCatalogue activiteAvecDoc) {
if (!discussionService.
/**
* Marshalle la liste des commentaires
- * @param activiteAvecDoc
- * @return
*/
List<Map> marshallCommentaires(ActiviteAvecDocumentsCatalogue activiteAvecDoc) {
List<Map> result = []
/**
* Marshalle un commentaire
- * @param commentaire
* @return une Map
*/
Map marshallCommentaire(ActiviteAvecDocumentsCatalogue activiteAvecDoc,
/**
* Supprime tous les commentaires de la discussion
- * @param securiteSession
- * @param discussion
*/
void supprimerTousCommentaires(SecuriteSession securiteSession,
Discussion discussion){
/**
* Est ce que le role du login est autorisé à créer une discussion ?
* mantis 4227 : modifier la liste des rôles dans cette méthode
- * @param securiteSession
- * @return
*/
public boolean roleAutoriseACreerDiscussion(SecuriteSession securiteSession) {
securiteSession.hasFonctionIn([
/**
* Retourne le 1er numéro d'ordre des dossiers disponible pour un utilisateur
- * @param utilisateur
- * @return
*/
Long getNumOrdreDossierSuivant(Autorite utilisateur) {
// Récupération de l'ordre max
}
/**
- * @param ids
* @return La liste des dossiers correspondant aux ids
*/
List<Dossier> findAllDossiersForAllIds(Set<Long> dossierIds) {
/**
* Création d'une relation entre un dossier et un cahier de texte
- * @param dossier
- * @param autorisation
- * @return
*/
public RelDossierAutorisationCahier creeRelation(Dossier dossier,
Autorisation autorisation) {
/**
* Retourne une liste d'évènements compatibles avec une activité
- * @param cdt
- * @param date
* @return List < EvenementActiviteInfo >
*/
List<EvenementActiviteInfo> findEvenementsForActivite(CahierDeTextes cdt,
/**
* Cherche l'événement pouvant être associé automatiquement à une activité
* (dans le cadre des API REST de textes)
- * @param activite
* @return l'Evenement associable
*/
Evenement findEvenementForAssociationAutomatiqueActivite(Activite activite,
/**
* Constructeur du cache avec une liste de documents et leur niveau de détail
- * @param docs
- * @param niveau
*/
CacheCatalogueDocument(List<TextesDocumentCatalogueInfo> docs,
NiveauDetailDocument niveau) {
/**
* Retourne un document contenu dans le cache, dont l'id externe correspond
* et dont le niveau de détail est égal ou supérieur au niveau demandé
- * @param documentIdExterne
- * @param niveauDemande
* @return Un TextesDocumentCatalogueInfo ou null
*/
TextesDocumentCatalogueInfo getDocument(String documentIdExterne,
/**
* Retourne les items du cache correspondant aux critères
- * @param params
- * @return
*/
List<ItemCacheDocument> findAllItemByCriteria(CatalogueRechercheParams params) {
List<ItemCacheDocument> itemsTrouves = []
/**
* Ajoute un document au cache
- * @param doc
- * @param niveau
*/
private void internalAjouteDocument(TextesDocumentCatalogueInfo doc,
NiveauDetailDocument niveau) {
/**
* Retourne un document complet par son id externe
- * @param securiteSession
- * @param idExterne
- * @return
*/
TextesDocumentCatalogueInfo getDocument(SecuriteSession securiteSession,
String idExterne) {
/**
* Retourne une liste de documents
- * @param securiteSession
* @param catalogueRechercheParams si recherche params ne sont pas passe,
* tous les documents d'utilisateur sont cherches
- * @return
*/
ReponseCatalogue findAllDocumentByCriteria(SecuriteSession securiteSession,
CatalogueRechercheParams catalogueRechercheParams = null) {
/**
* Cherche les editeurs et categories disponibles.
* Méthode implémentée dans CatalogueSessionService uniquement
- * @param securiteSession
*/
ModeleCatalogue getModeleCatalogue(SecuriteSession securiteSession) {
throw new IllegalStateException("Méthode getModeleCatalogue non implémentée")
/**
* Teste si l'acces au catalogue est actif, en fonction de la valeur retournée
* par l'API et du paramétrage.
- * @param securiteSession
- * @param etablissement
- * @return
*/
Boolean isAccesCatalogueActif(SecuriteSession securiteSession,
Etablissement etablissement) {
/**
* Methode commune pour la recherche des docs et ids
- * @param securiteSession
- * @param catalogueRechercheParams
- * @return
*/
private ReponseCatalogue generiqueGetAllDocuments(SecuriteSession securiteSession,
CatalogueRechercheParams catalogueRechercheParams) {
/**
* Appelle le service de communication avec les paramètres et gère le résultat
- * @param securiteSession
- * @param params
* @return List < TextesDocumentCatalogueInfo >
*/
private ReponseCatalogue interrogeCatalogue(SecuriteSession securiteSession,
/**
* Retourne une liste de documents
- * @param securiteSession
* @param catalogueRechercheParams parametres de recherche
* @return liste des infos sur les documents
*/
/**
* Cherche les editeurs et categories disponibles.
- * @param securiteSession
*/
ModeleCatalogue getModeleCatalogue(SecuriteSession securiteSession) {
if (!cacheCatalogueDocument) {initialiseCache(securiteSession)}
/**
* Indique si le catalogue est actif pour le contexte de l'établissement
- * @param etablissement
- * @param securiteSession
* @return true si le catalogue est actif
*/
Boolean isCatalogueActifForContexte(Etablissement etablissement,
/**
* Interroge le catalogue pour récupérer les documents incomplets, puis
* met à jour le cache
- * @param securiteSession
* @param items : tous les items à tester (complets et incomplets)
* @return la liste des items (ceux qui étaient déjà complets, plus ceux
* mis à jour par la méthode).
/**
* Fait un appel au catalogue pour initialiser le cache avec les documents
* de l'utilisateur au niveau BASIQUE.
- * @param securiteSession
*/
private void initialiseCache(SecuriteSession securiteSession) {
List<TextesDocumentCatalogueInfo> docInfos =
/**
* Applique la pagination sur la liste des documents complete
- * @param catalogueRechercheParams
- * @return
*/
private List<ItemCacheDocument> pagine(List<ItemCacheDocument> items,
PaginationParams params) {
\r
/**\r
* Recupere CoutDocumentCatalogue par son nom\r
- * @param name\r
- * @return\r
*/\r
static CoutDocumentCatalogue parseByName(String name) {\r
switch (name.toUpperCase()) {\r
/**
* Charge l'information des documents auxquels l'utilisateur loggue est abonné.
- * @param securiteSession
* @param params parametres de requetage
* @return ReponseCatalogue
*/
/**
* Recherche les documents de l'utilisateur connecté
- * @param securiteSession
- * @param params
- * @return une ReponseCatalogue
+ * @return une ReponseCatalogue
*/
ReponseCatalogue findAllDocument(SecuriteSession securiteSession,
WsCatalogueRechercheParams params)
\r
/**\r
* Liste des éditeurs dans un format JSON\r
- * @return\r
*/\r
List<Map> getEditeursForJson(){\r
return this.editeurs.collect {[nom: it]}\r
\r
/**\r
* Liste des catégories dans un format JSON\r
- * @return\r
*/\r
List<Map> getCategoriesForJson(){\r
return this.categories.collect {[nom: it]}\r
\r
/**\r
* toString\r
- * @return\r
*/\r
String toString(){\r
return """{\r
ApplicationContext applicationContext
/**
- * @param fichier
* @return le datastore qui stocke le flux de données du fichier
*/
DataStore getDataStore(Fichier fichier) {
}
/**
- * @param fichier
* @return le datastore qui stocke le flux de données du fichier
*/
DataStore getDataStore(DataStoreId dataStoreId) {
/**
* Vérifie l'existence du dossier
- * @param rootDir
* @throws DataStoreException
*/
private void verifieDataStoreRootDirExistence(File rootDir)
/**
* Vérifie l'accéssibilité du dossier en écriture
- * @param rootDir
* @throws DataStoreException
*/
private void verifieDataStoreRootDirPermission(File rootDir)
/**
* Exécute l'opération de ramasse miette sur un store
- * @param store
*/
GarbageCollectorRapport runGC(DataStoreId dataStoreId) {
EliotDataStoreGarbageCollector gc =
DataStoreResolverService dataStoreResolverService
/**
- * @param fichier
* @return la longueur du flux du fichier en octets
*/
Long getLength(Fichier fichier) {
}
/**
- * @param dataStore
- * @param fichierIdExterne
* @return la longueur du flux du fichier en octets
*/
Long getLength(DataStore dataStore, String fichierIdExterne) {
}
/**
- * @param fichier
* @return le flux de données du fichier
*/
InputStream getFlux(Fichier fichier) {
/**
* Enregistre le flux de données du fichier
- * @param fichier
*/
void enregistreFlux(Fichier fichier) {
DataStore dataStore = dataStoreResolverService.getDataStore(fichier)
/**
* Analyse le résultat du test et vérifie que les seuils ne sont pas dépassés
- * @param resultats
* @return true si un seuil est dépassé
*/
private Boolean isSeuilDepasse(List dataStoreFichierVerificationResultats,
/**
* Calcule les stats sur les résultats de la vérification des fichiers
- * @param resultats
* @return FichierVerificationStats
*/
private void calculeStats(
/**
* Lance la vérification des "nbFichiers" derniers fichiers enregistrés
* d'un dataStore donné
- * @param nbFichiers
- * @return
*/
private List<FichierVerificationResultat> testeDerniersFichiersForDataStore(
int nbFichiers,
/**
* Teste "NbFichiers" Fichiers choisis aléatoirement d'un dataStore donné
- * @param nbFichiers
* @return List < VerificationFichierResultat >
*/
private List<FichierVerificationResultat> testeFichiersAleatoiresForDataStore(
/**
* Extrait les ressources d'une activité
- * @param noeudActivite
* @return la liste des ressources de l'activité
*/
List<Ressource> extraitRessources(GPathResult noeudActivite, String cheminImport) {
/**
* Crée l'objet Fichier correspondant au fichier désigné par le chemin
- * @param cheminRelatif
* @return Le Fichier
*/
Fichier extraitFichier(String cheminRelatif, String cheminImport) {
/**
* * Créee un verrou
- * @param securiteSession
*/
synchronized static void creeVerrou(SecuriteSession securiteSession) {
creeFichierVerrou(securiteSession)
/**
* Libère un fichier verrou associé à un traitement de bascule d'année
- * @param securiteSession
- * @param basculeAnneeInfo
*/
private synchronized static void libereFichierVerrou() {
File fichierVerrou = new File(getVerrouAbsoluePath())
/**
* Effectue le chargement d'un chapitre ou d'une activité
- * @param securiteSession
- * @param cahier
- * @param proprietaire
- * @param contenuListePlate
*/
void loadContenu(SecuriteSession securiteSession,
CahierDeTextes cahier,
* Retourne le dossier de l'acteur 'propriétaire' dans lequel ses cahiers
* seront importés
* Ce dossier est créé à la volée s'il n'existe pas
- * @param proprietaire
- * @return
*/
Dossier getDossierImport(Autorite proprietaire) {
Dossier dossierImport = dossierService.getDossier(
/**
*
- * @param securiteSe
sion
- * @param do
sier : identifiant du dossier
- * @param u
lCss
* @throws IllegalStateException
*/
/**
* Exécution transactionnelle
- * @param rapport
- * @param closure
*/
private void executeDansTransaction(TextesImportRapport rapportPrincipal,
CahierDeTextesInfo cdt,
/**
* Verrouille l'application
- * @param cause
*/
void verrouilleApplication(Throwable cause) {
if (applicationVerrou?.isActif()) {
/**
* Teste si l'application est verrouillée
- * @return
*/
boolean isApplicationVerrouillee() {
return applicationVerrou?.isActif()
/**
* Verrouille une fonctionnalité
- * @param f
*/
void verrouilleFonctionnalite(EliotFonctionnalite f,
Throwable cause) {
/**
* Teste si une fonctionnalité est verrouillée
- * @param f
- * @return
*/
boolean isFonctionnaliteVerrouillee(EliotFonctionnalite f) {
return allFonctionnaliteVerrou.get(f)?.actif
}
/**
- * @param f
* @return la cause du verrouillage de la fonctionnalté f
*/
Throwable getFonctionnaliteVerrouilleeCause(EliotFonctionnalite f) {
* Permet d'obtenir le verrou de la bascule d'année s'il est disponible
* @param securiteSession la session de sécurité de l'utilisateur déclenchant l'action
* @param module le module sur lequel les traitements doivent être effectués
- * @return
* @author jtra
* @author jbui
*/
/**
* Libére un verrou de bascule d'année
- * @param verrou
* @author jtra
*/
void libereVerrou(BasculeAnneeVerrou verrou) {
/**
* renvoit l'ensemble des modules eliot à basculer
- * @return
*/
List<ModuleEliot> getAllModule() {
allEtape.collect {it.module}.unique().toList()
/**
* Génére les étapes de la bascule d'année de l'esnemble des applications
* qui utilisent la base de docs
- * @param etapes
*/
void genereAllEtapeBdDocs(List<Etape> etapes) {
// création à la volée
/**
* Génére les étapes de la bascule d'année de l'esnemble des applications
* qui utilisent la base de scolariré
- * @param etapes
*/
void genereAllEtapeBdScolarite(List<Etape> etapes) {
if (!etapes) {
/**
* Construit l'état de la page d'accueil de l'application eliot-textes à
* partir de la représentation JSON transmise par le client javascript
- * @param json
* @author jtra
*/
AbstractEtatApplication() {
* "c30_2556":"/drootTemps/c30_2556","c34_3111":"/drootTemps/c34_3111"}}}*
* ]
*
- * @param json
* @return l'état correspondant à la représentatino JSON fournie
* @author jtra
*/
/**
* getter sur une variable liste.
* @param nom : nom complet de la variable liste
- * @return
*/
public Object getVariableListe(String nom) {
def resultat = null
* Permet de savoir si une valeur issue du front-office doit
* être stockée dans un champ simple ou dans une map de variables
* @param nomComplet : nom front-office de la variable
- * @return
*/
boolean isVariableTypeList(String nomComplet) {
return nomComplet.contains('_')
/**
* Pour les variables de type liste, cette méthode permet de récupérer le nom
* de la variable du front, vu du coté de l'objet EtatApplication
- * @param nomComplet
- * @return
*/
String getNomForVariableTypeList(String nomComplet) {
return nomComplet.split('_')[0]
/**
* Retourne l'index associé à un nom complet d'une variable "liste"
- * @param nomComplet
- * @return
*/
String getIndexForVariableTypeList(String nomComplet) {
return nomComplet.split('_')[1]
/**
* Consolide cet état avec l'état fourni en argument
- * @param nouvelEtat
* @return l'état consolidé
* @author jtra
* @author othe
/**
* consolide les variables liste de l'état
- * @param nouvelEtatApplication
* @author othe
*/
private void consolideVariableListe(AbstractEtatApplication nouvelEtatApplication) {
/**
* Consolide les variables simples de l'état
- * @param nouvelEtatApplication
* @author othe
*/
private void consolideVariableSimple(AbstractEtatApplication nouvelEtatApplication) {
/**
* Consolide l'état identifié par id avec nouvelEtat
* S'il n'existe pas d'état pour cet id, nouvelEtat sera utilisé
- * @param id
- * @param nouvelEtat
*/
void consolideEtat(EtatApplicationId id, AbstractEtatApplication nouvelEtat) {
if (etats[id]) {
/**
* Contruit une variable d'état
- * @param fieldObject
- * @param field
*/
def EtatListeVariables(fieldObject, Field field) {
this.fieldObject = fieldObject
/**
* Contruit une variable d'état
- * @param fieldObject
- * @param field
*/
def EtatVariable(fieldObject, field) {
this.fieldObject = fieldObject;
/**
* Construit un objet chemin à partir de sa représentation textuelle
* (de la forme "/<id_1>/<id_2>/.../<id_n>"
- * @param strChemin
*/
Chemin(String strChemin) {
// TOIMP: *** Vérifier la syntaxe de strChemin
/**
* Indique si l'arbre est ouvert
- * @return
*/
public Boolean estOuvert() {
branchesOuvertes.size() != 0
/**
* charge les données de l'arbre à partir des informations json
- * @param json
*/
public void chargeJsonData(JSONObject json) {
/**
* Charge un nouveau noeud
- * @param noeud
- * @param chemin
*/
public void addNoeud(Noeud noeud, Chemin chemin) {
branchesOuvertes[noeud] = chemin
/**
* indique si le noeud est root
- * @return
*/
public boolean isRoot() {
noeudId.contains('root')
\r
/**\r
* Ecris une ligne comme <<\r
- * @param row\r
- * @return\r
*/\r
void leftShift(List row) {\r
write(row)\r
\r
/**\r
* Ecris une ligne\r
- * @param row\r
- * @return\r
*/\r
void write(List row) {\r
if (!headingsWritten) {\r
\r
/**\r
* Ecris plusieurs lignes\r
- * @param rows\r
- * @return\r
*/\r
void writeAll(Collection rows) {\r
for (List row in rows) {\r
\r
/**\r
* Ecris les entetes\r
- * @return\r
*/\r
protected void writeHeadings() {\r
columns.eachWithIndex { String nomColonne, i ->\r
\r
/**\r
* Ecris une valeur\r
- * @param value\r
- * @return\r
*/\r
protected void writeValue(def value) {\r
String valueString = (value == null) ? '' : value.toString()\r
\r
/**\r
* Export le contenu en CVS dans un ByteArrayOutputStream\r
- * @param donneesPourExportCSV\r
- * @return\r
*/\r
ByteArrayOutputStream exportVersOutputStream(DonneesPourExportCSV donneesPourExportCSV,\r
String encoding = ENCODING_CSV_PAR_DEFAUT) {\r
/**\r
* Export le contenu en CVS dans un Writer (PrintWriter, FileWriter,\r
* StringWriter ..)\r
- * @param colonnes\r
- * @param lignes\r
- * @param writer\r
*/\r
void exporteVersWriter(List<String> colonnes,\r
List<List> lignes,\r
\r
/**\r
* Export le contenu en CVS dans un String\r
- * @param colonnes\r
- * @param lignes\r
* @return csv exporte\r
*/\r
String exporteVersString(List<String> colonnes, List<List> lignes) {\r
\r
/**\r
* Export le contenu en CVS dans un Fichier\r
- * @param colonnes\r
- * @param lignes\r
- * @param fichier\r
*/\r
void exporteVersFichier(List<String> colonnes,\r
List<List> lignes,\r
\r
/**\r
* Ajoute une colonne\r
- * @param nomColonne\r
*/\r
void ajouteColonne(String nomColonne) {\r
colonnes.add(nomColonne)\r
\r
/**\r
* Ajoute les colonnes\r
- * @param nomColonnes\r
*/\r
void ajouteColonnes(List<String> nomColonnes) {\r
colonnes.addAll(nomColonnes)\r
\r
/**\r
* Ajoute un eligne des donnees\r
- * @param ligne\r
*/\r
void ajouteLigne(List ligne) {\r
lignes.add(ligne)\r
\r
/**\r
* Ajoute les lignes des donnees\r
- * @param lignes\r
*/\r
void ajouteLignes(List<List> lignes) {\r
this.lignes.addAll(lignes)\r
\r
/**\r
* Cree un CSVWriter autour de writer et remplis le avec le contenu en CSV\r
- * @param writer\r
* @return CSVWriter\r
*/\r
CSVWriterEliot ecrisDansWriter(Writer writer) {\r
/**
* Met à jour le templateEliot
* @param templateEliot : le templateEliot à mettre à jour
- * @param typeFonctionnalite
- * @param templateEliotEnum
- * @param numeroVersion
- * @param param
- * @param templateJasperIS
- * @param typeDonnees
- * @param sousRapport
* @return le TemplateEliot modifié
* @throws ImpressionServiceException
*/
/**
* Vide le template eliot de son contenu (en base)
- * @param templateEliotEnum
*/
private void videTemplateEliot(TemplateEliot templateEliotAVider) {
if (templateEliotAVider.templateJasper) {
/**
* Vide le template jasper de son contenu
* Procédure récursive.
- * @param templateJasper
*/
private void videTemplateJasper(TemplateJasper templateJasper) {
if (templateJasper.sousTemplate) {
* @param classeFactoryTableau : classe pour les tableaux dynamique
* @param classeFactorySousRapport : classe pour les ligne de tableau dynamique
* @param classeFactoryTableau : classe pour les sous ligne de tableau dynamique
- * @return
*/
@Transactional
TemplateEliot importeTableau(TemplateTypeFonctionnalite typeFonctionnalite,
* @param tableauIS InputStream sur fichier jrxml du rapport
* @param sousRapportIS InputStream sur fichier jrxml des lignes de matières
* @param sousSousRapportIS InputStream sur fichier jrxml des lignes de sous-matières
- * @return
*/
@Transactional
TemplateEliot metAJourTableau(TemplateEliot tableau,
/**
* Convertion d'un fichier.jasper en tableau de byte. Cette routine permettra
* de sauver le fichier en base
- * @param jasperReport
- * @return
*/
private byte[] jasperToBytes(JasperReport jasperReport) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()
/**
* Impression d'un état système en PDF
- * @param etab
- * @param codeTemplateDocument
- * @param data
- * @return
*/
public ByteArrayOutputStream creePdf(Etablissement etab,
String codeTemplateDocument,
/**
* Imprime un document en pdf
- * @param etab
- * @param templateDocument
- * @param data
- * @return
*/
public ByteArrayOutputStream creePdf(Etablissement etab,
TemplateDocument templateDocument,
/**
* Impression d'un état système en PDF dans un flux
* @param outputstream : flux de sortie pdf
- * @param etab
- * @param templateDocument
- * @param data
- * @return
*/
public void pdfToOutputStream(OutputStream outputStream,
Etablissement etab,
/**
* Construit le jasperprint résultat en fonction des données contenus dans data. Tiens compte de la structure de
* données dans data (List ou DonneesOptions)
- * @param data
- * @param etab
- * @param templateDocument
- * @return
*/
public JasperPrint construitJasperPrint(Object data, Etablissement etab, TemplateDocument templateDocument) {
JasperPrint jasperPrint
/**
* Gestion des zones de mémo
- * @param templateDocument
- * @param data
*/
private void gestionChampsMemo(TemplateDocument templateDocument, List data) {
/**
* Permet de charger un paramètre complementaire pour le modèle jasper. Ce paramètre
* dépend complètement du type d'état et n'est pas obligatoire.
- * @param etab
- * @param templateDocument
- * @param parameters
- * @param options
*/
private ListeParametresImpression gestionParametreOptions(TemplateDocument templateDocument,
ListeParametresImpression parameters,
/**
* Gestion du cachet
- * @param etab
- * @param templateDocument
- * @param parameters
* @return la liste parameters avec le cachet en plus
*/
private ListeParametresImpression gestionCachet(Etablissement etab,
/**
* Lecture des modèles jasper en base et préparation des paramètres pour jasperReport
- * @param templateDocument
* @return Liste des paramètres sous la forme nom=objet
* nom est de type string et object contient un objet JasperReport
*/
*
* @author bahj
* @param eleves liste des élèves
- * @param selectionAdresseResponsableEnum
* @param classe Classe des élèves
* @param clazzEleve classe de l'objet de stockage des informations eleve
- * @return
*/
public List<EleveImpressionInfo> findAllInfoGeneralesEleve(SecuriteSession securiteSession,
List<Personne> eleves,
/**
* tri par classe et nom
- * @param eleveInfos
- * @return
*/
public List triEleves(List<EleveImpressionInfo> eleveInfos) {
return eleveInfos.sort {
* Construit le nom d'affichage des responsables de la classe
* @param responsables liste des personne responsables de la classe
* @author bahj
- * @return
*/
private String getNomAffichageResponsablesDeClasse(List<Personne> responsables) {
return responsables?.collect { it.nomAffichageInitiales() }?.join(', ')
* @param dateFin la date max des envois
* @param classes la liste des classes des envois
* @param modeles la liste des templates utilisateurs des envois
- * @param start
- * @param sortInfo
- * @param typeMedia
- * @param statut
* @return la liste des suivis
*/
@SuppressWarnings("CatchException")
/**
* création d'une information de suivi d'envoi
- * @param etablissement
- * @param eleve
- * @param classe
- * @param dateEnvoi
- * @param media
- * @param templateDocument
- * @param templateTypeFonctionnalite
- * @param operateur
- * @param responsable
- * @param statut
- * @param periode
- * @param messageId
- * @return
* @throws ImpressionServiceException
*/
PublipostageSuivi creeSuiviEnvoi(Etablissement etablissement,
/**
* Permet de créer un historique pour les listes d'élèves selectionnés pour
* une impression différée
- * @param eleveImpressionInfos
- * @param templateDocument
- * @param templateTypeFonctionnaliteEnum
- * @param etablissementCourant
- * @param demandeur
- * @param periode
*/
public void traceImpressionCourrierDiffere(Object donnees,
TemplateDocument templateDocument,
/**
* Imprime dans un pdf sur disque et historise une liste d'élèves
- * @param securiteSession
* @param demande : informations de la demande
* @param etablissement : dans quel établissement
* @param template : modèle de document
* Détermine le type de fonctionnalité associé à la demande. Une demande de
* traitement étant générique pour toutes les applications, cette méthode
* permet de récupérer le type fonctionnel de demande de publipostage
- * @param demande
* @return : le type de fonctionnalité associé à la demande
*/
TemplateTypeFonctionnaliteEnum lectureTypeFonctionnalite(
/**
* Recherche un texte de contenu par défaut
- * @param code
- * @return
*/
public String getContenu(String code) {
/**
* Retourne une valeur numérique issue du fichier des propriétés
- * @param code
- * @return
*/
public Integer getInt(String code) {
String value = getContenu(code)
/**
*
- * @return
*/
public Integer getNombreContenuModeleSms() {
String valueNombre = INFO_MEMO + SMS + '.nombre'
/**
* recherche des modèles de contenus texte pour un type de support donné (pour
* l'instant un seul modèle)
- * @param typeModele
- * @return
*/
public List<ModeleContenu> findAllModeleContenuSms() {
/**
* Lecture des infos d'un modèle de sms
- * @param i
- * @return
*/
public ModeleContenu getInfoModele(Integer index) {
String code = INFO_MEMO + SMS + '.nom.' + index.toString()
/**
* Méthode de récupération des données pour faciliter la gestion
* des données au niveau de jasperReport
- * @return
*/
public List<TableauImpressionInfo> getSousModele() {
List<TableauImpressionInfo> tableau = []
/**
* indique si le destinataire du publipostage est valide
- * @return
*/
public Boolean isDestinataireCourrierValide() {
/**
* teste si la destinataire du sms à un numéro de portable
- * @return
*/
public Boolean isDestinataireSMSValide() {
return ((getParent_portable()) && (getParent_portable() != ""))
/**
* Permet de savoir si l'adresse 2 est différente de l'adresse 1
- * @return
*/
public boolean isAdresse2DifferenteAdresse1() {
/**
* Permet de savoir si le téléphone portable 2 est différent du téléphone portable 1
- * @return
*/
public boolean isPortable2DifferentPortable1() {
String portable1
/**
* Retourne le responsable associé choisit
- * @return
*/
public Personne getResponsable() {
switch (selectionAdresseResponsable) {
/**
* Retourne sous forme de texte la liste des notes textuelles
- * @return
*/
public String getAllNoteTextuelle() {
allNoteTextuelleImpression.toString()
/**
* Indique si il existe des notes textuelles dans le bulletin
- * @return
*/
public boolean getExisteNoteTextuelle() {
allNoteTextuelleImpression.existeNote()
/**
* Indique si la liste est vide
- * @return
*/
public boolean existeNote() {
(annotationsUtilisees.size() > 0)
/**
* Enregistrement d'une image
- * @param imageType
- * @param etablissement
- * @param image
*/
public void enregistre(ImageType imageType,
Etablissement etablissement,
/**
* Vérification du format de l'image
- * @param image
- * @return
*/
private void checkImageCorrecte(byte[] image) {
try {
/**
* Charge une image par rapport à son type et à l'établissement
- * @param imageType
- * @param etablissement
- * @return
*/
public byte[] load(ImageType imageType,
Etablissement etablissement,
/**
* Assure la migration des cachets de l'ancienne méthode de stockage vers la nouvelle
- * @param templateDocument
- * @param etablissement
*/
private void migrationCachet(TemplateDocument templateDocument,
Etablissement etablissement,
/**
* Retourne une image vide
- * @return
*/
private byte[] imageVide() {
* lecture et contrôle du template dans la demande
* @param objectParam : un objet paramètre (Map params de controleur, object
* commande de controleur, objet de demande de traitement de file d'attente)
- * @return
*/
public TemplateDocument getTemplateDocument(def objectParam) {
Long id = Long.parseLong(objectParam.modeleId)
* lecture et contrôle de l'etablissement dans la demande
* @param objectParam : un objet paramètre (Map params de controleur, object
* commande de controleur, objet de demande de traitement de file d'attente)
- * @return
*/
public Etablissement getEtablissement(def objectParam) {
Etablissement etablissement = Etablissement.get(objectParam.etablissementId)
* Permet de lire le type de période passé en paramètre
* @param objectParam : un objet paramètre (Map params de controleur, object
* commande de controleur, objet de demande de traitement de file d'attente)
- * @return
*/
public TypePeriode getTypePeriode(def objectParam) {
String typePeriodeIdStr = objectParam.typePeriodeId
* Permet de lire la liste des élèves passée en paramètre
* @param objectParam : un objet paramètre (Map params de controleur, object
* commande de controleur, objet de demande de traitement de file d'attente)
- * @return
*/
public List<Personne> getEleves(def objectParam) {
String eleveIdsStr = objectParam.elevesSelectionnes
/**
* Applique le nom de la période à la liste des informations eleve
- * @param eleveImpressionInfos
- * @param nomPeriode
- * @return
*/
public void nommePeriode(List<EleveImpressionInfo> eleveImpressionInfos,
String nomPeriode) {
* Samedi 7 -> 6
* Dimanche 1 -> 7
*
- * @param date
- * @return
*/
private Integer convertiJourSemaineJavaEnJourEliot(Date date) {
Calendar calendar = Calendar.getInstance()
/**
* Retourne le code hql de la requete permettant de lire les appels associés
* aux structures d'enseignement des élèves, sur une période données
- * @return
*/
private String hqlLectureAppelsElevesPeriodes() {
PersonneProprietesScolarite
/**
* Récupère la liste des jours de fermetures sur la période considérée
- * @param etablissement
* @param debut : début de la période
* @param fin : fin de la période
- * @return
*/
private List<Fermeture> findAllJoursFermetures(Etablissement etablissement,
Date debut,
/**
* Retourne la liste des jours de fermeture hebdo sur la période
- * @param etablissement
* @param debut : début de la période
* @param fin : fin de la période
- * @return
*/
private List<Fermeture> findAllFermetureHebdo(Etablissement etablissement,
Date debut,
* Regroupe les périodes contigues. Tiens compte des jours fériés et le jour
* de fermeture hebdo.
*
- * @param eleves
- * @param debut
- * @param fin
- * @return
*/
public void fusionnePeriodesEleves(Etablissement etablissement,
List<EleveImpressionInfo> eleves,
/**
* Vérifie s'il existe une période correspondant aux date/heure de début et
* de fin
- * @param debut
- * @param fin
- * @return
*/
public boolean isPeriodeExiste(Date debut, Date fin) {
Periode periode = (Periode) find {it.debut == debut}
/**
* Rajoute une période de présence uniquement si la plage demandée est disponible
- * @param debut
- * @param fin
*/
public void addPresence(Date debut, Date fin) {
if (!isPeriodeExiste(debut, fin)) {
* périodes à fusionner doivent être de même classe et leurs propriétés
* 'motif' doivent être identiques.
*
- * @param periode
*/
public void merge(Periode periode) {
* formulaire de saisie de la selection du publipostage. Ceci ne se trouve
* pas dans un contrôleur car en fait on va faire appel à cette méthode
* dans les jobs.
- * @return
*/
public PublipostageAbsencesParams construitSelectionCommand(String argsJSON) {
Map params = new JSONObject(argsJSON)
* @param etablissement l'établissement courant
* @param eleves les élèves choisis
* @param typePeriode type période chosis
- * @param eleveImpressionInfos
- * @param ajouteDetailsRetards
- * @return
*
*/
public List<EleveImpressionInfo> findAllInfoForRetardsDeparts(
* @param securiteSession la session courante
* @param etablissement établissement courant
* @param criteres représente l'ensemble des critères des retards
- * @return
*
*/
public List<EleveImpressionInfo> findAllInfoForRetardsAndDepartAnticipes(SecuriteSession securiteSession,
* @param securiteSession la session courante
* @param etablissement l'établissement courant
* @param criteres représente l'ensemble des critères d'absences
- * @return
*/
public List<EleveImpressionInfo> findAllInfoForAbsences(
SecuriteSession securiteSession,
/**
* Rempli datesAbsence dans eleveImpressionInfos en utilisant l'info sur les
* absences deja presant dans eleveImpressionInfos
- * @param eleveImpressionInfos
*/
void remplisDatesAbsences(List<EleveImpressionInfo> eleveImpressionInfos) {
eleveImpressionInfos.each { EleveImpressionInfo eleveImpressionInfo ->
* @param etablissement l'établissement courant
* @param eleves les élèves choisis
* @param typePeriode type période chosis
- * @param eleveImpressionInfos
- * @param ajouteDetailsRetards
- * @return
*
*/
public List<EleveImpressionInfo> findAllInfoForAbsences(
* @author bahj
* @param etablissement l'établissement courant
* @param criteres les critères de recherchre des absences
- * @param eleveImpressionInfos
- * @return
*/
private List<EleveImpressionInfo> findAllInfoAbsenceEleve(Etablissement etablissement,
BasicCriteresRecherche criteres,
* @author bahj
* @param etablissement l'établissement courant
* @param criteres les critères de recherche des retrads
- * @param eleveImpressionInfos
- * @return
*
*/
private List<EleveImpressionInfo> findAllInfoRetardDepartEleve(BasicCriteresRecherche criteres,
/**
* Gestion des dates de début et de fin de période
- * @param criteres
*/
private void gestionDateDebutDateFinRequete(List<EleveImpressionInfo> eleveImpressionInfos, BasicCriteresRecherche criteres) {
eleveImpressionInfos.each {
* - la StructureEnseignement
* - la Personne élève
* - l'absenceJournee
- * @param eleveImpressionInfos
*
- * @return
*/
private List<EleveImpressionInfo> addAbsencesImpressionInfo(BilanAbsencesParPersonneInfo datas,
List<EleveImpressionInfo> eleveImpressionInfos
* - la StructureEnseignement
* - la Personne élève
* - l'absenceJournee
- * @param eleveImpressionInfos
- * @return
*
*/
private List<EleveImpressionInfo> addRetardsImpressionInfo(BilanAbsencesParPersonneInfo datas,
* Lecture des requetes à lancer pour le template document.
* On entend par requete toutes les requetes sql necessaire pour récupérer un jeu
* de données
- * @param templateDocument
* @return : objet contenant les requetes à lancer
*/
public ImpressionRequetageSelection findAllSelectionRequete(TemplateDocument templateDocument) {
/**
* Vérifie que le fichier à générer existe
- * @param cheminDossier
- * @param nomFichier
* @return true si le fichier existe
*/
private Boolean fichierExiste(String cheminDossier,
/**
* Vérifie que le chemin complet existe, et crée les dossiers si besoin
- * @param cheminDossier
*/
private void forceCreationDossier(String cheminDossier) {
File dossier = new File(cheminDossier)
/**
* Calcule le chemin du fichier correspondant à la demande de traitement
- * @param demandeTraitement
- * @return
*/
private String calculeCheminDossier(DemandeTraitement demandeTraitement) {
Etablissement etab = Etablissement.get(demandeTraitement.etablissementId)
/**
* Vérifie que la demande de traitement porte bien sur une demande de type
* PUBLIPOSTAGE, sinon lève une IllegalArgumentException
- * @param demandeTraitement
*/
private void verifieTypeDemande(DemandeTraitement demandeTraitement) {
if (!demandeTraitement.traitementType.toString().startsWith(
/**
* Vérifie si le fichier généré par le traitement de la demande existe.
- * @param securiteSession
- * @param demandeTraitement
* @return true/false
* @author bper
*/
/**
* Retrouve le modèle de document à partir des paramètres
- * @param params
- * @return
*/
public TemplateDocument findTemplateDocument(Long templateDocumentId) {
/**
* Permet de créer un nouveau modèle de sms à partir d'un modèle de contenu
- * @param typeMedia
- * @param modeleSmsId
- * @param etablissement
- * @param nom
- * @param descriptif
- * @return
*/
public TemplateDocument creeTemplateDocumentSms(TypeMedia typeMedia,
Integer modeleSmsId,
/**
* Retourne la liste des templates utilisateurs ou systèmes disponibles
- * @param etablissement
- * @param typeFonctionnalite
* @param systeme : vrai si l'on souhaite ajouter les modèles systèmes à la liste
* @return la liste des template utilisateurs disponibles
*/
/**
* Modification du template document
- * @param templateDocument
- * @param nom
- * @param descriptif
- * @return
* @throws ImpressionServiceException
*/
public TemplateDocument modifieTemplateDocument(TemplateDocument templateDocument,
/**
* Modifie le nom du modèle pour la suppression
- * @param ancienNom
- * @return
*/
private String creeNomTemplateSupprime(String ancienNom) {
/**
* Liste des modèles de sms pour l'établissement
- * @param etablissement
- * @return
*/
public List<TemplateDocument> findAllTemplateDocumentSms(Etablissement etablissement) {
/**
* Lecture des données binaires compilés
- * @param currentTemplateJasper
- * @return
*/
public JasperReport binaryTemplateJasperFactory(TemplateDocument templateDocument,
TemplateJasper currentTemplateJasper,
/**
* Lecture du modele jasper pré-compilé en base
- * @param currentTemplateJasper
- * @return
*/
private JasperReport chargeModeleJasperParDefaut(TemplateJasper currentTemplateJasper) {
ByteArrayInputStream modeleBinaire = new ByteArrayInputStream(
/**
* Modification du modele jasper fourni pour les taille de fonte et les fontes
- * @param templateDocument
- * @param xml
- * @return
*/
private JasperReport modifieModeleJasper(TemplateDocument templateDocument,
TemplateJasper currentTemplateJasper,
/**
* Supprime une liste d'éléments dans la bande jasper
- * @param aSupprimer
- * @param jrBand
*/
public void supprimeListeElement(List<JRElement> aSupprimer, JRBand jrBand) {
/**
* Retourne le nom du champ ou du parametre sur lequel pointe la zone de texte
- * @param baseTextField
- * @return
*/
public String getNomChamp(JRBaseTextField baseTextField) {
/**
* recherche un élément par sa clé jasper (key) dans le bandeau jasper
* Cet élément doit exister dans le modèle
- * @param jrBand
- * @param key
- * @return
*/
public JRElement getElementByKey(JRBand jrBand, String key) {
/**
* Liste des noms de champs de publipostage élève pour un module donné
- * @param moduleEliot
- * @return
* @throws ImpressionServiceException
*/
List<String> listeChampsEleveParApplication(ModuleEliot moduleEliot)
/**
* Le domaine modeleTypedonnees permet de savoir à quelle structure de beans
* un état est associé.
- * @param modeleTypeDonnees
- * @return
*/
private Class getBeanClass(TemplateTypeDonnees typeDonnees,
ClassLoader classLoader)
/**
* Indique si le modele est de type bulletin de note
- * @param templateDocument
- * @return
*/
public Boolean isModeleBulletin(TemplateDocument templateDocument) {
/**
* Modification d'un modèle jasper
- * @param jasperReport
- * @param templateDocument
- * @param templateJasper
- * @return
*/
public JasperReport modifierTemplate(JasperReport jasperReport,
TemplateDocument templateDocument,
/**
* Modification du modèle contenant les détails des zones de ligne matière
- * @param jrBand
- * @param allDescriptionColonne
*/
private void modifierBandTemplateBulletin(JRBand jrBand,
ColonneBulletin allDescriptionColonne) {
* repositionne ou supprime les colonnes en fonction du paramétrage bulletin
* @param jrBand : bande jasper ou se trouve les champs à déplacer ou supprimer
* @param allDescriptionColonne : nouvelles positions des colonnes
- * @param bulletinParametrage
*/
private void modifierEtSupprimerColonnes(JRBand jrBand,
ColonneBulletin allDescriptionColonne
/**
* Modifie les champs à modifier et etabli la liste des champs à supprimer
- * @param jrBand
- * @param allDescriptionColonne
* @return la liste des champ à supprimer
*/
private List<JRElement> modifierChampsLigneMatiere(JRBand jrBand,
/**
* Modifie la position et la largeur de l'appréciation
- * @param jrBand
- * @param positionAppreciation
*/
private void modifierAppreciation(JRBand jrBand, Integer positionAppreciation) {
/**
* modifie le sous-tableau qui contient les informations des sous-matières
- * @param comp
*/
private void modifierTableauJasper(StandardTable table,
BulletinOptionsPersonnalise bulletinParametrage) {
/**
* Indique si une colonne d'un tableau doit être supprimé
- * @param colonne
- * @param bulletinParametrage
- * @return
*/
private Boolean colonneASupprimer(StandardColumn colonne, BulletinOptionsPersonnalise bulletinParametrage) {
/**
* Permet de modifier la ligne de titre en fonction des paramètres utilisateurs
* @param jrBand : bande jasper qui contient l'entête du tableau de bulletin de notes
- * @param allDescriptionColonne
*/
private void modifierLigneTitre(JRBand jrBand,
ColonneBulletin allDescriptionColonne
/**
* Change lar largeur des libellés Matières/Enseignants
- * @param jrBand
*/
private void traiteLibelleMatiereEnseignant(JRBand jrBand) {
JRElement elementMatiere = jrBand.getElementByKey(KEY_TITRE_MATIERE)
/**
* Recherche l'élément jasper contenant la zone de titre associée à un champ
- * @param jrBand
- * @param nomChamp
- * @return
*/
private JRElement getElementJasperTitre(JRBand jrBand, String nomChamp) {
/**
* Dans un bandeau jasper, corrige les largeurs du titre de groupe
- * @param jrBand
- * @param allDescriptionColonne
- * @param nomChamp
- * @param elementJasperPourTitreDeGroupe
- * @return
*/
private JRElement getElementJasperPourTitreGroupe(JRBand jrBand,
ColonneBulletin allDescriptionColonne,
/**
* Repositionne le titre par rapport à la position de son groupe
- * @param allDescriptionColonne
- * @param nomChamp
- * @param jrElement
*/
private void repositionneTitre(ColonneBulletin allDescriptionColonne,
String nomChamp,
/**
* Permet de rechercher la description d'une colonne par rapport au nom de champ associé
- * @param champ
- * @return
*/
public ColonneDescription getColonneParChamp(String champ) {
/**
* Permet de rechercher la colonne qui correspond à la position du titre de son groupe
- * @param champ
- * @return
*/
public ColonneDescription getPositionTitreParChamp(String champ) {
/**
* Retourne en nombre de colonne la largeur d'un titre de groupe de colonne.
- * @param colonneGroupeEnum
* @return largeur en nombre de colonne. si la valeur=0 c'est que le groupe n'est pas à imprimer.
*/
public Integer largeurTitreGroupeColonne(ColonneGroupeEnum colonneGroupeEnum) {
/**
* incremente la valeur si la colonne du groupe est à imprimer
- * @param nomColonne
- * @param resultat
- * @return
*/
private int incrementeSiOnImprime(String nomColonne, int resultat) {
if (bulletinParametrage.properties.containsKey(nomColonne)) {
* Retourne la valeur 'key' de la zone de texte contenant le titre du groupe.
* L'absence de titre (chaine "") indique simplement que le groupe n'a pas de
* zone de titre associé.
- * @return
*/
public String getTitreKey() {
titreKey
/**
* Retourne la colonne en fonction du nom de champ associé
- * @param champ
- * @return
*/
static public ColonneGroupeEnum getColonneParChamp(String champ) {
/**
* Retourne la colonne en fonction du nom de champ associé
- * @param champ
- * @return
*/
static public String getTitreKeyParChamp(String champ) {
ColonneGroupeEnum colonneGroupeEnum = getColonneParChamp(champ)
/**
* Est ce que le champ passé en parametre correspond à un champ de la colonne matière
- * @param champ
- * @return
*/
static public Boolean isColonneMatiere(String champ) {
Boolean resultat = false
/**
* Retourne la liste des colonnes imprimables
- * @param bulletinParametrage
- * @return
*/
public ColonneBulletin getListeColonneImprimable(BulletinOptionsPersonnalise bulletinParametrage) {
/**
* Détermine à partir du nom de champ jasper, si celui-ci est imprimé
- * @param nom
- * @return
*/
public Boolean aSupprimer(BulletinOptionsPersonnalise bulletinParametrage, String nom) {
/**
* Détermine à partir du nom de champ jasper, si celui-ci est à imprimer
- * @param bulletinParametrage
* @param colonneEnum groupe de colonne
* @param numCol numéro de colonne dans le groupe (0 est la première)
- * @return
*/
public Boolean aImprimer(BulletinOptionsPersonnalise bulletinParametrage,
ColonneGroupeEnum colonneEnum,
/**
* Retourne le numéro de colonne d'une colonne dans un groupe (exemple dans le groupe Moyenne, on a la colonne Eleve
* et la colonne classe)
- * @param nomChamp
- * @return
*/
private Integer numCol(String nomChamp) {
String dernier = nomChamp.substring(nomChamp.size() - 1, nomChamp.size())
/**
* Recherche la taille de police pour un champ memo
- * @param allTaillePolice
- * @param memoName
* @return la taille de police ou null si on ne la change pas
*/
private Integer rechercheTaillePoliceMemo(List<TemplateChampMemo> allTaillePolice, String memoName) {
/**
* affecte une fonte à l'item
- * @param element
- * @param fontName
*/
public void setElementFontName(JRElement element, String fontName) {
/**
* changement de taille de la police
- * @param element
- * @param size
*/
private void setFontSize(JRElement element, Integer size) {
/**
* Modifie les fontes sur une bande
- * @param jrBand
- * @param fontName
*/
public void setFontName(JRBand jrBand, String fontName) {
if (jrBand) {
/**
* Retrouve la liste des champMemo qui ont une taille de police particulière pour un template document donné
- * @param templateDocument
- * @return
*/
private List<TemplateChampMemo> findAllTaillePoliceMemo(TemplateDocument templateDocument) {
/**
* Modification de la taille des polices dans les champs memo
- * @param element
- * @param allTaillePolice
*/
private void modifieTaillePoliceZoneMemo(JRElement element, List<TemplateChampMemo> allTaillePolice) {
/**
* lecture de la liste des fontes disponibles
- * @return
*/
public List<String> getAllFontes() {
List<String> resultat = []
/**
* Liste des tailles de police disponibles
- * @return
*/
public List<Integer> getAllTaillePolice() {
List<Integer> resultat = []
/**
* Vérification de la validité du nom de police
- * @param nom
*/
static public Boolean verifie(String nom) {
* Constructeur de ChampMemoResolver
* @param templatesChampMemo la liste des champs memo
* @param data la liste d'objets
- * @return
*/
ChampMemosResolver(List<TemplateChampMemo> templatesChampMemo, List<Object> data)
throws ImpressionServiceException {
* "Resoud" les champs memo incarnes par des templates groovy
* @param objet l'objet sur lequel on resoud
* @param properties la map des proprietes pour resolution
- * @return
*/
def resolve(Object objet) {
// fsil : peut etre optimise si on est sur que tous les objets
* @param nomChamp le nom du champ
* @param objet l'objet
* @param resProperties les propr
- * @return
*/
def resolveTemplateGroovyForChampAndObjectWithProperties(String templateGroovy,
String nomChamp,
* de fonctionnement de tomcat. Cette méthode a pour but de lire les
* informations en provenance du serveur jmx
* @author othe
- * @return
*/
public void populate() {
// on se connecte au serveur jmx
/**
* Indique si on a l'autorisation ou non de construire l'élément de menu. Par défaut on a toujours le droit
* d'avoir l'entrée dans le menu.
- * @return
*/
public Boolean autoriseAjoutElementMenu() {
true
/**
* Retourne l'élément de menu contruit
- * @return
*/
abstract public MenuItemInfo construitMenuItem(Object pageCourante)
/**
* Indique si le menu est vide
- * @return
*/
public boolean isEmpty() {
(items.size() == 0)
/**
* Construction du menu établissement
- * @param securiteSession
- * @param etablissementCourant
* @param codeLabelMenu : code label du menu principal
* @param pageCourante : object représentant la page courante
- * @return
*/
public EtablissementMenuItemInfo(SecuriteSession securiteSession,
Etablissement etablissementCourant,
/**
* Construction du menu établissement
- * @param securiteSession
- * @param etablissementCourant
- * @param codeLabelMenu : code label du menu principal
+ * @param codeLabelMenu : code label du menu principal
* @param pageCourante : object représentant la page courante
- * @return
*/
public EtablissementMenuItemInfo(SecuriteSession securiteSession,
Etablissement etablissementCourant,
/**
* retourne tous les items correspondant à un controlleur/action
- * @param controller
- * @param action
- * @return
*/
public List<MenuItemInfo> findAllItemsForControllerAction(String controleur,
String action) {
/**
* retourne le premier item correspondant à un controller/action
- * @param controller
- * @param action
- * @return
*/
public MenuItemInfo findFirstItemForControllerAction(String controleur,
String action) {
* @param pageCourante : page courante (pour selection dans menu)
* @param allFonctionnaliteAutorisees : liste des fonctionnalités autorisée pour la session courante
* @param menuApplication : description du menu de l'application
- * @return
*/
public MenuInfo getMenuInfo(SecuriteSession securiteSession,
Object pageCourante,
/**
*
- * @param securiteSession
- * @return
*/
private Etablissement getEtablissementCourant(SecuriteSession securiteSession) {
/**
*
- * @param securiteSession
- * @param etablissement
- * @param menuEntete
- * @param pageCourante
- * @param allFonctionnalite
- * @return
*/
private MenuItemInfo creeEnteteMenu(SecuriteSession securiteSession,
Etablissement etablissement,
/**
*
- * @param securiteSession
- * @param etablissement
- * @param menuItemInfoEnum
- * @return
*/
private AbstractMenu creeSousMenuFactory(SecuriteSession securiteSession,
Etablissement etablissement,
/**
*
- * @param menuEntete
- * @return
*/
private List<SousMenu> findAllSousMenu(Entete entete, List<SousMenu> sousMenus) {
List<SousMenu> listeMenu = sousMenus.findAll {
/**
*
- * @param securiteSession
- * @param etablissement
- * @param menuEntete
- * @return
*/
private AbstractMenu creeMenuFactory(SecuriteSession securiteSession,
Etablissement etablissement,
/**
*
- * @param pageCourante
- * @param menuEntete
- * @return
*/
private MenuItemInfo creeMenuNormal(Object pageCourante, Entete menuEntete) {
MenuItemInfo menuItemInfo = new MenuItemInfo(
/**
*
- * @param menuItemInfoEnum
- * @return
*/
private Class getMenuFactoryClasse(SousMenu menuItemInfoEnum) {
Class classeMenuFactory = menuItemInfoEnum.menuSpecial
/**
* Retourne la liste des id des documents accessibles par l'utilisateur
- * @param userId
- * @param docDemandes
- * @return
*/
List<DocUser> getDocUsersForUser(String userId,
List<String> docDemandes) {
/**
* Retourne une liste de documents selon les critères
- * @param userId
- * @param docIds
- * @param fieldsParams
* @return une liste de Map décrivant les documents
*/
List<MockDocumentCatalogueInfo> getDocsForUser(String userId,
/**
* Décrit le document selon le formalisme de Pass Tech
- * @return
*/
Map toMap(FieldsParams fieldsParams){
Map result = (Map)[:]
/**
* Récupère ou crée les Resultats correspondant aux intervalles de meme type
* que le type d'intervalle de la classe [S1,S2] ou [T1,T2,T3]
- * @param classe
* @return List < ResultatClassePeriode >
*/
List<ResultatClassePeriode> internalFindAllForXmestres(StructureEnseignement classe)
/**
* Positionne la moyenne
- * @param msan
*/
void internalSetMoyenne(ResultatClasseServicePeriode res,
BigDecimal moyenne,
/**
* Enregistre un résultat.
- * @param res
* @return ResultatClasseSousServicePeriode
*/
ResultatClasseSousServicePeriode save(ResultatClasseSousServicePeriode res) {
/**
* Cherche résultat parent
- * @return
*/
private ResultatClasseServicePeriode internalGetResParent(StructureEnseignement classe,
SousService sousService) {
/**
* Positionne la moyenne
- * @param res
* @param moyenne numerique ou textuelle (BigDecimal / NoteTextuelle)
- * @param msan
*/
void internalSetMoyenne(def res, Moyenne moyenne) {
if (res != null) {
/**
* True si au moins une appreciation not null existe pour la période sélectionnée
- * @return
*/
Boolean internalAppreciationExistePourPeriode(Periode periode) {
return AppreciationEleveEnseignementPeriode.createCriteria().get {
/**
* True si au moins une appreciation not null existe pour la période sélectionnée
- * @return
*/
Boolean internalAppreciationExistePourPeriode(Periode periode) {
return AppreciationElevePeriode.createCriteria().get {
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
* Attention! Retourne le résultat uniquement si le sous-service est évaluable
- * @return
* @author msan
*/
ResultatEleveSousServicePeriode internalFindOrCree(Autorite eleve,
/**
* Détermine l'url du serveur
- * @param applicationContext
- * @param autoriteTypeEliot
- * @param application
- * @param action
* @param parametres optionels
- * @return
*/
protected String genereUrl(ApplicationContext applicationContext,
String autoriteTypeEliot,
/**
* Récupère une autorité eliot
- * @param autoriteTypeEliot
- * @return
*/
protected SecuriteSession getSecuriteSessionEliot(String autoriteTypeEliot) {
/**
* Crée une demande de notification ; si le type de notification n'a pas
* été activé pour l'établissement, aucune opération ne sera réalisé
- * @param demandeNotification
*/
void creeDemandeNotification(DemandeNotification demandeNotification) {
}
/**
- * @param applicationContext
* @return la liste des destinataires potentiels, qui sont les élèves et
* les responsable d'élèves de la structure d'enseignement liée à l'évaluation
*/
}
/**
- * @param applicationContext
* @param responsableEleveDestinataire doit être un responsable d'élève
* attaché à un ou plusieurs élèves appartenant à la structure d'enseignement
* lié à l'évaluation sur laquelle porte cette notification
- * @param media
- * @return
*/
private Message getMessageResponsableEleve(ApplicationContext applicationContext,
Personne responsableEleveDestinataire,
/**
* Lecture des paramétrages pour un établissement
- * @param etablissement
- * @return
*/
public NotificationParametrageEtablissement getParametrageEtablissement(Etablissement etablissement) {
/**
* Enregistrement des paramétrages pour un établissement
- * @param etablissement
- * @param allNotificationParametrage
*/
public Boolean enregistreParametrageEtablissement(Etablissement etablissement, Map notificationsMisesAJour) {
/**
* Vérifie si la table 'ParametrageEtablissement' est vide', auquel cas on la rempli
- * @param etablissement
*/
public void verifieParametrageVide(Etablissement etablissement){
/**
* Rempli la table 'ParametrageEtablissement' pour l'établissement courant avec les paramètres par défaut
- * @param etablissement
*/
private void populateParametrageEtablissementVide(Etablissement etablissement){
/**
* Lecture des paramétrages pour une personne
- * @param etablissement
- * @return
*/
PreferencePersonneEtablissement getPreferencePersonne(Etablissement etablissement,
SecuriteSession securiteSession) {
/**
* enregistre les préférences de notification pour une personne
- * @param personne
- * @param allNotificationParametrage
*/
Boolean enregistrePreferenceUtilisateur(SecuriteSession securiteSession,
Etablissement etablissement,
/**
* Active un type de notification (sms + email) pour l'utilisateur
* suivant ses fonctions (si une fonction active les droits, ces droits seront actifs pour l'utilisateur)
- * @param etablissement
- * @param fonctions
- * @param droitFonction
- * @param notificationTypePreferenceUtilisateurs
* @return notificationTypePreferenceUtilisateurs
*/
private NotificationTypePreferenceUtilisateur activeNotificationParFonction(Etablissement etablissement,
}
/**
* Message listant les semaines importees
- * @param semaines
- * @return
*/
private String getMessageSemainesImportees() {
if (semainesImportes.isEmpty()) {
/**
* Recuepre la date de debut et la date de fin de la semaine
- * @param semaine
- * @param annee
- * @return
*/
def getDebutFin(Integer semaine, Integer annee) {
Calendar cal = GregorianCalendar.getInstance(Locale.FRANCE)
/**
* Retourne la liste des jours fériés en fonction de la préférence établissement
- * @param pref
- * @return
*/
public List<JourFerieInfo> getJourFeriesInfoForPreferenceEtablissement(
PreferencesEtablissementAbsences pref) {
/**
* Retourne une liste de dates correspondant à des jours fériés
- * @param pref
* @return une List<Date>
*/
public List<Date> getListeJoursFeriesForPreferencesEtablissement(
/**
* Vérifie l'existence des evts de fermeture hebdo dans la base et les crée
* si besoin
- * @param pref
- * @param calendrier
*/
private verifieExistenceEvtFermetureHebdo(PreferencesEtablissementAbsences pref, Calendrier calendrier) {
Agenda agenda = tempsAgendaService.getAgendaScolaireForEtablissement(
/**
* Ajout dans une map la liste des numéros de jours anglo-saxon
* associé à un boolean à false
- * @param map
*/
private void initialiseMapSemaine(Map map) {
map[Calendar.MONDAY] = false
/**
* Méthode surchargée dans CalendrierSessionService
- * @param evenements
*/
@SuppressWarnings('EmptyMethod')
protected void metListeEvtEnCacheSession(List<Evenement> evenements) {
/**
* Enregistre en base le paramétrage du calendrier annuel
- * @param sessionSecurite
* @param calendrierAnnuelInfo : le dto
* @param pref : PreferencesEtablissementAbsences
*/
/**
* Modification du jour de fermeture hebdo si necessaire
- * @param lst
- * @param pref
*/
private void setJourFermetureHebdo(List<Map> lst, PreferencesEtablissementAbsences pref) {
if (lst.size() != 0) {
/**
* Enregistre en base le paramétrage du calendrier annuel
- * @param securiteSession
* @param calendrierHebdoInfo : le dto
* @param pref : PreferencesEtablissementAbsences
*/
/**
* Modifie les dates du calendrier en supprimant éventuellement les appels
* qui sortent de la nouvelle plage
- * @param dateDebut
- * @param dateFin
- * @param pref
*/
public setDatesCalendrier(SecuriteSession securiteSession,
Date dateDebut,
/**
* Vérifie que les dates ne couvrent pas plus de 12 mois,
* sinon, déclenche une exception
- * @param dateDebut
- * @param dateFin
*/
private void verifieDates(Date dateDebut, Date dateFin) {
Calendar cal = Calendar.getInstance(Locale.FRANCE)
/**
* Retourne le nombre d'appels à supprimer lors du changement des dates
* de l'année scolaire
- * @param ancienneDateDebut
- * @param ancienneDateFin
- * @param nouvelleDateDebut
- * @param nouvelleDateFin
* @return le nombre d'appels à supprimer
*/
int calculeNombreAppelsASupprimerSurChangementDates(Date ancienneDateDebut,
/**
* Retourne la liste des appels à supprimer sur un changement de dates
- * @param ancienneDateDebut
- * @param ancienneDateFin
- * @param nouvelleDateDebut
- * @param nouvelleDateFin
- * @param pref
* @return une List<Appel>
*/
private List<Appel> getListeAppelsASupprimerSurChangementDates(Date ancienneDateDebut,
/**
* Supprime les appels hors des bornes lors du changement des dates de l'étab
- * @param ancienneDateDebut
- * @param ancienneDateFin
- * @param nouvelleDateDebut
- * @param nouvelleDateFin
- * @param pref
*/
public void supprimeAppelsSurChangementDeDates(Date ancienneDateDebut,
Date ancienneDateFin,
/**
* Supprime les jours fériés hors des bornes lors du changement des dates de l'étab
- * @param ancienneDateDebut
- * @param ancienneDateFin
- * @param nouvelleDateDebut
- * @param nouvelleDateFin
- * @param pref
*/
private void supprimeJoursFeriesSurChangementDeDates(Date ancienneDateDebut,
Date ancienneDateFin,
/**
* Retourne la liste des jours fériés de l'établissement entre deux dates
- * @param dateDebut
- * @param dateFin
- * @param etablissement
* @return une liste d'évènements
*/
List<Evenement> getEvenementsJoursFeriesEntreDatesPourEtab(
/**
* Enregistre en cache session la liste des évènements envoyée à l'interface
- * @param evenements
*/
protected void metListeEvtEnCacheSession(List<Evenement> evenements) {
String codeJour
/**
* Récupère dans le cache session, et retourne l'id d'un évènement
* à partir du jour et du mois
- * @param jour
- * @param mois
* @return en id d'Evenement
*/
Long getEvtIdForJourEtMois(String jour, String mois) {
/**
* Vérifie qu'il n'existe pas d'appel pour les jours féries que l'on en train
* de créer
- * @param listeJourFeries
- * @param pref
* @throws AppelExistantException
*/
def verifieJourFeries(List<JourFerieInfo> listeJourFeries,
/**
* Vérifie qu'il n'existe pas d'appel ou d'absence sur un jour férié en cours de création
- * @param listeJourFeries
- * @param pref
* @throws AppelExistantException
*/
def verifieUnJourFerie(JourFerieInfo jourFerie,
/**
* Calcule l'heure de début de la fermeture indépendemment du jour
- * @param jourFerie
- * @param calendrierInfo
- * @return
*/
Date calculeHeureDebut(JourFerieInfo jourFerie, CalendrierInfo calendrierInfo) {
Calendar cal = Calendar.getInstance()
/**
* Calcule l'heure de fin de la fermeture indépendemment du jour
- * @param jourFerie
- * @param calendrierInfo
- * @return
*/
Date calculeHeureFin(JourFerieInfo jourFerie, CalendrierInfo calendrierInfo) {
Calendar cal = Calendar.getInstance()
/**
* Retourne le jour du jour férié à 0:00:00:000
- * @param jourFerieInfo
- * @param calendrierInfo
- * @return
*/
private Date getJourDuJourFerie(JourFerieInfo jourFerieInfo, CalendrierInfo calendrierInfo) {
Calendar calJour = initialiseCalendarAuJour(jourFerieInfo, calendrierInfo)
/**
* Reconstitue le jour à partie des informations
- * @param jourFerieInfo
- * @param calendrierInfo
* @return un Calendar initialisé au jour
*/
Calendar initialiseCalendarAuJour(JourFerieInfo jourFerieInfo,
/**
* Calcule etat de l'évènement
- * @param evenement
- * @param plageHoraires
- * @return
*/
EtatJourEnum calculeEtatEvenement(Evenement evenement,
List<PlageHoraire> plageHoraires) {
/**
* Retourne la liste des évènements de fermeture de l'établissement
- * @param preferencesEtablissementAbsences
* @return une liste d'Evenement
*/
List<Evenement> getListeEvenements(PreferencesEtablissementAbsences
/**
* Retourne la liste des événements de fermeture de l'établissement entre
* deux dates
- * @param preferencesEtablissementAbsences
- * @param dateDebut
- * @param dateFin
* @return List < Evenement >
*/
List<Evenement> getListeEvenementsForPreferencesEtablissementAndDates(
/**
* Retourne la liste des évènements de fermeture à la journée de
* l'établissement
- * @param preferencesEtablissementAbsences
* @return une liste d'Evenement
*/
List<Evenement> getListeEvenementsJournee(PreferencesEtablissementAbsences
/**
* Crée un nouvel évènement et affecte les valeurs
- * @param jourFerieInfo
- * @param heuresEtDatesEtab
*/
void traiteNouvelEvenement(JourFerieInfo jourFerieInfo,
CalendrierInfo calendrierInfo,
/**
* Calcule l'objet de l'évènement en fonction de son état
- * @param jourFerieInfo
- * @param messagesEvt
* @return une chaine
*/
String getLibelleEvenement(JourFerieInfo jourFerieInfo, Map messagesEvt) {
/**
* Calcule la date du jour à partir des données du jour férie et du mois pivot
- * @param jourFerieInfo
- * @param moisPivot
* @return une Date
*/
private Date calculeDateDuJour(JourFerieInfo jourFerieInfo,
/**
* Récupère l'évènement existant et le met à jour
- * @param jourFerieInfo
- * @param calendrierInfo
*/
void traiteEvenementExistant(SecuriteSession securiteSession,
JourFerieInfo jourFerieInfo,
/**
* Met à jour les heures de l'évènement en fonction du code
- * @param evenement
- * @param jourFerieInfo
- * @param calendrierInfo
*/
private void metAJourEvt(Evenement evenement, JourFerieInfo jourFerieInfo,
CalendrierInfo calendrierInfo,
/**
* Crée un évènement de fermeture hebdo entre deux heures données
- * @param plageFermetureHebdoInfo
- * @param pref
*/
private void creeEvenementBorne(
PlageFermetureHebdoInfo plageFermetureHebdoInfo,
/**
* Calcule la date de fin de la plage de fermeture
- * @param jour
- * @param plageFermetureHebdoInfo
* @return un Calendar
*/
Calendar calculeDateHeureFin(Calendar jour,
/**
* Calcule la date de début de la plage de fermeture
- * @param jour
- * @param plageFermetureHebdoInfo
* @return un Calendar
*/
Calendar calculeDateHeureDebut(Calendar jour,
/**
* Retourne la liste des jours dans l'année scolaire pour un jour de la
* semaine donné
- * @param plageFermetureHebdoInfo
- * @return
*/
List<Calendar> getJoursAffectes(
PlageFermetureHebdoInfo plageFermetureHebdoInfo,
/**
* Retourne la première occurence du jour de la semaine dans l'année scolaire
- * @param plageFermetureHebdoInfo
- * @param calendrier
- * @return
*/
private Calendar getPremiereOccurenceDuJourDeLaSemaine(
PlageFermetureHebdoInfo plageFermetureHebdoInfo, Calendrier calendrier) {
/**
* Crée un évènement de fermeture hebdo pour toute la journée
- * @param plageFermetureHebdoInfo
- * @param pref
*/
private void creeEvenementJournee(
PlageFermetureHebdoInfo plageFermetureHebdoInfo,
/**
* Supprime les évènements de fermeture hebdomadaire existants dans la base
- * @param pref
*/
@SuppressWarnings('CatchException')
private void supprimeEvenementsFermetureHebdo(Agenda agendaEtab) {
/**
* Crée une liste de PlageFermetureHebdoInfo à partir des plages horaires de
* l'établissement
- * @param pref
* @return une List<PlageFermetureHebdoInfo>
*/
private List<PlageFermetureHebdoInfo> getListePlagesFermeturesHebdo(
/**
* Pour chaque jour de la semaine, si la journée se termine par une plage
* horaire fermée, on crée une plage de fermeture
- * @param debutPlages
- * @param finDernierePlage
*/
private List<PlageFermetureHebdoInfo> creePlagesDeFinDeJournee(
Map debutPlages,
/**
* Crée une plage de fermeture à partir des données passées
- * @param debutPlage
- * @param finPlage
- * @param jourSemaine
- * @param debutJournee
- * @param finJournee
* @return une PlageFermetureHebdoInfo
*/
PlageFermetureHebdoInfo creePlageDeFermeture(Date debutPlage,
/**
* Indique si la plage horaire devient fermée par rapport à la précédente
- * @param plageHoraire
- * @param debutPlages
- * @param jourSemaine
* @return un Boolean
*/
private boolean etatPlageDevientFermee(PlageHoraire plageHoraire,
/**
* Indique si la plage horaire devient ouverte par rapport à la précédente
- * @param plageHoraire
- * @param debutPlages
- * @param jourSemaine
* @return un Boolean
*/
private boolean etatPlageDevientOuverte(PlageHoraire plageHoraire,
/**
* Retourne le nom de la propriété de la plage horaire qui correspond au
* jour de la semaine
- * @param jourSemaine
* @return le nom de la propriété
*/
private String getNomProprieteJour(int jourSemaine) {
/**
* Initialise la map contenant les débuts de plages fermées
- * @return
*/
Map initialiseDebutPlages() {
Calendar cal = Calendar.getInstance()
/**
* Affectation du premier jour de l'année scolaire
- * @param jour
*/
void setPremierJour(Date jour) {
Calendar cal = Calendar.getInstance()
/**
* Affectation du dernier jour de l'année scolaire
- * @param jour
*/
void setDernierJour(Date jour) {
Calendar cal = Calendar.getInstance()
/**
* Affectation des évènements du calendrier d'établissement
- * @param evenements
*/
void setListeEvenements(List<Evenement> evenements) {
this.evenementsEtablissement = evenements
/**
* Affectation des données de calendrier
- * @param calendrierInfo
*/
void setCalendrierInfo(CalendrierInfo calendrierInfo) {
this.calendrierInfo = calendrierInfo
/**
* Affectation des noms de mois
- * @param nomsMois
*/
void setNomsMois(Map nomsMois) {
this.nomsMois = nomsMois
/**
* Affectation de la liste des matinées de fermeture hebdo
- * @param demiJourneesHebdoMatin
*/
void setDemiJourneesHebdoMatin(List<Integer> demiJourneesHebdoMatin) {
this.demiJourneesHebdoMatin = demiJourneesHebdoMatin
/**
* Affectation de la liste des après-midi de fermeture hebdo
- * @param demiJourneesHebdoMatin
*/
void setDemiJourneesHebdoApresMidi(List<Integer> demiJourneesHebdoApresMidi) {
this.demiJourneesHebdoApresMidi = demiJourneesHebdoApresMidi
/**
* Vérrouille les jours après la fin de l'année scolaire
- * @param donneesMois
- * @param dernierJour
- * @return
*/
Map traiteBorneFin(Map donneesMois, Date dernierJour) {
Calendar cal = Calendar.getInstance()
/**
* Verrouille les demi-journées de fermeture hebdomadaire
- * @param donneesMois
- * @param mois
- * @param annee
* @return les données du mois modifiées
*/
private Map ajouteDemiJourneesHebdo(Map donneesMois, int mois, int annee) {
/**
* Positionne une journée de fermeture hebdomadaire
- * @param donneesMois
- * @param jour
* @return les données du mois modifiées
*/
private Map traiteFermetureHebdoJournee(Map donneesMois, int jour) {
/**
* Positionne une demi-journée de fermeture hebdo le matin
- * @param donneesMois
- * @param jour
* @return les données du mois modifées
*/
Map traiteFermetureHebdoMatin(Map donneesMois, Integer jour) {
/**
* Positionne une demi-journée de fermeture hebdo l'après-midi
- * @param donneesMois
- * @param jour
* @return les données du mois modifées
*/
Map traiteFermetureHebdoApresMidi(Map donneesMois, Integer jour) {
/**
* Ajoute les jours inexistants dans les données du mois
- * @param donneesMois
- * @param mois
- * @param annee
* @return les données du mois complétées
*/
Map ajouteJoursInexistants(Map donneesMois, int mois, int annee) {
/**
* Complète les données du mois avec le jour de fermeture hebdomadaire
- * @param donneesMois
- * @param mois
- * @param annee
- * @return
*/
Map ajouteFermetureHebdo(Map donneesMois, int mois, int annee) {
Integer curseur = 1
/**
* Ajoute dans la map donneesMois les jours féries du calendrier de l'étab
- * @param donneesMois
- * @param evts
*/
Map ajouteJoursFeries(Map donneesMois, int mois, int annee) {
Calendar cal = Calendar.getInstance()
/**
* Retourne les évènements du mois
- * @param mois
- * @param annee
- * @return
*/
private List<Evenement> getEvenementsDuMois(int mois, int annee) {
List<Evenement> result = []
/**
* Compte les pas de decompte ouvert et non feriés) sur la période
- * @param securiteSession
- * @param dateDebut
- * @param dateFin
* @return nbPasDeDecompteOuvert
*/
Float countPasDeDecompteOuvertSurPeriode(SecuriteSession securiteSession,
/**
* Retourne tous les jours à évaluer sur la période
* (avec leur nombre de pas de decompte matin et aprem)
- * @param securiteSession
- * @param dateDebut
- * @param dateFin
- * @param preferencesEtablissementAbsences
* @return listeJourAEvaluer
*/
ListeJoursAEvaluer findJoursAEvaluerSurPeriode(
* Retourne un nombre de pas de decompte ouvert suivant le pas de decompte,
* la longueur plage, et pour le matin ou l'après-midi,
* ceci pour des plages horaires données
- * @param pasDeDecompte
- * @param longueurPlage
- * @param plagesHorairesOuvertes
- * @param matin
* @return nbPasDeDecompteOuvert
*/
private float calculeNbPasDeDecompteOuverts(
/**
* Retourne le nom du jour pour une PlageHoraireInfo
* en fonction du jour de la semaine
- * @param date
* @return nomDuJour
*/
private String getNomDuJour(Date date) {
/**
* Retourne la liste des plagesHorairesInfo qui sont ouvertes (0)
* pour un jour donné
- * @param nomDuJour
- * @param preferencesEtablissementAbsences
- * @param calendrierHebdoInfo
* @return plagesHorairesOuvertes
*/
private List<PlageHoraireInfo> getPlagesHorairesOuvertesJour(
/**
* Exécute la requête de récupération des plages horaires ordonnées
- * @param pref
- * @return
*/
private List<PlageHoraire> getListePlageHorairesOrdonnee(
PreferencesEtablissementAbsences pref) {
/**
* Retourne l'heure pivot du calendrier hebdo enregistré en base
- * @param pref
* @return l'heure pivot
*/
Date getHeurePivot(PreferencesEtablissementAbsences pref) {
/**
* Retourne l'heure d'ouverture de l'établissement
- * @param pref
* @return une Date
*/
Date getHeureOuvertureEtablissement(PreferencesEtablissementAbsences pref,
/**
* Retourne l'heure de fermeture de l'établissement
- * @param pref
* @return une Date
*/
Date getHeureFermetureEtablissement(PreferencesEtablissementAbsences pref,
/**
* Indique si la statut de la plage horaire est fermé ou ouvert
- * @param statut
* @return true=ouvert
*/
private Boolean getOuverturePlage(Integer statut) {
/**
* Convertie les données de plageHoraireInfo vers plageHoraire
- * @param pref
- * @param plageHoraire
- * @param plageHoraireInfo
*/
void copyPlageHoraireInfoToPlageHoraire(
PreferencesEtablissementAbsences pref,
/**
* convertion des valeurs de la base (binaires) vers les valeurs de la vue (qui
* tien compte du jour de fermeture
- * @param numJour
- * @param jourFerie
- * @param ouverture
- * @return
*/
private int getValeurJour(int numJour, int jourFermeture, Boolean ouverture) {
if (numJour == jourFermeture) {
/**
* Retourne le PlageHoraireInfo correspondant à une PlageHoraire
- * @param plageHoraire
* @return un PlageHoraireInfo
*/
PlageHoraireInfo getPlageHoraireInfoFromPlageHoraire(
/**
* retourne la plage du jour en fonction d'une plage horaire
- * @param plageHoraire
- * @return
*/
private PlageDuJourInfo getPlageDuJourFromPlageHoraire(PlageHoraire plageHoraire) {
SimpleDateFormat sdf = new SimpleDateFormat(
/**
* Retourne l'heure minute contenu dans la date
- * @param date
- * @return
*/
private Date getTime(Date date) {
Calendar cal = Calendar.getInstance()
* @param plageHoraire : plage horaire à tester
* @param heureDebut : début de l'intervalle
* @param heureFin : fin de l'intervalle
- * @return
*/
private Boolean getDansPlageHebdo(PlageHoraire plageHoraire,
Date heureDebut,
/**
* Retourne le liste des plages horaires pour une date donnée et un établissement donnée
- * @param securiteSession
- * @param date
- * @param preferencesEtablissementAbsences
* @return dto contenant les informations de plages horaires
*/
public ListePlagesHorairesInfo listerHoraires(SecuriteSession securiteSession,
/**
* Retourne les id des plages fermées par rapport à un évènement et une plage horaire
- * @param evenement
- * @param plageHoraires
*/
private void constructionListePlagesHorairesFermees(
Evenement evenement,
/**
* Retourne la liste des plages horaires comprises entre deux bornes
- * @param idPlageDebut
- * @param idPlageFin
- * @param pref
* @return une List<PlageHoraire>
*/
public List<PlageHoraire> getPlagesEntreBornes(Long idPlageDebut,
/**
* recherche dans plageHoraires2 les plages horaires qui sont dans
* plageHoraires1.
- * @param plageHoraires
- * @param plageHoraires
* @return true s'l existe une correspondance
*/
Boolean isPlagesHorairesIdentiques(List<PlageHoraire> plageHoraires1,
/**
* Vérifie si la plage horaire est ouverte par rapport au calendrier hebdo
- * @param date
- * @param jourFeries
- * @param plageHoraire
- * @param calendrier
- * @return
*/
Boolean isPlageHoraireOuverte(Date date,
List<JourFerieInfo> jourFeries,
/**
* Vérifie si la plage horaire est ouverte par rapport aux informations
* de jours fériés du calendrier annuel
- * @param date
- * @param jourFerieInfos
- * @param plageHoraire
- * @return
*/
private Boolean isPlageAnnuelleOuverte(Date date,
List<JourFerieInfo> jourFerieInfos,
/**
* Contrôle si la plage horaire est ouverte
- * @param date
- * @param plageHoraire
- * @param calendrier
- * @return
*/
private Boolean isPlageHebdoOuverte(Date date, PlageHoraire plageHoraire, Calendrier calendrier) {
Calendar cal = Calendar.getInstance()
}
/**
- * @param pref
* @return l'ordre max pour les groupes de motifs de la base
*/
Integer getOrdreMax(PreferencesEtablissementAbsences pref) {
/**
* Vérifie l'unicité du groupe de motifs
- * @param preferencesEtablissementAbsences
- * @param libelle
* @throws GroupeMotifException
*/
private verifieUniciteGroupeMotif(PreferencesEtablissementAbsences pref,
/**
* Retourne la liste des groupes de motifs trié par ordre
- * @return
*/
public List<GroupeMotif> findAllGroupeMotifByPreferencesEtablissement(PreferencesEtablissementAbsences pref) {
List<GroupeMotif> allMotif = GroupeMotif.findAllByPreferencesEtablissement(pref, [fetch:['motifs':FetchMode.JOIN]])
/**
* Retrouve le numéro d'ordre du groupeMotif précédent le groupeMotif passé en paramètre dans la liste des
* groupeMotif de la PreferencesEtablissementAbsences
- * @param groupeMotif
- * @param pref
- * @return
*/
public Integer getNumeroOrdrePrecedent(GroupeMotif groupeMotif, PreferencesEtablissementAbsences pref) {
/**
* Retrouve le numéro d'ordre du groupeMotif suivant le groupeMotif passé en paramètre dans la liste des
* groupeMotif de la PreferencesEtablissementAbsences
- * @param groupeMotif
- * @param pref
- * @return
*/
public Integer getNumeroOrdreSuivant(GroupeMotif groupeMotif, PreferencesEtablissementAbsences pref) {
/**
* Permet de déplacer un groupe de motif
- * @param groupeADeplacer
- * @param groupeARemplacer
* @return la liste des objets GroupeMotif modifiés
*/
public List<GroupeMotif> deplaceGroupeMotif(GroupeMotif groupeADeplacer,
/**
* Modifie le numéro d'ordre de tous les groupes motif
* @param ordre : numéro de départ
- * @param resultat
*/
private void modifierNumeroOrdreAllGroupe(int ordre, List<GroupeMotif> resultat) {
/**
* monter un groupe motif dans la liste des groupes motif
- * @param groupeMotif
- * @param pref
* @return les 2 groupeinfos modifiés par l'opération
*/
public List<GroupeMotif> monterGroupeMotif(GroupeMotif groupeMotif, PreferencesEtablissementAbsences pref) {
/**
* descendre un groupe motif dans la liste des groupes motif
- * @param groupeMotif
- * @param pref
* @return les 2 groupeinfos modifiés par l'opération
*/
public List<GroupeMotif> descendreGroupeMotif(GroupeMotif groupeMotif, PreferencesEtablissementAbsences pref) {
/**
* Transforme une liste de groupes de motifs en
- * @param groupeMotifs
- * @return
*/
List getGroupesMotifsForJSON(List<GroupeMotif> groupeMotifs) {
List result = []
/**
* Modifie le disponibilité d'un motif
- * @param securiteSession
- * @param motif
- * @param dispoBulletin
- * @param dispoStats
*/
public void modifieDisponibiliteMotif(SecuriteSession securiteSession,
Motif motif,
/**
* Retourne la liste de tous les motifs de l'établissement
- * @param etab
* @param exclureMotifNonModifiable : si true, ne renvoie pas les motif
* non modifiables ("sans motif")
* @return une liste de Motifs
* @param priseEnCompteMotif : Paramètre de prise en compte
* @param listeVideEgalTous : si true, retourne une liste vide au lieu de
* tous les motifs
- * @return
*/
List<Motif> findAllMotifForPriseEnCompteMotif(
Etablissement etablissement,
* @param priseEnCompteMotif : Paramètre de prise en compte
* @param listeVideEgalTous : si true, retourne une liste vide au lieu de
* tous les motifs
- * @return
*/
List<Motif> findAllMotifForPriseEnCompteMotif(
PreferencesEtablissementAbsences pref,
}
/**
- * @param pref
* @return Les motifs à prendre en compte pour les stats
*/
List<Motif> getMotifsForStats(PreferencesEtablissementAbsences pref) {
}
/**
- * @param pref
* @return Les motifs à prendre en compte pour les bulletin
*/
List<Motif> getMotifsForBulletin(PreferencesEtablissementAbsences pref) {
/**
* Indique si le service de catalogue est actif pour l'établissement
- * @param etablissementIdExterne
- * @param codePorteur
* @return true si le catalogue est actif, false sinon
*/
Boolean isServiceCatalogueActif(String etablissementIdExterne,
/**
* Indique si un des services du portail est actif pour l'établissement
- * @param etablissement
* @return true si le service est actif, false sinon
*/
private Boolean isServicePortailActif(Long serviceId,
/**
* Indique si le service de catalogue est actif pour l'établissement
- * @param etablissementIdExterne
- * @param codePorteur
* @return true si le catalogue est actif, false sinon
*/
Boolean isServiceCatalogueActif(String etablissementIdExterne,
/**
* Verifie dans l'annuaire local si l'autorite acteur est active
- * @param idExterneAutorite
* @return true si l'autorite acteur est active
*/
Boolean isAutoriteActeurActive(String idExterneAutorite) {
/**
* Retourne l'id externe (ID AAF) de l'utilisateur associé à cette session HTTP
- * @param httpSession
- * @return
*/
String getPersonneIdExterne(def httpSession) {
return httpSession."${Constantes.SESSION_ATTRIBUT_UID}"
/**
* Retourne la liste des identifiants de groupes stockés en session par le CAS du portail
* Ces identifiants sont définis dans le référentiel distant (portail)
- * @param httpSession
- * @return
*/
List<Long> getGroupesIds(def httpSession) {
def groupes = httpSession."${Constantes.SESSION_ATTRIBUT_USERGROUPES}"
/**
* Extrait le code porteur ENT d'une requête HTTP
- * @param httpRequest
- * @return
*/
String getCodePorteurENT(def httpRequest) {
// fsil : cherche le code porteur en paramètre de la request
/**
* Retourne le type d'utilisateur (au sens du portail) qui est stocké en session
- * @param httpSession
- * @return
*/
String getUtilisateurType(def httpSession) {
return httpSession."${Constantes.SESSION_ATTRIBUT_USERTYPE}"
* Retourne les informations de login (login simple + type utilisateur) à partir du login étendu
* Le login étendu peut contenir un préfixe pour les connexions admin & correspondant de
* déploiement
- * @param loginEtendu
- * @return
* @author jtra
*/
LilieLoginInfo getLoginInfoFromLoginEtendu(String loginEtendu) {
}
/**
- * @param httpSession
* @return le type d'utilisateur associé à cette session
*/
TypeUtilisateur getTypeUtilisateur(def httpSession) {
/**
* Extrait les informations contenues dans la requête HTTP
- * @param httpRequest
- * @return
*/
LilieHttpInfo parseLilieHttpInfo(def httpRequest) {
return new LilieHttpInfo(
/**
* Initialise la session HTTP pour les applications Eliot
* Contruit l'acteur, la securiteSession, et stocke ces informations dans la session HTTP
- * @param httpRequest
*/
@Transactional
void initialiseHttpSessionActeur(def httpRequest) {
* Retourne l'idExterne (AAF) de l'établissement de rattachement d'un utilisateur
* Note jtra : cette méthode est utilisée pour traiter le cas particulier des correspondants
* de déploiement
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
* @throws IllegalStateException si l'établissement de rattachement n'a pas pu être déterminé
*/
/**
* Mis à jour les informations de la modalité cours
* @param modaliteCours la moadalité cours à mettre à jour
- * @param modCoursInfo
* @return modaliteCours la moadalité cours mit à jour
*
*/
/**
* Retourne la liste des modalites matiere pour l'établissement
- * @param etablissement
- * @param securiteSession
* @return liste des modalites
* @author msan
*/
/**
* Verifier que le directeur de l'etablissement est le seul autorisé pour la modification ou creation
- * @param securiteSession
- * @param Etablissement
* @author mjao
*/
void verifieAutorisationModifierModaliteMatiereManuel(SecuriteSession securiteSession,
}
/**
* Verifier que le directeur de l'etablissement est le seul autorisé pour la suppression
- * @param securiteSession
- * @param Etablissement
* @author mjao
*/
void verifieAutorisationsupprimeModaliteMatiereManuel(SecuriteSession securiteSession,
}
/**
- * @param etablissement
* @return Retourne les niveaux de l'établissement
*/
List<NiveauGeneral> findAllNiveauGeneralByEtablissement(Etablissement etablissement){
/**
* Périodes d'année lié à la structure d'enseignement
- * @param structureEnseignement
- * @return
* @author msan
*/
List<Periode> findAllPeriodesAnnee(StructureEnseignement structureEnseignement) {
* 1. Classe => Les périodes rattachées
* 2. Regroupement => Les périodes rattachées aux classes du regroupement
* 3. Groupe local => Une liste vide car les groupes ne doivent pas avoir de période
- * @param struct
* @return List < Periode >
* @author bper
*/
/**
* Periode d'une classe et un typePeriode
- * @param classe
- * @param typePeriode
- * @return
* @author msan
*/
Periode getPeriode(StructureEnseignement classe, TypePeriode typePeriode) {
/**
* Periodes d'une classe et optionellement une nature de periode
- * @param classe
* @param naturePeriode nature de periode (optionelle)
- * @return
* @author msan
*/
List<Periode> findAllPeriodeParClasseNature(StructureEnseignement classe,
/**
* Liste périodes d'un service et une classe
- * @param service
- * @param classe
- * @return
* @author msan
*/
List<Periode> internalFindAllByServiceAndClasse(Service service,
/**
* Toutes les periodes de Xmestres precedantes la periode pour la classe donnee
- * @param classe
- * @param periode
- * @return
*/
List<Periode> findAllPeriodesPrecedentes(StructureEnseignement classe, Periode periode) {
if (!classe.isClasse()) {
/**
* Nom court I18n de periode - DEPRECATED. Utilisez getPeriodeCodeCourt et internalisation au lieu.
- * @param libelleTypePeriode
- * @return
* @deprecated Utilisez getPeriodeCodeCourt et i18n au lieu.
*/
public String getNomPeriodePrecedente(String libelleTypePeriode){
/**
* Vérifie si un service principal d'aorigine AUTO existe déjà pour le couple
* (matiere, structureEnseignement)
- * @param matiere
- * @param structureEnseignement
* @return true/false
* @author bper
*/
* Vérifie que l'utilisateur possède l'autorisation modifier les services
* Modification est autorisée uniquement pour le personnel de la direction de l'établissement
* @param securiteSession la session de sécurité courante
- * @param service
* @throws AutorisationException
*
* @author msan
* Vérifie que l'utilisateur possède l'autorisation supprimer les services
* Suppression est autorisée uniquement pour le personnel de la direction de l'établissement
* @param securiteSession la session de sécurité courante
- * @param service
* @throws AutorisationException
*
* @author msan
* Vérifie que l'utilisateur possède l'autorisation modifier les services
* Modification est autorisée uniquement pour le personnel de la direction de l'établissement
* @param securiteSession la session de sécurité courante
- * @param etablissement
* @throws AutorisationException
*
* @author msan
/**
* Recherche un service en fonction de sa matière, sa structure d'enseignement
* et sa modalité cours
- * @param matiere
- * @param structureEnseignement
- * @param modaliteCours
* @return le service recherché, ou null s'il n'existe pas
*/
public Service findService(Matiere matiere,
/**
* Services d'une classe
- * @param classe
- * @return
* @author msan
*/
List<Service> getServicesPourClasse(StructureEnseignement classe) {
/**
* Retourne les service pour une période
- * @param periode
* @return List < Service >
* @author bper
*/
/**
* Cherche les services par ids
- * @param ids
- * @return
* @author msan
*/
List<Service> internalFindAllByIds(List<Long> ids) {
* http://adhockery.blogspot.com/2009/06/querying-by-association-redux.html
* http://jira.codehaus.org/browse/GRAILS-7087
*
- * @param service
- * @return
* @author msan
*/
Service internalRechargeParForce(Service service) {
/**
* Retourne tous les services évaluables pour un couple (classe, période)
- * @param classe
- * @param periode
- * @return
*/
List<Service> findAllServiceEvaluableByClasseAndPeriode(
StructureEnseignement classe,
/**
* Get type periode par typeIntervalle (e.g. T1, S2, ANNEE ...)
- * @param typeIntervalleEnum
- * @return
* @author msan
*/
TypePeriode getTypePeriode(IntervalleEnum intervalleEnum) {
/**
* Retourne un type de période "équivalent":
* (1T <=> 1S, 2T <=> 2S, 3T => null, ANNEE => null)
- * @param typePeriode
* @return TypePeriode
* @author bper
*/
/**
* Toutes les propriétés liées à une structure d'enseignement
- * @param structureEnseignement
- * @return
*/
public List<ProprietesScolarite> findAllByStructureEnseignement(StructureEnseignement structureEnseignement) {
return ProprietesScolarite.withCriteria {
/**
* Execute la requete hql associé à une liste de propriété scolarité
- * @param hql
- * @param ps
*/
private void internalSupprimeHql(String hql, List<ProprietesScolarite> ps) {
if (ps?.size() > 0) {
/**
* Supprime toutes ls PS définies dans la liste
- * @param ps
*/
public void supprimeProprietesScolarite(List<ProprietesScolarite> ps) {
internalSupprimeHql("delete ProprietesScolarite p where p in (:ps)", ps)
/**
* Supprime toutes ls PPS liés aux proprietés scolarité
- * @param ps
*/
public void supprimePersonneProprietesScolarite(List<ProprietesScolarite> ps) {
internalSupprimeDomain("PersonneProprietesScolarite", ps)
/**
* Convertion d'une liste de chaine en une chaine comprenant tout les
* items séparés par ','
- * @param lstString
* @return la chaine
*/
private String stringListToString(List<String> lstString) {
/**
* Retourne la liste des personnes correspondantes aux critères de
* propriété scolarité
- * @param args
* @param actif true - les personne actuellement associées à la ProprietesScolarite
* false - les personne n'étant plus associées à la ProprietesScolarite
* null - toutes les personne qui sont ou étaient associées à la ProprietesScolarite
/**
* Retourne la liste des responsables correspondant aux critères de
* propriété scolarité
- * @param args
* @param actif true - les personne actuallement associées à la ProprietesScolarite
* false - les personne n'étant plus associées à la ProprietesScolarite
* null - toutes les personne qui sont ou étaient associées à la ProprietesScolarite
/**
* Vérifie si l'établissement fait partie d'une cité scolaire
- * @param etablissement
- * @return
*/
Boolean isEtablissementHavingCiteScolaire(Etablissement etablissement) {
return (etablissement.etablissementRattachement != null)
/**
* Vérifie si l'établissement est une cité scolaire
- * @param etablissement
- * @return
*/
Boolean isEtablissementUneCiteScolaire(Etablissement etablissement) {
return (etablissement.id == etablissement.etablissementRattachementId)
/**
* Recherche un établissement par son idExterne (référenciel AAF)
- * @param idExterne
* @return l'établissement si il existe
* @throws EtablissementException si l'établissement n'existe pas
* @author jtra , othe
/**
* Recherche un établissement par son code UAI
- * @param uai
* @param failOnError leve une exception si l'etablissmeent n'est pas trouve
* @return l'établissement si il existe
* @throws EtablissementException si l'établissement n'existe pas et failOnError == true
/**
* Lecture du logo de l'établissement
- * @param etablissement
- * @return
*/
public byte[] getLogo(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement = getPreferenceEtablissement(etablissement)
/**
* Lecture du cachet de l'établissement
- * @param etablissement
- * @return
*/
public byte[] getCachet(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement = getPreferenceEtablissement(etablissement)
/**
* Suppression du cachet de l'établissement
- * @param etablissement
*/
public void supprimeCachet(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement = getPreferenceEtablissement(etablissement)
/**
* Suppression du logo de l'établissement
- * @param etablissement
*/
public void supprimeLogo(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement = getPreferenceEtablissement(etablissement)
/**
* Enregistrement du logo de l'établissement
- * @param etablissement
- * @param logo
*/
public void setLogo(Etablissement etablissement, byte[] logo) {
PreferencesEtablissement preferencesEtablissement =
/**
* Enregistrement du cachet de l'établissement
- * @param etablissement
- * @param cachet
*/
public void setCachet(Etablissement etablissement, byte[] cachet) {
PreferencesEtablissement preferencesEtablissement =
/**
* Lecture de la préférence établissement
* @param etablissement : l'établissement pour lequel on veut ses préférences
- * @return
*/
public PreferencesEtablissement getPreferenceEtablissement(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement = PreferencesEtablissement.findByEtablissement(etablissement)
/**
* Enregistrement des préférences établissement
- * @param preferencesEtablissement
*/
public void setPreferenceEtablissement(PreferencesEtablissement preferencesEtablissement) {
preferencesEtablissement.save(flush: true, failOnError: true)
/**
* Retourne l'état de l'activation de la liaison vers la vie scolaire
- * @param etablissement
- * @return
*/
Boolean isLiaisonVieScolaireActive(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement =
/**
* Retourne l'état de l'activation de la liaison vers Magister-ParentWeb
- * @param etablissement
- * @return
*/
Boolean isLiaisonMagisterActive(Etablissement etablissement) {
PreferencesEtablissement preferencesEtablissement =
/**
* indique si une personne a une fonction
- * @param personne
- * @param fonctionEnum
* @return vrai si la personne a la fonction
*/
public Boolean hasFonction(Personne personne, FonctionEnum fonctionEnum) {
/**
* Indique si l'autorité à une fonction sur l'établissement
- * @param autorite
- * @param typeRole
- * @param etablissement
* @return vrai si l'autorité à une fonction sur l'établissement
* @throws Exception
* @author othe
/**
* Indique si l'autorité à une fonction sur l'établissement
- * @param autorite
- * @param typeRole
- * @param etablissement
* @return vrai si l'autorité à une fonction sur l'établissement
* @throws Exception
* @author othe
/**
* Ajout les fonctions d'admin local. Utilise pour la gestion
* des droits dans cites scolaires des Admin Locaux
- * @param fonctionEtablissements
- * @return
*/
List<FonctionEtablissement> ajoutFonctionsCiteScolaireAdminlocal(List<FonctionEtablissement> fonctionEtablissements) {
/**
* Ajout les fonctions d'utilisateur. Utilise pour la gestion
* des droits dans cites scolaires des utilisateurs normaux
- * @param fonctionEtablissements
- * @return
*/
List<FonctionEtablissement> ajoutFonctionsCiteScolaireUtilisateurNormal(List<FonctionEtablissement> fonctionEtablissements) {
* des droits dans cites scolaires.
* @param fonctionEtablissements liste de FonctionEtablissement courant
* @param fonctionEnumsAcopier fonctions a copier dans les etablissements de cite
- * @return
*/
private List<FonctionEtablissement> ajoutFonctionsCiteScolaire(List<FonctionEtablissement> fonctionEtablissements,
List<FonctionEnum> fonctionEnumsAcopier) {
/**
* indique si une personne est un enseignant
- * @param personne
* @return vrai si la personne est un enseignant
*/
Boolean isEnseignant(Personne personne) {
/**
* indique si une personne est un documentaliste
- * @param personne
* @return vrai si la personne est un documentaliste
*/
Boolean isDocumentaliste(Personne personne) {
/**
* indique si une personne est un personel d'éducation (cpe)
- * @param personne
* @return vrai si la personne est un personel d'éducation (cpe)
*/
Boolean isPersonelEducation(Personne personne) {
/**
* Retrourne l'ensemble des fonctions établissements d'un utilisateur pour un établissement
- * @param personne
- * @param etablissement
- * @return
* @author bahj
*/
List<FonctionEtablissement> findAllFonctionEtablissementBy(Etablissement etablissement,
/**
* Retourne la liste des fonctions / établissement pour une autorite de type Acteur en
* prenant en compte le typeUtilisateur (normal, admin, correspondant de déploiement)
- * @param personne
- * @param typeUtilisateur
* @return La liste des Fonction/Etablissement de l'utilisateur associé à l'autorité
* @throws IllegalArgumentException si l'autorité n'est pas de type acteur ou si le
* typeUtilisateur est incorrect
/**
* Retourne la liste des fonctions / établissement pour un utilisateur normal
- * @param personne
* @return La liste des Fonction/Etablissement de l'utilisateur associé à l'autorité
* @author jtra
*/
/**
* Retourne la liste des fonctions / établissement pour un admin local
* (seules les fonctions/établissement de type 'admin local' sont retournées)
- * @param personne
* @return La liste des Fonction/Etablissement de l'utilisateur associé à l'autorité
* @throws IllegalStateException si l'autorité n'est pas un admin local
* @author jtra
/**
* Retourne la liste des fonctions / établissement pour un correspondant de déploiement
* (seules les fonctions/établissement de type 'correspondant déploiement' sont retournées)
- * @param personne
* @return La liste des Fonction/Etablissement de l'utilisateur associé à l'autorité
* @throws IllegalStateException si l'autorité n'est pas un correspondant de déploiement
* @author jtra
* Extrait une liste de FonctionEtablissement à partir d'une requete hql
* @param hql : source de la requete
* @param parametres : éventuel paramètres à passer à la requete
- * @return
*/
private List<FonctionEtablissement> findAllFonctionEtablissement(String hql,
Personne personne,
/**
* Vérifie que la securiteSession a l'autorisation de créer une matière
* quelconque (AUTO ou MANUEL) sur l'établissement fournit
- * @param securiteSession
- * @param etablissement
* @throws AutorisationException
* @author jtra
*/
/**
* Recherche une matière par code gestion & établissement
- * @param codeGestion
- * @param etablissement
* @return la matière si elle existe, sinon null
*/
Matiere findMatiereByCodeGestionAndEtablissement(String codeGestion,
/**
* Retourne les matières enseignés par le prof pour l'établissement
- * @param enseignant
- * @param etablissement
* @return liste des matières
* @author bahj
* @author msan
/**
* Retourne la liste des matieres pour l'établissement
- * @param securiteSession
- * @param etablissement
* @return liste des matieres
* @author mjao
*/
/**
* Verifier si la matiere est utilise dans les services
- * @param matiere
- * @param securiteSession
* @author mjao
*/
boolean isMatiereUtilise(SecuriteSession securiteSession, Matiere matiere) {
/**
* Retourne le nom d'affichage d'une autorité
- * @param autorite
* @param avecMEF si le nom de groupe devrait contenir l'information sur le MEF ou pas
- * @return
* @author jtra
*/
String getNomAffichage(Autorite autorite, Boolean avecMEF = false) {
/**
* Retourne le nom d'affichage d'une autorité de type Acteur
- * @param autorite
- * @return
* @author jtra
*/
private String getNomAffichageAutoriteActeur(Autorite autorite) {
/**
* Retourne le nom d'affichage d'une autorité de type Groupe
- * @param autorite
- * @return
* @author jtra
*/
public String getNomAffichageAutoriteGroupe(Autorite autorite,
/**
* Retourne le nom d'affichage d'une autorité de type Groupe local
- * @param autorite
- * @return
* @author bahj
*/
private String getNomAffichageAutoriteGroupeLocal(Autorite autorite) {
/**
* Retourne le nom d'affichage d'une autorité de type Groupe distant
- * @param autorite
- * @return
* @author bahj
*/
private String getNomAffichageAutoriteGroupeDistant(Autorite autorite, Boolean withMEF) {
/**
* Retourne le nom d'affichage d'une autorité de type Eliot
- * @param autorite
- * @return
* @author jtra
*/
private String getNomAffichageAutoriteEliot(Autorite autorite) {
/**
* Retourne la personne associée à un acteur
- * @param acteur
* @param forceCreation si true, la personne est créée à la volée si
* nécessaire
* @return La personne associée à l'acteur, ou null si cette personne
/**
* Retourne la personne associée à une autorité de type "acteur"
- * @param autorite
* @param forceCreation si true, la personne est créée à la volée si
* nécessaire
* @return La personne associée à l'acteur, ou null si cette personne
/**
* Lecture de la liste des nom/prénoms des personne correspondant à la liste
* des id externes passés en paramètre
- * @param autoriteIdExternes
* @return une map associant l'idExterne avec le nom d'affichage
*/
public Map<String, String> findAllNomPersonneByAllAutoriteIdExterne(Set<String> autoriteIdExternes) {
/**
*
- * @param nom
- * @param prenom
* @return le nom d'affichage
*/
String getNomAffichage(String nom, String prenom) {
/**
* retourne les initiales du prenom
- * @param prenom
*
@return
*/
/**
* Retourne tous les personnels de direction d'un établissement
- * @param etablissement
* @return une liste de Personne
*/
List<Personne> findAllPersonnelDirectionByEtablissement(Etablissement etablissement) {
/**
* Retourne tous les personnels d'éducation d'un établissement
- * @param etablissement
* @return une liste de Personne
*/
List<Personne> findAllPersonnelEducationByEtablissement(Etablissement etablissement) {
/**
* Retourne tous les enseignants d'un établissement
- * @param etablissement
* @return une liste de Personne
*/
List<Personne> findAllEnseignantByEtablissement(Etablissement etablissement) {
/**
* Pareil que findAllEleveByStructureEnseignement mais en mode Fetch.JOIN
- * @param structureEnseignement
- * @param actif
- * @return
*/
List<Personne> findAllEleveByStructureEnseignementFetch(
StructureEnseignement structureEnseignement,
/**
* Pareil que findAllEleveByStructureEnseignementFetch
* mais en mode Fetch.JOIN pour l'autorite
- * @param structureEnseignement
- * @param actif
- * @return
*/
List<Personne> findAllEleveByStructureEnseignementFetchAutorite(
StructureEnseignement structureEnseignement,
/**
* List des élèves enseignés par un enseignant
- * @param securiteSession
- * @param enseignant
- * @param etablissement
* @param inclureClassePrincipal si true, les élèves de la classe,
* donc l'enseignant est le prof principal sont inclus
- * @return
* @author msan
*/
List<Personne> findAllEleveByEnseignantAndEtablissement(SecuriteSession securiteSession,
/**
* Récupère les données du calendrier
- * @param calendrier
* @result moisPositions
*/
List<RegistreLigneInfo> getCalendrierData(PreferencesEtablissementAbsences preferencesEtablissementAbsences,
* Crée un objet collectant toutes les données nécessaires aux calculs.
* @param eleves : liste des élèves
* @param pref : PreferenceEtablisement de l'étab
- * @param calendrier
* @return RegistreMensuelDataCollector
*/
private RegistreMensuelDataCollector getDataCollectorForEleveAndPeriode(
/**
* Récupère le détail des absences pour une journée et pour un élève
- * @param eleve
* @result mapDetailAbsencesJourEleve
*/
DetailJourInfo getDetailAbsencesJour(
/**
* Crée un critère de recherche pour les absences justifiées et non justifiées
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsAbsencesTotales(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée les critères de recherche de base
- * @param calendrier
- * @param eleve
* @return un StatsMensuellesParams
*/
private StatsMensuellesParams getBasicParams(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les absences justifiées
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsAbsencesJustifiees(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les absences non justifiées
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsAbsencesNonJustifiees(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les absences non recevables
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsAbsencesNonRecevables(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les absences à la demi-pension
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsDemiPension(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les départs anticipés
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsDepartsAnticipes(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les absences à l'internat
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsInternat(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour les retards
- * @param calendrier
- * @param eleve
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsRetards(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Crée un critère de recherche pour le taux d'absenteisme
- * @param ficheEleveAbsencesReferentiel
* @return un StatsMensuellesParams
*/
StatsMensuellesParams getParamsTauxAbsenteisme(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Récupère une liste avec la position du tableau FO en clef,
* et le mois et l'année correspondante en valeur
- * @param calendrier
* @result moisPositions
*/
List associerPositionEtMois(Calendrier calendrier) {
/**
* Récupère la position de la date et du mois du jour
* dans le calendrier scolaire de la Fiche élève onglet Absences
- * @param allFicheEleveCalendrierMoisPosition
* @result Map positions
*/
Map getDatePositions(
/**
* Compte le nombre de mois du calendrier de l'année scolaire
- * @param calendarDebut
- * @param calendarFin
* @result nbrMois
*/
int compteMoisCalendrier(Calendar calendarDebut, Calendar calendarFin) {
/**
* Calcule les stats pour les absences à l'internat
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesInternat(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les absences à la demi-pension
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesDemiPension(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les départs anticipés
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findDepartsAnticipesMensuelles(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les critères passés en params
- * @param securiteSession
- * @param params
- * @param preferencesEtablissementAbsences
- * @param eleve
* @return StatsMensuellesEleve
*/
private StatsMensuellesEleve findStatsMensuellesForParams(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel,
/**
* Calcule les stats pour les retards
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findRetardsMensuelles(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les absences non recevables
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesNonRecevables(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les absences justifiées et non justifiées
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesTotal(
/**
* Calcule les stats mensuelles pour les absences non justifiées
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesNonJustifiees(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Retourne les stats mensuelles d'un élève pour les absences justifiées
- * @param securiteSession
- * @param eleve
- * @param calendrier
- * @param preferencesEtablissementAbsences
* @return un StatsMensuellesEleve
*/
StatsMensuellesEleve findAbsencesMensuellesJustifiees(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel) {
/**
* Calcule les stats pour les critères passés en params
- * @param securiteSession
- * @param params
- * @param preferencesEtablissementAbsences
- * @param eleve
* @return StatsMensuellesEleve
*/
private Double findTauxAbsenteismeForParams(FicheEleveAbsencesReferentiel ficheEleveAbsencesReferentiel,
/**
* Enregistre un commentaire pour un élève.
- * @param eleve
- * @param commentaire
* @return FicheEleveCommentaire
* @author bper
*/
/**
* Consolide la validation des relations ReponsableEleve de l'annuaire local à partir de
* l'annuaire distant
- * @param securiteSessionResponsable
* @author jtra
*/
void consolideRelationResponsableEleve(SecuriteSession securiteSessionResponsable) {
}
/**
- * @param securiteSessionResponsable
* @return la liste des idExterne des élèves pour lesquels la relation avec ce responsable a
* été validée
* @author jtra
/**
* Invalide une relation ResponsableEleve
- * @param responsableEleve
* @author jtra
*/
private void invalideResponsableEleve(ResponsableEleve responsableEleve) {
/**
* Valide une relation ResponsableEleve
- * @param responsableEleve
* @author jtra
*/
private void valideResponsableEleve(ResponsableEleve responsableEleve) {
/**
* Modifie la validation d'une relation ResponsableEleve
- * @param responsableEleve
- * @param validation
*/
private void setValidationResponsableEleve(ResponsableEleve responsableEleve,
boolean validation) {
/**
* Recherche une structure d'enseignement par code, type, établissement, et année
- * @param code
- * @param etablissement
* @param forceCreation si true et que la structure n'existe pas, elle sera
* créée à la volée
* @param anneeScolaire (par défaut l'année en cours)
/**
* Retourne les structures d'enseignement d'un établissement
- * @param etablissement
* @param type structure (optionel)
* @return une liste de StructureEnseignement
*/
* Classe par défaut les donnée par un ordre alphabetique (code de la structure).
* ATTENTION! La classe où le prof est le prof principale, mais dans laquelle il n'enseigne pas, n'est pas incluse!
* @param enseignant : l'enseignant connecté
- * @param etablissement
* @param type structure (optionel)
* @return une liste de StructureEnseignement
*/
/**
* Retourne les structures d'enseignement de l'enseignant pour la matière et l'établissement en paramètre
* @param enseignant : l'enseignant connecté
- * @param etablissement
* @return une liste de StructureEnseignement
*/
List<StructureEnseignement> findStructureEnseignementByEnseignantAndMatiereAndEtablissement(Autorite enseignant,
/**
* Retourne toutes les structures d'enseignements d'un établissement
* pour une matière donnée
- * @return
*/
List<StructureEnseignement> findStructuresEnseignementByMatiereAndEtablissement(
Matiere matiere,
}
/**
- * @param eleve
* @return la première structure de type classe de l'élève
*/
StructureEnseignement findClasseForEleve(Personne eleve) {
/**
* Retourne une map associant une liste de personne élèves avec leur classe
- * @param eleves
* @return une map associant une liste de personne élèves avec leur classe
*/
Map<Personne, StructureEnseignement> findAllClassesForAllEleves(Set<Personne> eleves,
/**
* Retourne une map associant une liste d'autorité élèves avec leur classe
- * @param eleves
* @return une map associant une liste d'autorité élèves avec leur classe
* @author bahj , othe
*/
* classé par défaut en ordre alphabétique
* @param securiteSession la session de securite de l'utilisateur déclenchant
* l'action (pour transmettre le code porteur ENT)
- * @param structureEnseignement
* @return une liste de personne (parents)
*/
List<Personne> findAllParentsForStructure(SecuriteSession securiteSession,
/**
* Liste des structures liées à une classe.
- * @param classe
* @return liste des structures liées à une classe avec la classe dans la liste aussi.
* @author msan
*/
/**
* Retourne toutes les classe d'un enseignant dans lesquelles il enseigne directement
* ou à travers des groupes
- * @param securiteSession
- * @param enseignant
- * @param etablissement
* @return List < StructureEnseignement >
* @author bper
*/
/**
* Retourne les "Personne" élèves appartenant à la structure et ayant un des
* régimes de la liste
- * @param structureEnseignement
* @param regimes : liste de Regime
* @return une List<Personne>
*/
/**
* Ajoute la classe dans le groupe si la classe et le groupe ont au moins
* un élève en commun
- * @param classe
- * @param groupe
* @throws IllegalArgumentException
* @return true - si la classe a été ajoutée
* false - si la classe existait déjà
/**
* Vérifié que la classe et le groupe ont au moins un élève en commun (y compris
* les élève inactifs)
- * @param classe
- * @param groupe
* @return true - s'il y a au moins un élève en commun
* false - s'il y en a aucun
* @author bper
/**
* Retourne une liste de structures correspondant à une liste d'ids
- * @param ids
- * @return
*/
List<StructureEnseignement> findAllStructureForAllIds(List<Long> ids) {
if (ids) {
/**
* Retourne une map : [classeId:effectif]
- * @param ClasseIds
- * @return
*/
Map<Long,Integer> mapClasseEffectif(Collection<Long> classeIds) {
Map params = [
/**
* Retourne un porteurEnt à partir de son code
- * @param code
* @return un porteurEnt
* @throws IllegalStateException si le code ne correspond pas à un porteur Ent
* dans l'annuaire
/**
* Construction d'un branche de l'arbre.
- * @param fonctionnalite
- * @param typeAcces
* @return La feuille de la branche
*/
private FonctionnaliteNoeud creeBranche(Fonctionnalite fonctionnalite) {
/**
* La création des noeuds de l'arbre se fait par rapport aux fonctionnalités
- * @param fonctionnalite
- * @return
*/
static public FonctionnaliteNoeud creerNoeudFonctionnalite(Fonctionnalite fonctionnalite) {
/**
* Recherche arbre des fonctionnalités pour une personne sur un établissement
- * @param etablissement
- * @param personne
- * @return
*/
public FonctionnaliteArbre getAllAcces(Etablissement etablissement,
Personne personne) {
/**
* teste si la fonction peut accéder à des fonctionnalités ayant le même parent
* que la fonctionnalité passée en paramètre
- * @param fonctionnalite
- * @param fonction
- * @param etablissement
- * @return
*/
private Boolean existeDroitActifSurFonctionnaliteSoeur(Fonctionnalite fonctionnalite,
Fonction fonction,
/**
* test si le noeud fonctionnalite a des frères actifs.
- * @param fonctionnalite
- * @param personne
- * @param etablissement
- * @return
*/
private Boolean isFreresFonctionnalitePersonneActif(Fonctionnalite fonctionnalite,
Personne personne,
/**
* Recherche tous les utilisateurs concernés par le paramétrage
- * @return
*/
public List<Personne> findAllPersonne(Etablissement etablissement) {
/**
* Recherche toutes les fonctionnalités paramétrables
- * @return
*/
private List<Fonctionnalite> getAllFonctionnaliteParametrable() {
Fonctionnalite.findAllByParametrable(true)
/**
* Ajout d'un arbre pour les fonctionnalités
- * @param racine
- * @param listeFonctionnaliteAccessible
- * @param typeAcces
*/
private void completeArbrePourAccesPersonne(FonctionnaliteArbre racine,
List<Fonctionnalite> listeFonctionnaliteCochee
/**
* Retourne pour chaque item la valeur des permissions des autorités
- * @param items
- * @param autorites
* @return une map associant à chaque item, la valeur des permissions
*/
PermissionItems getPermissionsForAllItems(SecuriteSession securiteSession,
/**
* Répercute les permissions calculées sur les items parents, sur les items
* enfants
- * @param permissionItems
- * @param parentItem
- * @param permission
- * @param proprietaire
- * @param parentItems
*/
private void affectePermissionsSurItemsEnfants(PermissionItems permissionItems,
Item parentItem,
/**
* Retourne la liste des autorisations associées aux items et aux autorites
* passés en paramètres
- * @param items
- * @param autorites
- * @return
*/
private List<Autorisation> getAutorisationsForItemsAndAutorites(Map items, List<Autorite> autorites) {
/**
* Associe à chaque item, son item parent ou lui-même
- * @param items
* @return une Map
*/
private Map getParentItems(List<Item> items) {
/**
* Trie les droits d'acteurs.
* Le proprietaire le premiere, apres tries par l'ordre alphabetique.
- * @param droitsActeurs
*/
void trieDroitsUtilisateur(List<Droit> droitsActeurs) {
droitsActeurs.sort { a, b ->
/**
* Teste le droit à consulter
- * @param securiteSession
- * @param item
* @return un Boolean
*/
Boolean peutConsulterLeContenu(SecuriteSession securiteSession, Item item) {
/**
* Teste le droit à supprimer
- * @param securiteSession
- * @param item
* @return un Boolean
*/
Boolean peutSupprimer(SecuriteSession securiteSession, Item item) {
/**
* Teste le droit à modifier le contenu
- * @param securiteSession
- * @param item
* @return un Boolean
*/
Boolean peutModifierLeContenu(SecuriteSession securiteSession, Item item) {
/**
* Teste le droit à consulter les permissions
- * @param securiteSession
- * @param item
* @return un Boolean
*/
Boolean peutConsulterLesPermissions(SecuriteSession securiteSession, Item item) {
/**
* Teste les droits à modifier les permissions
- * @param securiteSession
- * @param item
- * @return
*/
Boolean peutModifierLesPermissions(SecuriteSession securiteSession, Item item) {
return verifiePermission(
* Retourne la liste des autorités par rapport à une liste d'id
* externes
* @param ids : idExternes
- * @param paramType
- * @return
*/
public List<Autorite> getListeAutorites(String ids, String paramType) {
// On reçoit une liste d'ids de groupes ou d'users
/**
* Enregistre les droits des groupes distants sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enregistreDroitsGroupeDistant(SecuriteSession securiteSession,
Item item,
/**
* Enleve les droits des groupes sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enleveDroitsGroupeDistant(SecuriteSession securiteSession,
Item item,
/**
* Enregistre les droits des groupes locaux sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enregistreDroitsGroupeLocal(SecuriteSession securiteSession,
Item item,
/**
* Enleve les droits des groupes locaux sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enleveDroitsGroupeLocal(SecuriteSession securiteSession,
Item item,
/**
* Enleve les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enleveDroitsActeurs(SecuriteSession securiteSession,
Item item,
/**
* Enregistre les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
*/
private void enregistreDroitsActeurs(SecuriteSession securiteSession,
Item item,
/**
* Enregistre les droits d'une autorite sur un item
- * @param securiteSession
- * @param item
- * @param autorite
- * @param peutConsulter
- * @param peutModifier
*/
private void enregistreDroits(SecuriteSession securiteSession,
Item item,
/**
* Enleve de droitsNouvels les droits qui n'ont pas changee par rapport
* aux droits existants
- * @param droitsNouvels
- * @param droitsExistants
* @return droits a enregistrer
*/
private List<Droit> filtreDroitsPasChanges(List<Droit> droitsNouvels,
/**
* Envoi une liste de sms
- * @param etablissement
* @param demandeur : demandeur de l'envoi
* @param templateDocument : modèle de sms à utiliser
* @param data : liste des sms à envoyer
/**
* Contrôle la taille finale du sms. Limite à 160 caractères
- * @param sms
- * @return
*/
private String controleTaille(String sms) {
if (sms.size() > 160) {
/**
* Retourne le texte de la fusion du modèle avec les données du sms
- * @param eleveImpressionInfo
- * @param modele
- * @return
*/
public String fusionne(EleveImpressionInfo eleveImpressionInfo, String modele) {
SmsBinding binding = new SmsBinding(
/**
* Indique si le modele est trop grand
- * @param modele
* @return nombre de caractères
*/
public boolean isModeleTropGrand(String modele) {
/**
* Retourne le modèle tronqué à la limite des 160 caractères
- * @param modele
- * @return
*/
public String modeleTronque(String modele) {
SmsModeleString modeleParse = analyseTailleModele(modele)
/**
* Analyse le modele pour vérifier s'il est de la bonne taille
* @param modele : modele
- * @return
*/
private SmsModeleString analyseTailleModele(String modele) {
TailleSMSBinding tailleSMSBinding = new TailleSMSBinding()
* permet aux descendants d'implémenter des comportement spécifiques liés
* à leur réponse. Sert en général à remettre le fichier sous forme d'une liste
* key=value
- * @param contenu
- * @return
*/
abstract protected String reformateContenu(String contenu)
*
*
* Traite les éventuelles particularitées liées aux fournisseurs de sms
- * @param contenuReponse
- * @return
*/
protected void prepareListeContenu(String contenuReponse) {
// la balise <br/> peut-être utilisée comme séparateur
/**
* Lit une valeur chaine dans la réponse
- * @param code
- * @return
*/
protected String lireValeur(String code) {
if (properties.getProperty(code)) {
/**
* Lecture d'une valeur booleenne dans la réponse
- * @param code
- * @param valeurVrai
- * @return
*/
protected boolean lireBooleen(String code, String valeurVrai = 'true') {
String statut = lireValeur(code)
/**
* Lecture d'une valeur date dans la réponse
- * @param code
- * @return
*/
protected Date lireDate(String code) {
String date = lireValeur(code)
/**
* Dans le cas de la lecture de la réponse de l'envoi on a une valeur OK ou KO
* contenant plusieurs valeurs
- * @param contenu
- * @return
*/
protected String reformateContenu(String contenu) {
contenu = contenu.replaceAll("OK:", 'OK=')
/**
* Extrait code retour de ligne de status d'envoi
- * @param ligneStatus
- * @return
*/
private CodeRetourEnvoi lireCodeRetourEnvoi() {
/**
* Extrait code return de ligne de status de suivi
- * @param ligneStatus
- * @return
*/
private CodeRetourCause lireCause() {
/**
* Extrait la date de mis a jour
- * @return
*/
private Date lireDernierMaj() {
return lireDate(DATE_LAST_TRACK)
/**
* Lecture du statut
- * @return
*/
private boolean isStatutOk() {
/**
* Extrait la reponse
- * @return
*/
private String lireReponse() {
return lireValeur(REPONSE)
/**
* Complément pour la préparation de la réponse
- * @param contenu
- * @return
*/
protected String reformateContenu(String contenu) {
// dans le cas de la réponse le mot-cle "Cause" est aussi séparateur de ligne *
* Pour chaque préférence établissement de l'établissement, on retourne celles qui
* ont une liaison SOO active (soit une liaison lvs soit une liaison magister
* pour le moment)
- * @param securiteSession
- * @param liaisonSSOActive
- * @return
*/
List<LvsPreferenceEtablissementInfo> findSSOPreferencesEtablissement(SecuriteSession securiteSession,
Boolean liaisonSSOActive
/**
* Crypte un string, fonction utilisée en vsn @author msan
- * @param url
- * @return
*
*/
String crypte(String url, String password) {
/**
* Get array de hex String 'AFF' -> [0x0A, 0xFF]
- * @param str
- * @return
*/
private byte[] hexStringToArray(String inputString) {
byte[] array = null
/**
* Transforme le profil des utilisateurs eliot, en profil lvs
- * @param securiteSession
- * @param etablissement
- * @return
*/
private String getProfilLvs(SecuriteSession securiteSession,
Etablissement etablissement
/**
* Formate la date de naissance
- * @param personne
- * @return
*/
private String getDateDeNaisance(Personne personne) {
/**
* Vérifie l'existence du dossier
- * @param rootDir
* @throws DataStoreException
*/
private void verifieDataStoreRootDirExistence(File rootDir)
/**
* Vérifie l'accéssibilité du dossier en écriture
- * @param rootDir
* @throws DataStoreException
*/
private void verifieDataStoreRootDirPermission(File rootDir)
/**
* supprime le fichier associé à un objet du domaine
- * @param objetDomaine
- * @param propName
*/
public void supprime(Object objetDomaine, String propName) {
objetDomaine."${propName}" = null
/**
* enregistre un fichier associé à un objet du domaine
- * @param objetDomaine
- * @param propName
- * @param image
*/
public String enregistre(Object objetDomaine, String propName, byte[] image) {
/**
* Charge le fichier associé à l'objet du domaine
- * @param objetDomaine
- * @param propName
- * @return
*/
public byte[] charger(Object objetDomaine, String propName) {
/**
* True si une synchronisation est en cours.
- * @return
*/
Boolean isSynchroEnCours() {
// Une synchro est en cours, s'il existe un enregistrement dans Execution
* Crée les préférences d'un utilisateur pour un agenda
* @param agenda : l'agenda auqel les proporiétés seront crées
* @param nomPersonnalise : nom personalisé de l'agenda
- * @param couleur
* @param notification : notification sur l'agenda
* @param securiteSession : la session en court
* @return preferences : l'objet crée
/**
* Modifie les préférences d'un agenda pour un utilisateur
- * @param agenda
* @param parametres : objet map qui contient:
* - nomPersonnalise
* - couleur
/**
* retourne les préférences de l'utilisateur si elle existe
* sinon crée les préférences avec des valeur par défaut
- * @param agenda
* @param securiteSession : la session en cours
* @param forceCreationPreferences : flag indiquant si il faut forcer la création
* @return preference : la preférence créee
/**
* retourne une map associant les agendas en paramètres à la préférence de l'utilisateur
* si les préférences n'existe pas, ils sont crées avec des valeur par défaut
- * @param agendas
* @param securiteSession : la session en cours
* @param forceCreationPreferences : flag indiquant si il faut forcer la création
* @return preference : la preférence créee
/**
* Retourne une couleur aléatoire à partir d'une palette définit.
- * @return
*/
String getCouleur() {
Random rand = new Random()
/**
* Retourne l'agenda scolaire de l'établissement
* Attribut les droits en consultation et en modification
- * @param etablissement
* @param forceCreation : flag indiquant si il faur forcer la création si l'agenda n'existe pas
* @return agenda agenda crée
* @throws EliotTempsException en cas
/**
* Récupére la liste des agendasInfo par permission et type de la session
- * @param typeAgenda
* @param securiteSession session courante
* @param proprietaire : si l'utilisateur doit être le propriétaire de l'agenda ou pas
* @param forceCreationPreferences : flag indiquant si il faut forcer la création
/**
* Construit un agendaInfo
- * @param agenda
* @param preferences : les preferences de l'utilisateur sur l'agenda
* @param session : la session courante
* @return agendaInfo : l'agenda information construit
/**
* Indique s'il existe un edt pour l'établissement
- * @param etablissement
*/
Boolean isEmploiDuTempsExisteForEtablissement(Etablissement etablissement) {
String hql = """select id from Agenda
/**
* Récupère la liste des agendas scolaires par défaut sélectionnés pour un élève
* - Agendas de type structure auquels l'élève est attaché
- * @param eleve
* @return defaultAgendasEleve : la liste des agendas structures
*
*/
/**
* Récupère la liste des agendas scolaires par défaut sélectionnés pour un parent
* - Agendas de types structure d'enseignement auxquels les fils sont attachés
- * @param parent
* @return defaultAgendasParent
*
*/
* @param description : description de l'agenda
* @param typeAgenda : type de l'agenda
* @param item : item de l'agenda
- * @param structureEnseignement
* @return agenda: agenda crée
* @throws EliotTempsException en cas
* d'erreur lors de la création
/**
* Vérifie si l'agenda scolaire n'existe pas
- * @param nom
- * @param description
- * @param typeAgenda
- * @param item
- * @param structureEnseignement
- * @param etablissement
- * @param enseignant
- * @return
*/
protected Agenda returnAgendaSiIlExiste(String nom,
String description,
/**
* Supprime les événements de l'enseignement qui ont une date de début
* supérieure à celle en paramètre et qui ne sont pas liée à des activités
- * @param enseignement
- * @param dateHeureDebut
*
*/
void supprimeEvenementEnseignement(Enseignement enseignement,
* Retourne les événements d'un agenda
* Ne vérifie pas les droits de récuperer les événements
* événements crées à partir de l'agenda + événements attachés à l'agenda
- * @param agenda
* @return evenements liste des événements
*/
Collection<Evenement> getEvenementsFromAgenda(Agenda agenda) {
* Si le mot clé une chaîne vide,
* tous les événements de l'agenda vont être listés
* Vérifie les droits de consultation
- * @param agenda
* @param motCle : différents de null et de chaîne vide
- * @param securiteSession
* @return evenements liste des événements trouvés
*/
Collection<Evenement> chercherEvenementsFromAgenda(Agenda agenda,
* Récupère les droits de l'acteur sur le cahier de textes
* - si l'événement est lié à un enseignement
* - si l'enseignament est attaché à un cahier de texte
- * @param evenement
- * @param securiteSession
* @return droitsCdt les droits de l'utilisateur sur le cahier de texte
*/
private int getDroitsCdt(Evenement evenement,
/**
* Retourne les évènements d'un agenda
- * @param agenda
- * @param enseignement
- * @param jour
- * @return
*/
List<Evenement> findEvenementsForListEnseignementAndJour(List<Enseignement> enseignements,
Date jour) {
/**
* Retrouve le prochaine événement de cours que l'enseignant donne à une structure
- * @param enseignement
- * @param jour
* @return un Evenement
*/
Evenement findProchainEvenementForEnseignement(Enseignement enseignement, Date jour) {
/**
* verifie les droits de modifications des permissions d'un agenda
- * @param agenda
- * @param securiteSession
* @throws AutorisationException
*/
void verifieAutorisationModificationPermissions(Agenda agenda,
* ce qui revient à verifier les droits en consultation
* Chaque utilisateur qui a le droit de consulter un agenda,
* il a le droit de le ersonnaliser
- * @param agenda
- * @param securiteSession
* @throws AutorisationException
*/
void verifieAutorisationModificationPreferences(Agenda agenda,
/**
* Compare l'heure de l'objet avec l'heure d'un autre objet Date
* ou d'un descendant de Date
- * @param anotherTime
- * @return
*/
public int compareTo(Date anotherTime) {
Calendar heureLocale = Calendar.getInstance()
/**
* type d'import
- * @return
*/
abstract ImportType getImportType()
}
/**
- * @param etablissement
* @return retourne la date (sous forme de Long) à laquelle les fichiers STS
* ont été déposés pour cet établissement, ou null s'il n'y a pas de fichiers
* STS en attente pour
* établissement et une date de traitement
* @param etablissement un établissement
* @param dateTraitement une date de traitement
- * @return
*/
public File getFileRapport(Etablissement etablissement, Date dateTraitement) {
File fileDossierImportTraite = getFileDossierImportTraites(
/**
* Déverouille les données d'un établissement
- * @param etablissement
*/
void deverrouilleEtablissement(Etablissement etablissement) {
File fileVerrou = getFileVerrouForEtablissement(etablissement)
/**
* Teste si un établissement est verrouillé
- * @param etablissement
* @return true si l'établissement est verrouillé, false sinon
*/
boolean isVerrouille(Etablissement etablissement) {
/**
* Retourne tous les rapports d'import pour un établissement
- * @param etablissement
- * @return
*/
public List<ImportRapportInfo> getListeRapportFichierInfo(Etablissement etablissement) {
List<ImportRapportInfo> listeRapportFichierInfo = (List) []
/**
*
- * @param etablissement
* @return true si l'import se passe sans problemes
*/
abstract Boolean executeImport(Etablissement etablissement)
* Recherche l'enseignant par l'idSts et Académie
* @param idSts : l'id dans les fichier STS (doit etre unique dans une Académie)
* @param academie : l'Académie de l'établissement de rattachement
- * @param actif
* @return personne ayant la fonction Enseignant
* @author bper
*/
* fichier verrou, si ils existent
* Cette méthode n'est utilisé que pour faire le ménage en cas d'exception
* non prévue
- * @param etablissement
*/
void cleanUp(Etablissement etablissement) {
safeDelete(getFileEmpSts(etablissement, ImportEtat.EN_ATTENTE))
}
/**
- * @param etablissement
* @return retourne la date (sous forme de Long) à laquelle les fichiers STS
* ont été déposés pour cet établissement, ou null s'il n'y a pas de fichiers
* STS en attente pour
* @param noeudIndividus le noeud de la section 'INDIVIDUS' de fichier empSts
* @param etablissement l'établissement sur lequel l'import sera effectué
* @param StsImportRapport le rapport de l'import en court
- * @param infoProfPrincipaux
* @author bahj
*/
void importeProfsPrincipaux(GPathResult noeudIndividus,
/**
* Ajoute l'info sur les PPs dans infoProfPrincipaux
- * @param noeudIndividus
- * @param infoSuppProfPrinc
*/
void ajouteInfoPP(GPathResult noeudIndividus, InfoProfPrincipaux infoSuppProfPrinc) {
// ajout l'info PP pour chaque individu
* Traite les erreurs
* @param enseignant l'enseignant principal
* @param structure la structure d'enseignement
- * @return
* @author bahj
*/
private setProfesseurPrincipal(Personne enseignant,
/**
* Permet de supprimer les événements doublons de l'enseignement
- * @param enseignement
* @param dateImport date de l'import sts
* @param rapport rapport de l'import sts
*/
/**
* Vérfie si les service importés existent pour l'établissement et l'année.
- * @param etablissement
- * @param anneeScolaire
* @return true - si au moins un service importé existe,
* false - si aucun service importé n'existe.
*/
/**
* Traite une erreur qui survient durant la création d'un événement cours
* @param e l'exception qui a été levée
- * @param rapport
*/
private void traiteErreurCreerEvenementCours(Exception e,
String libelleMatiere,
/**
* Traite une erreur liée à l'absence du lien professeur - établissement
- * @param enseignant
- * @param structure
- * @param rapport
* @author bahj
*/
private void traiteErreurPersonneNonEnseignantPourEtablissement(Personne enseignant,
/**
* Ajoute une erreur pour le fichier EmpSts : l"altérnance est hors de l'année scolaire
- * @param dateDebutSemaine
- * @param dateDebutAnnneeScoalire
- * @param dateDeFinAnneeScolaire
- * @param rapport
*/
private void traiteErreurAlternanceHorsAnneeScolaire(String dateDebutSemaine,
Date dateDebutAnnneeScoalire,
/**
* Parse les dates de début de la semaine
- * @param dateDebutSemaine
- * @return
*/
static Calendar parseDateDebutSemaine(String dateDebutSemaine) {
Calendar cal = Calendar.getInstance()
* fichier verrou, si ils existent
* Cette méthode n'est utilisé que pour faire le ménage en cas d'exception
* non prévue
- * @param etablissement
*/
void cleanUp(Etablissement etablissement) {
try {
/**
* Retourne la config du nommage de groupes
- * @return
*/
String getNommageGroupes() {
return ConfigurationHolder.config.eliot.scolarite.import.udtConnecteur.nommagegroupes
/**
* Retourne le chemin du fichier de config Log4J
- * @return
*/
String getCheminConfigL4J() {
return ConfigurationHolder.config.eliot.scolarite.import.udt.configLog4J
/**
* Ajoute une erreur à la liste
- * @param erreur
*/
void ajouteErreur(UdtImportErreur erreur) {
erreurs << erreur
/**
* Génére le html du rapport
- * @param builder
*/
@SuppressWarnings('AbcComplexity')
private buildHtml(MarkupBuilder builder) {
/**
* Aussi utilise pour l'affichage de rapports
- * @param etablissement
- * @param anneeScolaire
- * @param debutTraitement
- * @return
*/
public File getFichierForRapport(Etablissement etablissement,
AnneeScolaire anneeScolaire,
/**
* Retourne le dossier de destination du rapport
- * @param rapport
*/
File getDossierForRapport(UdtImportRapport rapport) {
return getDossierForRapport(rapport.etablissement, rapport.anneeScolaire)
/**
* Retourne le dossier de destination du rapport
- * @param etablissement
- * @param anneeScolaire
*/
private File getDossierForRapport(Etablissement etablissement,
AnneeScolaire anneeScolaire) {
/**
* Retourne tous les rapports d'import pour un établissement
- * @param etablissement
- * @return
*/
List<ImportRapportInfo> getListeRapportFichierInfo(Etablissement etablissement) {
List<ImportRapportInfo> listeRapportFichierInfo = (List) []
/**
* Constructeur
- * @param message
*/
UdtImportErreurSimple(String message) {
this.message = message
/**
* Crée un dossier temporaire et unique qui sera supprimé à la ferméture de la jvm
* @param directoryName le nom de dossier
- * @return
*/
File creeTemporaryDir(String directoryName) {
File tempDir = File.createTempFile(directoryName, '', null)
}
/**
- * @param structure
* @return la structure d'enseignement (classe ou groupe) correspondant à la pop
*/
StructureEnseignement getStructureEnseignement(
/**
* Retourne un service
- * @param popEnseignant
- * @param popStructure
- * @param popMatiere
- * @return
*/
public Service getService(PopulationTestActeur popEnseignant,
PopulationTestActeur popDirecteur,
* Construit une url pour une securiteSession (utilisée pour déterminer le
* porteur de l'utilisateur courant), 1 application Eliot, 1 contrôleur et
* 1 action
- * @param porteurEnt
- * @param application
- * @param controller
- * @param action
* @return une url
* @throws IllegalStateException Si les données fournies n'ont pas permis de
* construire une url valide (données invalides en base pour le porteur,
/**
* Construit une url pour la sécurite session, pour un serveur non grails
- * @param securiteSession
- * @param application
- * @param action
- * @return
*/
String getUrl(SecuriteSession securiteSession,
EliotApplicationEnum application,
/**
- * @param application
* @return retourne le nom d'application pour application utilisé dans l'url
*/
private String getNomApplication(EliotApplicationEnum application) {
* Retourne l'url serveur d'une application
* Note : la securiteSession est nécessaire pour déterminer le porteur Ent si
* la résolution d'url est configurée par porteur en utilisant l'annuaire
- * @param securiteSession
- * @param application
- * @return
*/
String getUrlServeur(SecuriteSession securiteSession,
EliotApplicationEnum application) {
* configuration
* (soit par la variable eliot.commons.urlServeur, soit pour la variable
* eliot.<application>.urlServeur)
- * @param application
- * @return
*/
private String getUrlServeurFromConfiguration(EliotApplicationEnum application) {
/**
* Retourne l'url serveur du porteur associé à la securiteSession
- * @param securiteSession
* @return une url
*/
public String getUrlServeurFromPorteurEnt(SecuriteSession securiteSession) {
/**
* Retourne l'url serveur du porteur associé à la securiteSession
- * @param securiteSession
* @return une url
*/
public String getUrlServeurFromPorteurEntAnnuaireDistant(
/**
* Determine si la variable de config (key) ou son prefixe
* est autorisée dans les logs
- * @param key
* @return isLoggable
*/
Boolean isConfigVariableLogAutorise(key) {
/**
* Formate les donnée affichées dans le tableau
- * @param value
- * @return
*/
static String format(def value) {
if (value == null) {return ''}
/**
* Indique si les webservices sont disponibles
- * @return
*/
Boolean estDisponible() {
return connexionWebservicesOK
/**
* Appel du webservice avec un parametre
- * @param xml
- * @return
*/
public OutputStream appelWebService(String url,
String param = null,
}
/**
- * @param jsNamespace
- * @param varName
* @return le nom qualifiée d'une variable
* @author jtra
*/
\r
/**\r
* Verifie que l'adresse email est correcte\r
- * @param adresse\r
* @return true si l'adresse est correcte\r
*/\r
\r
/**
* Teste qu'un argument est non null
- * @param nomArgument
- * @param valeur
* @throws IllegalArgumentException si l'argument est null
* @author jtra
*/
* Cette méthode doit être utilisée périodiquement pour les services de type
* batch non transactionnel
* @param session la session GORM à nettoyer
- * @return
*/
public static cleanUpGorm(def session) {
session.flush()
* qui sera instanciée
* sinon ce sera une exception de classe Exception
*
- * @param specificException
* @param msg : message associée à l'exception
* @param e : exception cause
* @return instance de l'exception à remonter
/**
* Contructeur
- * @param racineDossierBascule
- * @param moduleBascule
- * @param anneeScolaireService
* @return BasculeAnneeInfo
* @author bper
*/
/**
* Libère un fichier verrou associé à un traitement de bascule d'année
- * @param securiteSession
- * @param basculeAnneeInfo
*/
synchronized static void libereFichierVerrou(SecuriteSession securiteSession,
BasculeAnneeInfo basculeAnneeInfo) {
/**
* Retourne le dossier les informations d'une opération de bascule d'année
- * @param info
* @return Dossier <racine_bascule>/<annee_source>_vers_<annee_cible>
*/
public static File getDossierAnneeOperationBascule(BasculeAnneeInfo info) {
/**
* Decoupe une liste en plusieurs
- * @param listOrig
- * @param batchSize
- * @return
*/
static List<List> splitParBatch(Collection listOrig, Integer batchSize) {
List<List> listeBatches = []
/**
* Permet de convertir du hql en sql
- * @param hqlQueryText
- * @return
*/
static public String toSql(String hqlQueryText) {
/**
* Ajoute la date et l'heure minimum (1èr jour du mois)
- * @param date
* @author bahj
*/
static void setMinimumDayOfMonth(Calendar date) {
/**
* Retourne un objet Calendar qui correspond au premier jour avec
* les premiers heure... de la date en paramètre
- * @param date
* @author bahj
*/
static Calendar getMinimumDayOfMonth(Calendar date) {
/**
* Ajoute la date et l'heure maximum (dernier jour du mois)
- * @param date
* @author bahj
*/
static void setMaximumDayOfMonth(Calendar date) {
/**
* Retourne un objet Calendar qui correspond au dernier jour avec
* les dernieres heure... de la date en paramètre
- * @param date
* @author bahj
*/
static Calendar getMaximumDayOfMonth(Calendar date) {
/**
* Ajoute l'heure, minute, seconde et miliseconde de l'heure de début du jour
- * @param date
* @author bahj
*/
static Date setDebutJour(Date date) {
/**
* Ajoute l'heure, minute, seconde et miliseconde de l'heure de début du jour
- * @param date
* @author bahj
*/
static void setDebutJour(Calendar date) {
/**
* Retourne retourne un objet calendar qui correspond au début du jour
* de la date en paramètre
- * @param date
* @author bahj
*/
static Calendar getDebutJour(Calendar date) {
/**
* Ajoute dans la date la chaine d'heure minute
- * @param date
* @param heureMinute : heure et minute sous la forme: hh:mm
* @return date : retourne une date auquelle l'heure et la minute ont étés ajoutés
*
/**
* Convertion du numéro de jour de la semaine française en semaine anglaise
- * @param jour
- * @return
*/
static Byte convertJourFranceVersJourAnglais(Byte jour) {
byte result = jour + 1
/**
* Convertion du numéro de jour de la semaine anglaise en semaine française
- * @param jour
- * @return
*/
static Byte convertJourAnglaisVersJourFrance(Byte jour) {
byte result = jour - 1
/**
* Retourne une date à une heure et une minute données
- * @param heure
- * @param minute
* @return une Date au 01/01/2000 à l'heure donnée
*/
static Date getTime(Integer heure, Integer minute) {
/**
* Retourne une date à une heure et une minute données
- * @param dateTime
* @return une Date au 01/01/2000 à l'heure donnée
*/
static Date getTime(Date dateTime) {
/**
* ajoute un nombre de jours à une date
- * @param date
- * @param nombreJours
* @return une Date
*/
static Date ajouteJours(Date date, Integer nombreJours) {
/**
* Compose une date et heure à partir d'une date et d'une heure
- * @param date
- * @param heure
* @return une Date
* @author jbui
*/
/**
* Vérifie que les deux dates se trouvent dans la même journée
- * @param date1
- * @param date2
* @return un Boolean
*/
static Boolean isJoursIdentiques(Date date1, Date date2) {
/**
* Formate une date vers le format JS
- * @param date
* @return une chaine
*/
static String formateDateToJS(Date date) {
/** Retourne une date initialisée dont
* l'heure égale à celle en paramètre
- * @param date
- * @return
* @author bahj
*/
static Date getHeure(Date date) {
/**
* retourne la date formatée exp : 'hh:mm '
* @author bahj
- * @param date
* @return une String
*/
static String formateDate(Date date) {
/**
* retourne la date formatée exp : 'jj/mm/yyyy hh:mm '
* @author bahj
- * @param date
* @return une String
*/
static String formateDateJourHeure(Date date) {
/**
* Retourne les données perso d'un utilisateur identifié par son idExterne (annuaire distant / aaf)
- * @param personneIdExterne
- * @return
* @author jtra
*/
DonneesPerso findDonneesPersoByIdExterne(String personneIdExterne) {
/**
* Retourne les données perso d'un utilisateur identifié par son login
- * @param login
- * @return
* @author jtra
*/
DonneesPerso findDonneesPersoByLogin(String login) {
/**
* Converti un objet PersonneDonneesPersoDto (référentiel annuaire distant) en
* DonneesPerso
- * @param personneDonneesPersoDto
- * @return
* @author jtra
*/
private DonneesPerso convertiPersonneDonneesPerso(PersonneDonneesPersoDto personneDonneesPersoDto) {
/**
* Retourne le nom d'affichage d'un utilisateur identifié par son id dans le
* référentiel de l'annuaire distant (id AAF)
- * @param personneIdExterne
- * @return
*/
String getPersonneNomAffichage(String personneIdExterne) {
PersonneDto persDto = getPersonnePortailBusiness().getPersonneDto(
* @param personneIdExterne idExterne de la personne (id AAF)
* @param codePorteurENT codePorteurENT à associer à l'acteur
* @param typeUtilisateur type de l'utilisateur (admin, correspondant déploiement, normal)
- * @return
* @author jtra
*/
Acteur getActeurInformations(String personneIdExterne,
/**
* Retourne les organisations accessibles pour un utilisateur de type 'normal'
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
*/
List<OrganisationInfo> findAllOrganisationAccessible(String personneIdExterne,
/**
* Retourne les organisations accessibles pour un utilisateur (en prenant en
* compte le typeUtilisateur fournit)
- * @param personneIdExterne
- * @param codePorteurENT
- * @param typeUtilisateur
- * @return
* @author jtra
*/
List<OrganisationInfo> findAllOrganisationAccessible(String personneIdExterne,
/**
* Retourne les fonctions / établissement d'un utilisateur
- * @param personneIdExterne
- * @param codePorteurENT
* @param typeUtilisateur le type de l'utilisateur (admin, correspondant de
* déploiement, ou normal)
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForPersonne(String personneIdExterne,
/**
* Retourne les fonctions / établissement d'un utilisateur normal
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForUtilisateurNormal(String personneIdExterne,
/**
* Retourne les fonctions / établissement d'un admin local
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForAdminLocal(String personneIdExterne,
/**
* Retourne les fonctions / établissement d'un correspondant de déploiement
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForCorrespondantDeploiement(String personneIdExterne,
/**
* Retourne les fonctions / établissement d'un admin central
- * @param personneIdExterne
- * @param codePorteurENT
- * @return
* @author jtra
*/
List<FonctionEtablissement> findAllFonctionEtablissementForAdminCentral(String personneIdExterne,
/**
* Converti une liste de profils (référentiel annuaire socle) en une liste de fonctions / établissement
- * @param profil
- * @return
* @author jtra
*/
private List<FonctionEtablissement> findAllFonctionEtablissementForProfilDto(RelPersonneProfilDto profil) {
/**
* Converti une FonctionDto (référentiel annuaire socle) en une liste de
* fonctions / établissement
- * @param profil
- * @return
* @author jtra
*/
private List<FonctionEtablissement> findAllFonctionEtablissementForFonctionDto(FonctionDto fonctionDto,
* Spécifique à la simulation de CAS en mode dév
* Retourne la liste des ids de groupes qui sont normalement ajoutés à la
* session par CAS pour un utilisateur sur un porteurENT
- * @param codePorteurENT
- * @param utilisateurIdExterne
- * @param utilisateurType
- * @return
*/
List<Long> getGroupesIdsSimulationCas(String codePorteurENT,
String utilisateurIdExterne,
* typeUtilisateur n'est pas 'correspondant de déploiement'
* Les correspondants de déploiement ne peuvent accéder qu'à leur établissement de
* rattachement
- * @param personneIdExterne
- * @param codePorteurENT
- * @param typeUtilisateur
- * @return
* @throws IllegalStateException si le typeUtilisateur correspond à
* 'correspondant de déploiement'
*/
/**
* Verifie que la permission a supprimmer, n'est pas la permission par defaut.
* Cette verififcation n'est pas effectue pour ELITO_SYSTEME.
- * @param autorisation
- * @param permission
* @throws IllegalStateException si la permission est la permission par defaut
*/
private void verifieAutorisationPasParDefaut(Autorisation autorisation,
/**
* Verifie si l'operation est faite par l'utilisateur systeme (ELIOT)
- * @return
*/
private Boolean sessionEstSessionSysteme() {
return this.session.defaultAutorite?.type == Autorite.TYPE_ELIOT
/**
* Supprimme l'autorisation si elle est vide
- * @return
*/
private boolean autorisationEstSupprimee() {
if (autorisation.valeurPermissions == 0 &&
/**
* Teste si cette session possède une des focntions désignées par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
- * @return
*/
boolean hasFonctionIn(List<FonctionEnum> fonctionEnum) {
return annuaireSession.hasFonctionIn(fonctionEnum)
/**
* Teste si cette session possède une des fonction désignées par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
* @param id de l'établissement
- * @return
*/
boolean hasFonctionIn(List<FonctionEnum> fonctionEnums, Long idEtablissement) {
return annuaireSession.hasFonctionIn(fonctionEnums, idEtablissement)
/**
* Retrouve l'etat du compte de la personne connectée
- * @param lilieHttpInfo
- * @return
*/
private CompteUtilisateurEtat getCompteUtilisateurEtat(LilieHttpInfo lilieHttpInfo) {
Autorite autorite = Autorite.findByIdExterneAndType(
/**
* Création d'une session à partir d'une autorité système
- * @param autorite
* @return la session
* @throws IllegalArgumentException
*/
/**
* Passe l'autorite en mode actif
- * @param securiteSession
*/
private void reactiveDefaultAutorite(Autorite defaultAutorite) {
defaultAutorite.estActive = true
/**
* Passe l'autorite en accés restreint
- * @param securiteSession
- * @param dateSuppression
*/
private void passeEnAccesRestreint(Autorite defaultAutorite,
Date dateSuppression) {
/**
* Teste si cette session possède la fonction désignée par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
- * @return
*/
boolean hasFonction(FonctionEnum fonctionEnum) {
* Teste si cette session possède une des fonction données sur un établissement donné
* @param fonction une fonction
* @param idEtablissement l'id de l'établissement
- * @return
*/
boolean hasFonctionIn(List<FonctionEnum> fonctionEnums, Long idEtablissement)
throws IllegalStateException {
/**
* Liste des groupes étendus auxquels l'utilisateur a accès
- * @return
*/
public List<RessourceIndexeeInfo> getGroupesEtendusInfo() {
listeGroupesEtendus
/**
* Construit la session ACL à partir des informations extraites de la requête & la session HTTP
- * @param lilieHttpInfo
- * @return
* @author jtra
*/
def LocalACLSession(LilieHttpInfo lilieHttpInfo) {
/**
* Construit la session annuaire à partir des informations extraites de la requête & la session HTTP
- * @param lilieHttpInfo
- * @return
* @author jtra
*/
def LocalAnnuaireSession(LilieHttpInfo lilieHttpInfo) {
/**
* Teste si cette session possède une des fonctions désignées par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
- * @return
* @author othe
*/
boolean hasFonctionIn(List<FonctionEnum> fonctionEnums) {
/**
* Teste si cette session possède une des fonctions désignées par fonctionEnum (quelque soit
* l'établissement)
- * @param fonctionEnum
* @param id de l'établissement
- * @return
* @author othe
*/
boolean hasFonctionIn(List<FonctionEnum> fonctionEnums, Long aLong) {
/**
* Liste des groupes étendus auxquels l'utilisateur a accès
- * @return
*/
public List<RessourceIndexeeInfo> getGroupesEtendusInfo() {
[]
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
* @return evaluation
* @author mjao
*/
/**
* Creation des périodes
- * @param typePeriode
- * @param structureEnseignement
- * @param dateDebut
- * @param dateFin
- * @return
*/
Periode getOuCreePeriode(TypePeriode typePeriode,
StructureEnseignement structureEnseignement,
/**
* Crée un enseignement
- * @param enseignant
- * @param service
- * @return
*/
Enseignement creeEnseignement(Autorite enseignant, Service service) {
Enseignement enseignement = new Enseignement(
/**
* Permet de récupérer la classe de l'objet de donnée associé au templateDocument
- * @param templatedocument
- * @return
*/
private static def getClassDonnees(TemplateDocument templatedocument) {
/**
* Cherche les agendas visibles pour la personne logguee.
- * @param securiteSession
* @param typeAgenda type d'agenda a chercher
* @return Liste d'AgendaAgendaInfo vidibles pour la personne logguee
*/
/**
* Vérifie que le fichier est conforme aux spécifications
- * @param fichier
- * @param fichierSpecification
*/
void verifieFichier(Fichier fichier,
TestFichierSpecification fichierSpecification) {
/**
* Ajoute un arbre mathML dans le document en dessous du noeud root
*
- * @param document
- * @param root
* @param asciiMath : équation exprimé en asciimath
*/
public void ajouteMathML2Dom(Document document, Element root, String asciiMath) {
/**
* Parse une expression ASCII math.
* L'arbre MathML est joint sous mathElement
- * @param doc
- * @param mathElement
- * @param asciiMath
*/
void amParseMath(Document doc, Element mathElement, String asciiMath) {
/**
* Récupère le nombre d'enfants
- * @param node
- * @return
*/
private Integer docSize(Node node) {
if (node.childNodes == null) {
/**
* Parse une expression
- * @param document
- * @param asciiMath
- * @param ctx
- * @param rightbracket
- * @return
*/
ParsingResult amParseExpr(Document document, String asciiMath, ParsingContext ctx,
Boolean rightbracket = false) {
/**
* Parse une expression
- * @param document
- * @param asciiMath
- * @param ctx
- * @return
*/
ParsingResult amParseIexpr(Document document, String asciiMath, ParsingContext ctx) {
/**
* Parse une équation. Retourne une balise MathML avec sa valeur
- * @param str
- * @return
*/
private List parseEquation(String str) {
/**
* Retourne le premier caractère de l'équation
- * @param str
- * @return
*/
private String premierCaractere(String str) {
/**
* Extrait le caractère qui se trouve à la position k
- * @param str
- * @param k
- * @return
*/
private String extractCharAtPos(String str, int k) {
/**
* Return position >=n where str appears or would be inserted.
* Assumes arr is sorted
- * @param arr
- * @param str
- * @param n
- * @return
*/
Integer amPosition(List<String> arr, String str, Integer n) {
/**
* Enleve les brackets d'element
- * @param node
*/
void amRemoveBrackets(Node node) {
//MathML version
/**
* Remove n characters and any following blanks
- * @param str
- * @param n
- * @return
*/
private String amRemoveCharsAndBlanks(String str, Integer n) {
/**
* Imprime un document dans un string compacte
- * @param document
- * @return
*/
String dom2string(Document document) {
TransformerFactory transformerFactory = TransformerFactory.newInstance()
/**
* Une utilisation pour montrer la conversion
- * @param args
*/
static void main(String[] args) {
ASCIIMath2MathML conv = new ASCIIMath2MathML()
/**
* Constructeur
- * @param chaineAsciiMath
- * @param exceptionOrigine
*/
AsciiMathException(String chaineAsciiMath, Exception exceptionOrigine) {
super(exceptionOrigine)
/**
* Cree un element MathML et place le fragment sous cette nouvel element
- * @param document
- * @param nodeName
- * @param fragment
* @return element MathML avec fragement comme l'enfent
*/
static public Element creerNoeudMathML(Document document, String nodeName, Node fragment) {
/**
* Créé un élément MathML et place le fragment sous cette nouvel element
- * @param document
- * @param nodeML
- * @param fragment
- * @return
*/
static public Element creerNoeudMathML(Document document, MathML nodeML, Node fragment) {
Element node = document.createElementNS(
/**
* Créé un élément mo et place le fragment sous cette nouvel element
- * @param document
- * @param fragment
- * @return
*/
static public Element creerNoeudMO(Document document, Node fragment) {
MathMLTools.creerNoeudMathML(
/**
* Création d'un élément de regroupement
- * @param document
- * @param fragment
- * @return
*/
static public Element creerRegroupementHorizontal(Document document, Node fragment) {
MathMLTools.creerNoeudMathML(
/**
* Cree un element MathML
- * @param document
- * @param nodeName
* @return element MathML
*/
static public Element amCreateElementMathML(Document document, String nodeName) {
/**
* Ajouter un espace dans un document mathML
- * @param document
- * @return
*/
static public Element ajouterEspace(Document document) {
Element resultat = amCreateElementMathML(
/**
* Création d'un changement de style
- * @param doc
- * @param mathElement
- * @return
*/
static public Element creerChangementDeStyle(Document doc, Element mathElement) {
/**
* Fait apparaitre un carré blanc
- * @return
*/
static public Element carreBlanc(Document document) {
creerNoeudMO(
/**
* Retourne un message d'erreur en mathML
- * @param message
- * @return
*/
static public String messageErreur(String message) {
return "<math xmlns='http://www.w3.org/1998/Math/MathML'>" +
/**
* La methode qui lance l'import
- * @param args
*/
public static void main(String[] args) {
Logger logger = Logger.getLogger(Application.class.name)
/**
* Affiche un message dans le rapport
* @param message le message a faire apparaitre dans le rapport
- * @return
*/
def doWithMessage(String message) {
logger.info(message)
/**
* Marque qu'on a cree un enregistrement de la structure d'nseignement
- * @param structureEnseignement
*/
void marqueStructureCree(StructureEnseignement structureEnseignement) {
structuresInserees.put(getHashStructure(structureEnseignement), Boolean.TRUE)
/**
* Verifie si un enregistrement pour la structure d'enseignement a ete deja cree
- * @param structureEnseignement
- * @return
*/
Boolean isStructureCree(StructureEnseignement structureEnseignement) {
return (structuresInserees.get(getHashStructure(structureEnseignement)) ==
/**
* Hash de structure
- * @param structureEnseignement
- * @return
*/
String getHashStructure(StructureEnseignement structureEnseignement) {
return "${structureEnseignement.code}|"+
/**
* Trie fichiers par le type
- * @param files
- * @return
*/
Map<TypeFichier, List<FileInfo>> listeFichiersInfoByTypeFichier(List<FileInfo> files)
/**
* Liste des erreurs issus de l'accès aux fichiers
- * @return
*/
List<String> getErreurs()
/**
* Trie les fichiers a traites. Chaque liste corresponde a un pair porteur-academie.
* La premier liste contient les fichiers non-AAF sans porteur-academie.
- * @return
*/
List<LotFichiers> listeFichiersByPorteurAcademie()
}
\ No newline at end of file
/**
* Méthode permettant de retourner les statistiques
- * @return
*/
String statisticsAsString() {
def res = null
/**
* Trie les fichiers a traites. Chaque liste correspond a une paire porteur-academie.
* La première liste contient les fichiers non-AAF sans porteur-academie s'ils existent
- * @return
*/
List<LotFichiers> listeFichiersByPorteurAcademie() {
List<FileInfo> fichiersAtraiter = listeFichiersAtraiter()
* Vérifie qu'il n'y ait pas de lots contenant des fichiers ayant, pour la même
* entité, deux types d'import différents (Complet/Delta)
* Si c'est le cas, l'import entier est annulé.
- * @param lots
* @return lots corrects
*/
void verifieTypeImportDansLots(List<LotFichiers> lots) {
/**
* Liste tous les fichiers a traiter avec le bon nom
- * @return
*/
private List<FileInfo> listeFichiersAtraiter() {
List<FileInfo> fichiersAtraiter = []
/**
* Recupere les informations contenu dans le nom de fichier
- * @param file
- * @return
*/
private FileInfo extraisFileInfo(File file) {
/**
* Creation d'enregistrement de suppression d'un admin local
- * @param sql
- * @param personne
- * @param contexteImport
- * @return
*/
def marqueSuppressionAdminLocal(Sql sql, Personne personne, ContexteImport contexteImport) {
Long personneId = SqlUtils.getNextValueFromSequence(
/**
* Creation d'enregistrements designant qu'un admin local est ratache aux etablissements
- * @param sql
- * @param personne
- * @param contexteImport
- * @return
*/
List<Long> marqueInsertionPairAdminLocalEtablissement(Sql sql,
Personne personne,
/**
* Nombre de pairs admin local - etablissement marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombrePairsALEtabMarqueesAInserer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesAInserer(sql, contexteImport, ENTITE_AIF_ADMIN_LOCAL)
/**
* Nombre d'admin locaux marqués à supprimer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombrePairsALEtabMarqueesASupprimer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesASupprimer(sql, contexteImport, ENTITE_AIF_ADMIN_LOCAL)
/**
* Creation d'enregistrement d'une structure d'enseignement
- * @param sql
- * @param eleve
- * @param contexteImport
*/
void marqueInsertionStructuresEnseignement(Sql sql, Eleve eleve, ContexteImport contexteImport) {
eleve.profilsScolarite?.each { ProprietesScolarite proprietesScolarite ->
/**
* Creation d'enregistrement d'une repartition d'eleve
- * @param sql
- * @param eleve
- * @param contexteImport
*/
void marqueInsertionEleveRepartitions(Sql sql, Eleve eleve, ContexteImport contexteImport) {
/**
* Creation d'enregistrement de la suppression d'un eleve
- * @param sql
- * @param eleve
- * @param contexteImport
- * @return
*/
def marqueSuppressionEleve(Sql sql, Eleve eleve, ContexteImport contexteImport) {
Long eleveId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_ELEVE)
/**
* Creation d'enregistrement d'un eleve
- * @param sql
- * @param eleve
- * @param contexteImport
- * @return
*/
Long marqueInsertionEleve(Sql sql, Eleve eleve, ContexteImport contexteImport) {
Long eleveId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_ELEVE)
/**
* Nombre d'eleves marqués à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreElevesMarquesAInserer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesAInserer(sql, contexteImport, ENTITE_AIF_ELEVE)
/**
* Nombre de repartitions marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreEleveRepartitionsMarquesAInserer(Sql sql, ContexteImport contexteImport) {
// on n'a pas type_requete dans eleve_repartition
/**
* Nombre de structures d'enseignement marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreStructuresMarqueesAInserer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesAInserer(
/**
* Nombre d'eleves marqués à supprimer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreElevesMarquesASupprimer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesASupprimer(sql, contexteImport, ENTITE_AIF_ELEVE)
/**
* Load objet dans un transaction
- * @param obj
- * @param sql
- * @param contexteImport
- * @return
*/
def loadObjectInTransaction(ResultatTransformation obj,
Sql sql,
/**
* Traitement spécifique aux objets de même entité avant la finalisation de l'import.
* @param sql le canal SQL
- * @return
*/
abstract def doAfterProcessImportObjets(Sql sql)
/**
* Creation d'objet Sql
- * @return
*/
def initSql() {
sql = new Sql(dataSource)
/**
* Nombre d'entites marquées à insérer
- * @param sql
- * @param contexteImport
- * @param nomTable
- * @return
*/
Long nombreItemsMarquesAInserer(Sql sql, ContexteImport contexteImport, String nomTable) {
String sqlString = "select count(*) from ${nomTable} where "+
/**
* Nombre d'entitees marquées à supprimer
- * @param sql
- * @param contexteImport
- * @param nomTable
- * @return
*/
Long nombreItemsMarquesASupprimer(Sql sql, ContexteImport contexteImport, String nomTable) {
String sqlString = "select count(*) from ${nomTable} where "+
/**
* Creation d'enregistrement d'une fonction de personne hors AAF
- * @param sql
- * @param personne
- * @param contexteImport
*/
void marqueInsertionPersonneFonctions(Sql sql, Personne personne, ContexteImport contexteImport) {
personne.profilsScolarite?.each { ProprietesScolarite proprietesScolarite ->
/**
* Creation d'enregistrement de suppression d'une personne hors AAF
- * @param sql
- * @param personne
- * @param contexteImport
- * @return
*/
def marqueSuppressionPersonneHorsAAF(Sql sql, Personne personne, ContexteImport contexteImport) {
Long personneId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_HORS_AAF)
/**
* Creation d'enregistrement d'une perssone hors AAF
- * @param sql
- * @param personne
- * @param contexteImport
- * @return
*/
Long marqueInsertionPersonneHorsAAF(Sql sql, Personne personne, ContexteImport contexteImport) {
Long personneId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_HORS_AAF)
/**
* Nombre de personnes hors AAF marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombrePersonnesHorsAAFMarqueesAInserer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesAInserer(sql, contexteImport, ENTITE_AIF_HORS_AAF)
/**
* Nombre de fonctions de personne hors AAF marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombrePersonneHorsAAFFonctionsMarqueesAInserer(Sql sql, ContexteImport contexteImport) {
// on n'a pas type_requete dans eleve_repartition
/**
* Nombre de personnes hors AAF marquées à supprimer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombrePersonnesHorsAAFMarqueesASupprimer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesASupprimer(sql, contexteImport, ENTITE_AIF_HORS_AAF)
/**
* Creation d'enregistrement d'une fonction de prof
- * @param sql
- * @param prof
- * @param contexteImport
*/
void marqueInsertionProfFonctions(Sql sql, Personne prof, ContexteImport contexteImport) {
prof.profilsScolarite?.each { ProprietesScolarite proprietesScolarite ->
/**
* Creation d'enregistrement de suppression d'un prof
- * @param sql
- * @param prof
- * @param contexteImport
- * @return
*/
def marqueSuppressionProf(Sql sql, Personne prof, ContexteImport contexteImport) {
Long profId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_PROF)
/**
* Creation d'enregistrement d'un prof
- * @param sql
- * @param prof
- * @param contexteImport
- * @return
*/
Long marqueInsertionProf(Sql sql, Personne prof, ContexteImport contexteImport) {
Long profId = SqlUtils.getNextValueFromSequence(sql, SEQUENCE_AIF_PROF)
/**
* Nombre de profs marqués à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreProfsMarquesAInserer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesAInserer(sql, contexteImport, ENTITE_AIF_PROF)
/**
* Nombre de fonctions de prof marquées à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreProfFonctionsMarqueesAinserer(Sql sql, ContexteImport contexteImport) {
// on n'a pas type_requete dans eleve_repartition
/**
* Nombre de profs marqués à insérer
- * @param sql
- * @param contexteImport
- * @return
*/
Long nombreProfsMarquesASupprimer(Sql sql, ContexteImport contexteImport) {
return nombreItemsMarquesASupprimer(sql, contexteImport, ENTITE_AIF_PROF)
/**
* Marque la fin d'import
- * @param importId
*/
void marqueFinImport(ContexteImport contexteImport) {
withLoaderTransaction { def sql ->
/**
* Renseignement des champs de responsables eleve par rapport a autoritesParentales
- * @param autoritesParentales
- * @param parents
- * @param eleve
- * @return
*/
private def setResponsablesElevesForAutoritesParentales(def autoritesParentales,
def parents,
/**
* Renseignement des champs de responsables eleve ou tous les responsables
* sont les parents
- * @param parents
- * @param eleve
- * @return
*/
private def setResponsablesElevesForParentsUniquement(def parents,
Eleve eleve) {
/**
* Cree une ProprieteScolarite depuis ENTPersonFonctions
- * @param fonction
- * @return
*/
private ProprietesScolarite proprietesScolariteForFonction(String fonction) {
ProprietesScolarite proprietesScolarite = new ProprietesScolarite()
/**
* Verifie qu'un enregistrement a les champs comme attendu
- * @param sql
- * @param nomTable
- * @param whereClause
- * @param champs
*/
void verifieRecord(Sql sql,
String nomTable,
/**
* Méthode permettant d'effectuer une demande de traitement
- * @param demande
* @return l'identifiant de la demande
* @author bper
*/
/**
* Retourne la demande de traitement de priorité max pour un type de traitement donné
- * @param traitementType
* @return la demande ou null si elle n'existe pas
*/
DemandeTraitement getDemandeTraitementPrioriteMax(TraitementType traitementType)
/**
* Retourne la demande de traitement de priorité max pour une liste de types de traitement
* donnée
- * @param traitementTypes
* @return la demande ou null si elle n'existe pas
*/
DemandeTraitement getDemandeTraitementPrioriteMax(List<TraitementType> traitementTypes)
/**
- * @param params
* @return les données d'historique des traitement selon les paramètres
*/
List<DemandeTraitement> getHistoriqueDemandesTraitements(SuiviDemandeTraitementParams params)
/**
* Supprime une demande de traitement
- * @param demandeTraitementId
*/
void supprimeDemandeTraitements(List<Long> demandeTraitementIds)
}
\ No newline at end of file
/**
* Lève une exception si la valeur de l'attribut dont le nom est passé
* en paramètres est null.
- * @param prop
*/
protected void checkNotNullProperty(String prop) {
if (this."$prop" == null) {
/**
* Méthode permettant d'effectuer une demande de traitement
- * @param demande
* @return l'identifiant de la demande
* @author bper
*/
/**
* Supprime une demande de traitement
- * @param demandeTraitementId
*/
void supprimeDemandeTraitements(List<Long> demandeTraitementIds) {
demandeTraitementIds.each {
/**
* Retourne la liste des DefaultDemandeTraitement avec dataSource = null afin
* de les rendre non modifiables.
- * @param params
* @return les données d'historique des traitement selon les paramètres
*/
List<DefaultDemandeTraitement> getHistoriqueDemandesTraitements(
/**
* Teste si une autorité est propriétaire de ce fichier
- * @param autorite
- * @return
*/
public boolean isAutoriteProprietaire(Autorite autorite)
/**
* Permet de savoir si le fichier est dans un groupe étendu ou un partage etablissement
*
- * @return
*/
public boolean estPartage()
/**
* Teste si une autorité est propriétaire de ce fichier
- * @param autorite
- * @return
*/
public boolean isAutoriteProprietaire(Autorite autorite) {
return autorite.encodeAsString() == this.getProprietaireId()
/**
* Permet de savoir si le fichier est dans un groupe étendu ou un partage etablissement
*
- * @return
*/
public boolean estPartage() {
synchronizeNode()
/**
* Création du noeud racine d'une organisation
- * @param rootNode
* @param organisationId : identifiant de l'organisation
- * @return
*/
private Node creationNoeudRacineOrganisation(Node rootNode, String organisationId) {
Node organisationNode = rootNode.addNode(
/**
*
- * @param ressourceId
- * @param nodeTypeRessource
- * @param jcrSession
- * @return
*/
public boolean estInitialisee(String ressourceId,
String nodeTypeRessource,
/**
*
- * @param ressourceId
- * @param nodeTypeRessource
- * @param jcrSession
*/
public void supprimer(String ressourceId,
String nodeTypeRessource,
/**
*
- * @param ressourceId
- * @param nodeTypeRessource
- * @param jcrSession
*/
public void initialiser(String ressourceId,
String nodeTypeRessource,
/**
* Création du noeud racine des ressources indexées
- * @param rootnode
- * @return
*/
private Node creationNoeudRacineRessourceIndexee(Node rootNode) {
/**
* Récupère ou construit un noeud composant un id de ressource indexée
- * @param racine
- * @param chemin
- * @return
*/
private Node creationComposanteId(Node parent, String chemin) {
Node hNode
* Le but est de pouvoir différencier les différents type de
* ressource indexé.
*
- * @param parent
- * @param index
- * @return
*/
private Node creationNoeudIndex(Node parent, String index) {
Node noeudIndex
/**
* permet d'ajouter un dossier ou un fichier au noeud parent
- * @param nodeParent
- * @param proprietaireActeurInfo
* @param nom : nom du fichier ou dossier
* @param description : description du fichier ou dossier
* @param typeItem (nt:file ou nt:folder)
- * @param auteurActeurInfo
- * @return
*/
private Node ajouterDossierFichier(Node nodeParent,
DocsActeurInfo proprietaireActeurInfo,
/**
* lit le noeud du groupe étendu décrit par l'information de ressource indexée
- * @param jcrSession
- * @param ressourceIndexeeInfo
- * @return
*/
private Node getNodeGroupeEtendu(javax.jcr.Session jcrSession,
RessourceIndexeeInfo ressourceIndexeeInfo) {
/**
* Retourne le dossier correspondant à un groupe étendu
- * @param securiteSession
- * @param ressourceIndexeeInfo
- * @return
*/
public Dossier retournerGroupeEtendu(SecuriteSession securiteSession,
RessourceIndexeeInfo ressourceIndexeeInfo) {
* Met à jour le suffixe de partage (le suffixe de partage était l'id de
* l'autorité propriétaire, il doit maintenant être l'encodage de l'autorité
* propriétaire)
- * @param noeud
*/
private void traiteSuffixePartage(Node noeud) {
* Compte le nombre de noeuds enfants, petits enfants.....
* @param base base de comptage
* @param noeud : noeud courant
- * @return
*/
private Integer nombreNoeudEnfants(Integer base, Node noeud) {
/**
* log les erreurs sur une organisation
- * @param noeud
- * @param nomTypeNoeud
- * @param rapport
*/
private boolean logErreurOrganisation(Node noeud, String nomTypeNoeud, DocsIntegriteRapport rapport, boolean reparationAuto) {
/**
* Essaye de réparer (par suppression) le dépot de l'organisation
- * @param messageErreurRacineUtilisateur
- * @param noeud
- * @param rapport
*/
private boolean repareOrganisation(String messageErreurRacineUtilisateur, Node noeud, DocsIntegriteRapport rapport) {
/**
* Ajoute un message d'erreur sur l'organisation dans le log
- * @param rapport
- * @param noeud
- * @param messageErreurRacineUtilisateur
*/
private void rapportErreurOrganisation(DocsIntegriteRapport rapport, Node noeud, String messageErreurRacineUtilisateur) {
rapport.ajouteErreur(
* Méthode temporaire destinée à patcher le fonctionnement d'authentification
* d'eliot-docs sur le repository suite au changement d'API (code porteur)
* en attendant de reprendre en profondeur le mécanisme
- * @param securiteSession
- * @return
* - TypeRole.ROLE_ELEVE si l'utilisateur est un élève ;
* - TypeRole.ROLE_ELEVE.PERS_REL_ELEVE si l'utilisateur est un parent d'élève ;
* - TypeRole.INVITE si l'utilisateur est un invité ;
/**
* Retourne les informations de la racine des ressources indexées
- * @return
*/
public static JcrSystemNodeInfo getInfoRessourcesIndexees() {
def nom = JcrConstants.ELIOT_RACINE_RESSOURCES_INDEX
/**
* Retourne les informations du noeud correspondant à un groupe etendu
- * @param groupeEtenduId
- * @return
*/
public static JcrSystemNodeInfo getInfoGroupeEtendu(String groupeEtenduId) {
/**
* Retourne les infos du noeud d'une ressource indexée.
- * @param ressourceId
- * @param typeRessource
- * @return
*/
public static JcrSystemNodeInfo getInfoRessourceIndexee(String ressourceId,
String typeRessource) {
/**
* Retourne le node JCR correspondant au chemin
- * @param jcrSession
- * @return
*/
public Node getNode(javax.jcr.Session jcrSession) {
return (Node) jcrSession.getItem(
/**
* Constructeur : on lui passe l'identifiant et le type de la ressource indexée
- * @param ressourceIndexId
- * @param typeRessource
- * @return
*/
public RessourceIndexeInfo(String ressourceIndexId, String typeRessource) {
/**
* Retourne le chemin de la ressource
- * @return
*/
public String getPath() {
"/$racineRessourceIndexe/$h1/$h2/$h3/$ressourceIndexId/$typeRessource"
/**
* Indique s'il s'agit d'une ressource indexée
- * @param path
- * @return
*/
boolean estRessourceIndexees(Path path) {
return path.isEquivalentTo(ressourcesIndexees)
/**
* prépare un fichier AAF
* @param typeFichier : type de fichier aaf à préparer
- * @return
*/
private FichierAaf prepareFichier(TypeFichier typeFichier) {
new FichierAaf(
/**
* Prépare les fichiers AAF
- * @return
*/
private prepareFichiersAAF() {
/**
* Exporte les données des ldifentry vers les fichier AAF
* S'occupe aussi du log d'éventuelles erreurs
- * @param ldifEntry
*/
@SuppressWarnings('CatchException')
private void exporteLdifEntry(LdifEntry ldifEntry) {
/**
* Exporte les données des personnels d'éducation vers leur fichier AAF.
* Assure la génération de l'attribut PersEducNatPresenceDevantEleves
- * @param analyseurLdif
*/
private void exporteAttributsPersonnelEducation(AnalyseurLdif analyseurLdif) {
/**
* Calcule le chemin du fichier de sortie selon le type
- * @param sousTypeItem
* @return le chemin complet
*/
String getCheminFichierAaf(String sousTypeItem) {
/**
* Importe tous les fichiers contenus par le dossier
- * @param chemin
*/
public void importeFichiersDossier() {
/**
* Ajoute un item dans la liste des fichiers traités
- * @param nomFichier
*/
void ajouteFichierTraite(String nomFichier) {
fichierTraites << nomFichier
/**
* Ecriture de l'id d'un item
- * @param id
*/
private void identifier(String id) {
startElement(IDENTIFIERS) {
/**
* Ecrit un texte brut dans la balise courante
- * @param texte
*/
public void writeText(String texte) {
xmlw.writeCharacters(texte)
/**
* Ecrit un attribut d'item
- * @param name
- * @param value
*/
public void attribute(String name, String value) {
xmlw.writeAttribute(name, value)
/**
* Copie d'un élément ldif dans le fichier aaf
- * @param source
- * @param listeAttributsAExporter
*/
public void exporteLdif(AnalyseurLdif source,
TraitementAttributs listeAttributsAExporter) {
/**
* Exporte un élément ldif dans le fichier aaf
- * @param source
- * @param listeAttributsAExporter
* @param complement : traitement complémentaire pour un attribut. Cette
* closure est appelée pour chaque attribut d'un élément ldif. Cela
* permet d'alimenter les attributs AAF
* @param nom : nom de la propriété à modifier
* @param listeAttributsAExporter : pour récupérer une instance de convertisseur
* @param valeurs : liste des valeurs de la propriété
- * @return
*/
private List<String> transformationDesValeurs(String nom,
TraitementAttributs listeAttributsAExporter,
/**
* fourni un éventuel convertisseur de donnée pour une propriété
- * @param nom
- * @return
*/
public Convertisseur create(String nom)
/**
* Indique s'il existe une propriété nom
* @param nom : nom de l'enum recherché
- * @return
*/
public boolean existe(String nom)
/**
* Lecture d'un attribut multi-valuée
- * @param entryAttribute
- * @return
*/
public List<String> readStringList(EntryAttribute entryAttribute) {
List<String> reponse = []
/**
* Lecture d'un attribut mono-value
- * @param entryAttribute
- * @return
*/
private String readString(EntryAttribute entryAttribute) {
List<String> listeAttr = readStringList(entryAttribute)
/**
* Lecture de tous les attributs sauf des classes et uid qui ont déjà été traités
- * @param closure
*/
public void each(Closure closure) {
for (EntryAttribute attribute: ldifEntry.getEntry()) {
/**
* Recherche les classes de données de contenu dans l'objet Ldif
- * @param ldifEntry
*/
private void rechercheClasse() {
/**
* Retourne le type de l'item AAF
- * @return
*/
public TypeFichier findTypeFichier() {
/**
* Indique si on est en train de manipuler un élève
- * @return
*/
public boolean isEleve() {
return (objectclasses.find {it == CLASSE_ELEVE} != null)
/**
* Indique si on est en train de manipuler un établissement
- * @return
*/
public boolean isEtab() {
/**
* Indique si on est en train de manipuler un personne en relation avec
* un élève
- * @return
*/
public boolean isEnRelAvecEleve() {
return (objectclasses.find {it == CLASSE_PERSONNE_REL_ELEVE} != null)
/**
* Indique si on est en train de manipuler un personnel d'education
- * @return
*/
public boolean isPersEducNat() {
/**
* Affiche un message dans le rapport
* @param message le message a faire apparaitre dans le rapport
- * @return
*/
def doWithMessage(String message) {
logger.info(message)
\r
/**\r
* Verifie le fichier d'eleves genere\r
- * @param application\r
*/\r
private void verifieDonneesAAFEleve(Application application) {\r
\r
\r
/**\r
* Verifie le fichier des responsables genere\r
- * @param application\r
*/\r
private void verifieDonneesAAFParents(Application application) {\r
\r
\r
/**\r
* Verifie le fichier d'enseignants genere\r
- * @param application\r
*/\r
private void verifieDonneesAAFEnseignant(Application application) {\r
\r
\r
/**\r
* Verifie le fichier d'etablissements genere\r
- * @param application\r
*/\r
private void verifieDonneesAAFEtablissement(Application application) {\r
\r
/**
* Document par défaut
- * @return
*/
public static final Resource docbookParDefault() {
return new ClassPathResource("default.xml")
/**
* document d'erreur
- * @return
*/
public static final Resource docbookErreur() {
return new ClassPathResource("erreur.xml")
/**
* Charge la config fop
- * @return
*/
public static final InputStream fopConfigFile() {
this.getClassLoader().getResourceAsStream("config.xml")
/**
* Retourne le texte du document par défaut
- * @return
*/
static public String texte() {
Resource resource = ResourceUtils.docbookParDefault()
/**
* Retourne le texte la page d'erreur
- * @return
*/
static public String docErreur() {
Resource resource = ResourceUtils.docbookErreur()
/**
* Convertion d'une resource en string
- * @param resource
- * @return
*/
private static String resourceToString(Resource resource) {
StringWriter writer = new StringWriter()
/**
* positionne les paramètres de la feuille de style docbook to pdf
- * @param transformer
- * @param sansSommaire
*/
private void affecteParametres(Transformer transformer, boolean sansSommaire) {
// libellé en français
/**
* Permet de charger le fichier de configuration FOP
- * @param fopFactory
*/
private void chargeConfigurationFactory(FopFactory fopFactory) {
DefaultConfigurationBuilder cfgBuilder = new DefaultConfigurationBuilder()
/**
* Construction d'un objet result à partir des données docbook à
* transformer. Construit aussi un objet fop pour générer du pdf.
- * @param ctx
- * @return
*/
private Result getResult(DonneesPourLeRendu ctx) {
try {
/**
* Permet de convertir un document docbook en pdf
- * @param ctx
*/
public void render(DonneesPourLeRendu ctx) {
/**
* Retourne le fichier pdf de rendu du fichier docbook
- * @param docbook
- * @param sansSommaire
- * @return
*/
public byte[] render(String docbook, boolean sansSommaire) {
try {
/**
* Verification si le webservice est deploye
- * @return
*/
response.outputStream << "tout va bien"
/**
* Encodage HTML basique
- * @param s
- * @return
*/
String mathML = null
/**
* Gestion du breadCrumbs : Les classes descendantes peuvent surcharger cette
* partie pour implémenter leur propre gestion.
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
/**
* Permet de parser des objets
* @author bahj
- * @param data
- * @return
*/
protected List<Map> parseDataForJSON(List data) {
List<Map> resultats = []
/**
* retourne la date formatée exp : '24/02/2011'
* @author bahj
- * @param date
* @return une String
*/
protected String formateDate(Date date) {
/**
* retourne l'heure formatée exp : '13:30'
* @author bahj
- * @param date
* @return une String
*/
protected String formateHeure(Date date) {
/**
* Parse une chaine du format dd/mm/yyyy,hh:mm en date
* @author bahj
- * @param dateComplete
- * @return
*/
protected Date parseDateComplete(String dateComplete) {
String parse = message(code: FORMAT_DATE) +
/**
* Parse une cahine du format dd/MM/yyyy en date
* @author bahj
- * @param date
- * @return
*/
protected Date parseDate(String date) {
String parse = message(code: FORMAT_DATE)
/**
* Traduction d'un message fournie par l'application
- * @param code
- * @return
*/
protected String traduis(String msgCode) {
return message(code: msgCode)
/**
* Retourne les données pour la construction du menu d'aide en ligne
- * @return
*/
protected AideItemInfo getAideInfo() {
AideItemInfo menuAideInfo = menuAideAbsencesService.getMenuAideInfo(securiteSession)
}
/**
- * @param motifDefauts
- * @param motifs
* @return une intersection des 2 listes de motifs
*/
protected List<Motif> getSousListeMotifsDefaut(List<Motif> motifDefauts,
/**
* Retourne la page par défaut
- * @return
*/
protected Object getDefaultPage(Object pageSouhaitee) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Formate les appelLigne pour la vue de consultation des absences,
* retards et départ par le profil parent et le profil élève
- * @param lstLignes
- * @return
* @author bahj
*/
private traduitInfoConsultationParentEtEleves(List lstLignes) {
/**
* Retourne les données horaires de l'absence, traduites
- * @param appelLigne
* @return une chaine
*/
private String traduitHorairesAbsence(AppelLigne appelLigne) {
/**
* traduit les codes I18n correspondant à profilAppelant
- * @param resultatConsultation
- * @return
*/
private ResultatConsultation traduitProfilAppelant(ResultatConsultation resultatConsultation) {
resultatConsultation.lignes.each {LigneConsultation ligne ->
/**
* Filtre ou complète la liste des structures
- * @param command
*/
private void consolideListeStructures(AppelsOubliesCommand command) {
List<StructureEnseignement> structuresAutorisees =
/**
* Retourne la liste des structures autorisées en fonction de la requête
- * @param command
- * @return
*/
private List<StructureEnseignement> findStructuresAutorisees(AppelsOubliesCommand command) {
List<StructureEnseignement> structuresAutorisees = []
/**
* Permet de formatter un entier en 2 chifrres
* @param number le numéro à formatter
- * @return
* @author bahj
*/
private String formatteNumeroTo2Chiffres(int number) {
}
/**
- * @param messageCode
* @return une Map décrivant une erreur
*/
private Map getResultError(String messageCode) {
/**
* Convertion de l'objet contenant l'arbre des motif en JSON
- * @param arbreMotifInfo
- * @return
*/
private JSON allGroupeMotifVersJson(List<GroupeMotif> allGroupeMotif) {
/**
* Convertion d'un groupe motif pour l'interface
- * @param noeudMotifInfo
- * @return
*/
private Map groupeMotifToMap(GroupeMotif groupeMotif) {
/**
* Liste des modèles de sms
- * @return
*/
private List findAllTemplateSms() {
/**
* Permet de convertir les informations de type media sous forme de map
* dans le but de les mettre dans le modèle
- * @param typeMedia
- * @return
*/
private Map getMapforMedia(TypeMedia typeMedia) {
return [
/**
* Liste des média de sortie
- * @return
*/
private List listeMedia() {
List result = []
/**
* Construit la map à rendre en JSON
- * @param suivis
- * @param listeEnvoi
- * @return
*/
private Map construitResult(List<PublipostageSuivi> suivis, Map listeEnvoi) {
Map result = (Map) [:]
/**
* recherche la liste des structures d'enseignement par rapport à la liste des
* id passée en paramètre
- * @param mapParams
- * @param it
- * @return
*/
private List<StructureEnseignement> findAllStructureEnseignement(Map mapParams) {
List<StructureEnseignement> classes = []
/**
* Recherche la liste des modèles de documents par rapport à ceux passé en
* paramètre
- * @param mapParams
- * @return
*/
private List<TemplateDocument> findAllTemplateDocument(Map mapParams) {
List<TemplateDocument> modeles = []
/**
* Liste des classes
- * @return
*/
private List<StructureEnseignement> internalGetClasses() {
/**
* Récupération de tous les motifs
- * @return
*/
private def tousLesMotifs() {
/**
* Mets un appel temporaire dans la session
- * @param appelEnteteInfo
*/
private void metsAppelDansSession(AppelTemporaire appelTemporaire) {
session[APPEL_TEMP] = appelTemporaire
/**
* Charge l'appel temporaire depuis la session
- * @return
*/
private AppelTemporaire chargeAppelDepuisSession() {
return (AppelTemporaire) session[APPEL_TEMP]
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Parse les paramètres de la requête de recherche
- * @param params
* @return un RechercherParams
*/
private RechercherParams parseRechercherParams(Map params) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
* Renvoie une liste de jours fériés de la semaine
* à condition que rechercherParams.dateDebut et rechercherParams.dateFin
* soient dans la même semaine
- * @param dateDebut
- * @param dateFin
- * @param etablissement
- * @param locale
- * @return
*/
public List<JourFerieInfo> joursFeriesSemaine(Date dateDebut,
Date dateFin,
/**
* Marshall une ligne de calendrier Hebdo en tenant compte des jours fériés
- * @param ligneCalendrier
- * @param joursFeries
- * @param locale
- * @param sdf
- * @return
*/
Map marshallLigneCalendrierHebdo(CalendrierHebdoLigne ligneCalendrier,
List<JourFerieInfo> joursFeries,
/**
* "Ferme" les jours fériés en appliquant closureLigne à la ligne
- * @param joursFeries
- * @param calendar
- * @param ligne
- * @param closureLigne
*/
private void fermeJoursFeries(List<JourFerieInfo> joursFeries,
Calendar calendar,
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
/**
* Récupération des incidents
* partie commune à l'affichage et à l'export
- * @param jsonCriteres
- * @param champTri
- * @param triAscendant
- * @param offset
- * @param limit
- * @return
*/
private Map recupIncidents(String jsonCriteres,
String champTri,
/**
* Cree un incident
- * @param incidentACreerParams
- * @return
*/
private creeIncident(IncidentParams incidentACreerParams) {
Map resultats = [:]
/**
* Modifie un incident
- * @param incidentAModifierDto
- * @param idIncident
- * @return
*/
private Map modifieIncident(IncidentParams incidentAModifierDto,
Long idIncident) {
/**
* Construit un incidentModificationInfo, utilisé dans la vue de modification
- * @param incident
* @author bahj
*/
private IncidentModificationInfo getIncidentModificationInfo(Incident incident) {
/**
* Construit la liste des partenaires à prévenir de l'incident à modifier
- * @param incident
* @author bahj
*/
private String getPartenairesPrevenusModification(Incident incident) {
/**
* Construit la liste des protagonistes de l'incident à modifier
- * @param incident
* @author bahj
*/
private List<ProtagonisteModificationInfo> getProtagonistesModificationInfo(
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
}
/**
- * @param params
* @return le message en fonction du mode
*/
private def getMessageModele(Map params) {
/**
* Récupération des punitions
* partie commune à l'affichage et à l'export
- * @param jsonCriteres
- * @param champTri
- * @param triAscendant
- * @param offset
- * @param limit
- * @return
*/
private Map recupPunitions(String jsonCriteres,
String champTri,
/**
* Permet de construire les dto pour la vue de consultation des sanctions
- * @param sanctions
- * @return
*/
private List<PunitionConsultationInfo> parsePunitionsInfoForConsultation(
List punitionsInfo
/**
* Parse les paramètres pour constituer un PunitionParams
- * @param params
* @return un PunitionParams
*/
protected PunitionParams parsePunitionParams(Map params) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Récupération des sanctions
* partie commune à l'affichage et à l'export
- * @param jsonCriteres
- * @param champTri
- * @param triAscendant
- * @param offset
- * @param limit
- * @return
*/
private Map recupSanctions(String jsonCriteres,
String champTri,
/**
* Construit le message en fonction du mode
- * @param params
- * @return
*/
private String getMessageModele(Map params) {
Boolean isModeModification = null
/**
* Permet de construire les dto pour la vue de consultation des sanctions
- * @param sanctions
- * @return
*/
private List<SanctionConsultationInfo> parseSanctionsInfoForConsultation(
List sanctionsInfo
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
}
/**
- * @param paramInfo
* @return le SaisieDispenseParams correspondant aux données saisies
*/
private SaisieDispenseParams parseSaisieDispense(Map paramInfo) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
/**
* Traite une ligne d'absence devant être associée à un appel en dédoublonnant
* les lignes portant sur des appels avec plusieurs plages horaires.
- * @param lignesExistantes
- * @param ligneATraiter
*/
private void associeAbsenceAUnAppel(List<AbsenceJourneeLigneParams> lignesExistantes,
AbsenceJourneeLigneParams ligneATraiter,
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
/**
* Parse les paramètres de la requête et retourne un StatsMensuellesParams
- * @param params
* @return un StatsMensuellesParams
*/
protected StatsMensuellesParams parseParams(Map mapParams) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Parse les paramètres de la requête et retourne un StatsMensuellesParams
- * @param params
* @return un StatsMensuellesParams
*/
protected StatsMensuellesParams parseParams(Map mapParams) {
/**
* Parse les types de discipline
* (type punitions, sanctions, incidents)
- * @param type
- * @param typesDisciplineIds
- * @return
*/
protected List parseParamTypesDiscipline(Type type, String typesDisciplineIds) {
List resultats = []
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Retourne les préférences de l'établissement courant
- * @param securiteSession
- * @param etablissementParDefaut
* @return une PreferencesEtablissementAbsences
*/
PreferencesEtablissementAbsences getPreferencesEtablissementAbsencesCourant(SecuriteSession securiteSession,
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.absences.aideEnLigne.url
/**
* Retourne un résultat vide
- * @return
*/
private ResultatConsultation getResultVide() {
return new ResultatConsultation()
/**
* Indique si l'élève est absent ou en retard sur la période
- * @param eleve
- * @param debutPeriode
- * @param finPeriode
* @return un Boolean
*/
Boolean isEleveAbsentForPeriode(Personne eleve,
/**
* Recherche l'existence d'AbsenceJournee ou l'élève est absent puor la période
- * @param eleve
- * @param debut
- * @param fin
* @return true s'ile xiste un appelLigne pour l'élève sur la période
*/
Boolean existeAbsenceJourneeForEleveAndPeriode(Personne eleve,
/**
* Recherche l'existence d'appel ou l'élève est absent pour la période
- * @param eleve
- * @param debut
- * @param fin
* @return true s'il existe un appelLigne pour l'élève sur la période
*/
Boolean existeAppelForEleveAndPeriode(Personne eleve, Date debut, Date fin) {
* Retournes les absences, retards et départ valables d'un élève
*
* @param params les paramètres de la recherche
- * @return
* @author bahj
*
*/
/**
* Retourne la date de l'absence (abs, retard, départ,..)
- * @param appelLigne
- * @return
*/
Date getDateFromAppelLigne(AppelLigne appelLigne) {
if (appelLigne.appel) {
/**
* Initialisation à partir d'un AppelLigne
- * @param appelLigne
*/
void loadFromAppelLigne(AppelLigne appelLigne){
this.retard = appelLigne.retard
/**
* Retourne la liste des élèves correspondant aux critères
- * @param criteria
* @return un Set<Personne>
*/
private Set<Personne> findAllElevesForCriteria(PublipostageCriteresRecherche criteria) {
/**
* Constitue la chaine à envoyer au front office
- * @param closureHeure
- * @return
*/
Map getInfos(Closure closureHeure){
Map result = (Map)[:]
/**
* Retourne le nombre d'appels manquants
- * @param enseignements
* @return un Long
*/
Long findCount(List<Enseignement> enseignements, AppelsOubliesCommand command) {
/**
* Recherche les événements
- * @param enseignements
- * @param command
- * @return
*/
List findDatas(List<Enseignement> enseignements, AppelsOubliesCommand command) {
Calendar cal = Calendar.getInstance()
/**
* Recherche la liste des enseignements correspondant aux critères
- * @param command
* @return une List<Enseignement>
*/
List<Enseignement> findEnseignements(AppelsOubliesCommand command) {
/**
* L'export de resultat de la recherche avec une liste multicritere
- * @param listeBilan
- * @return
*/
DonneesPourExportCSV prepareExportAbsencesMulticritere(ResultatConsultation listeBilan) {
DonneesPourExportCSV donnees = new DonneesPourExportCSV()
/**
* Export des sanctions pour du csv
- * @param sanctionData
- * @return
*/
public DonneesPourExportCSV prepareSanctions(Map sanctionData) {
DonneesPourExportCSV donneesPourExportCSV = new DonneesPourExportCSV()
/**
* Export des données csv des punitions
- * @param punitionData
- * @return
*/
public DonneesPourExportCSV preparePunitions(Map punitionData) {
/**
* Recherche les données des incidents pour générer un fichier csv
- * @param incidentData
- * @return
*/
public DonneesPourExportCSV prepareIncidents(List<IncidentConsultationInfo> incidentData) {
DonneesPourExportCSV donneesPourExportCSV = new DonneesPourExportCSV()
/**
* L'export de resultat de la recherche du tableau de bord
- * @param tableauDeBord
- * @param afficherLesAbsencesEnHeures
* @param traduction de libelle 'Totaux'
- * @return
*/
DonneesPourExportCSV prepareExportTableauDeBord(TableauDeBord tableauDeBord,
Boolean afficherLesAbsencesEnHeures,
/**
* L'export de resultat de la recherche des statistiques mensuelles par classe
- * @param datasTempsReel
- * @return
*/
public DonneesPourExportCSV prepareExportTempsReel(Map datasTempsReel) {
/**
* Modifie le paramètre indiquant la longueur d'une plage
- * @param securiteSession
- * @param preferences
- * @param codeLongueur
*/
void setLongueurPlage(SecuriteSession securiteSession,
PreferencesEtablissementAbsences preferences,
/**
* Modifie le paramètre indiquant le mode de calcul du taux d'absences
- * @param securiteSession
- * @param preferences
- * @param tauxAbsencesCalculMode
*/
void setTauxAbsencesCalculMode(SecuriteSession securiteSession,
PreferencesEtablissementAbsences preferences,
/**
* Retourne le mode de calcul du taux d'absences
- * @param preferences
* @return tauxAbsencesClaculMode
*/
String getTauxAbsencesModeCalcul(preferences) {
/**
* Permet de supprimer un type d'incident
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimeTypeIncident(SecuriteSession securiteSession,
TypeIncident type
/**
* permet de modifier un type d'incident
- * @param type
- * @param libelle
* @return type le type d'incident modifié
*/
TypeIncident internalModifieTypeIncident(TypeIncident type, String libelle)
/**
* Permet de supprimer un type de punition
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimeTypePunition(SecuriteSession securiteSession,
TypePunition type
/**
* permet de modifier un type de punition
- * @param type
- * @param libelle
* @return type le type de punition modifié
*/
TypePunition internalModifieTypePunition(TypePunition type, String libelle)
/**
* Permet de supprimer un type de sanction
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimeTypeSanction(SecuriteSession securiteSession,
TypeSanction type
/**
* permet de modifier un type de sanction
- * @param type
- * @param libelle
* @return type le type de sanction modifié
*/
TypeSanction internalModifieTypeSanction(TypeSanction type, String libelle)
/**
* Permet de supprimer un lieu d'incident
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimeLieuIncident(SecuriteSession securiteSession,
LieuIncident lieu
/**
* permet de modifier un partenir à prévenir
- * @param lieu
- * @param libelle
* @return lieu le lieu d'incident modifiée
*/
LieuIncident internalModifieLieuIncident(
* vérifie les propriétés du parvenaire à prévenir
* - le nombre de caractères mpax
* - l'unicité
- * @param lieu
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Récupère les lieux d'incident
* Si aucun partenire à prévenir n'est crées, il crée ceux de par défauts
- * @param pref
* @return lieu : la liste des lieux d'incident
*/
List<LieuIncident> getLieuxIncident(
/**
* Permet de supprimer un partenaire à prévenir
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimePartenaireAPrevenir(SecuriteSession securiteSession,
PartenaireAPrevenir partenaire
/**
* permet de modifier un partenir à prévenir
- * @param partenaire
- * @param libelle
* @return partenaire le partenaire à prévenir modifiée
*/
PartenaireAPrevenir internalModifiePartenaireAPrevenir(
* vérifie les propriétés du parvenaire à prévenir
* - le nombre de caractères mpax
* - l'unicité
- * @param partenaire
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Récupère les partenaires à prévenir
* Si aucun partenire à prévenir n'est crées, il crée ceux de par défauts
- * @param pref
* @return partenaire : la liste des partenaires à prévenir
*/
List<PartenaireAPrevenir> getParteniresAPrevenir(
/**
* Permet de supprimer une qualité de protagoniste
* Vérifie les droits de suppression
- * @param securiteSession
- * @param identifiant
*/
void supprimeQualiteProtagoniste(SecuriteSession securiteSession,
QualiteProtagoniste protagoniste
/**
* permet de modifier une qualité de protagoniste
- * @param protagoniste
- * @param libelle
* @return protagoniste la qualité de protagoniste modifiée
*/
QualiteProtagoniste internalModifieQualiteProtagoniste(
* vérifie les propriétés de la qualité de protagoniste
* - le nombre de caractères mpax
* - l'unicité
- * @param protagoniste
- * @param libelle
* @throws LibelleLongException
* @throws CreationContraintException
*/
/**
* Récupère les qualités de protagoniste
* Si aucune qualité de protagoniste n'est crées, il crée celles par défauts
- * @param pref
* @return protagonistes : la liste des qualités de protagoniste
*/
List<QualiteProtagoniste> getQualitesProtagoniste(
/**
* Création d'une demande différée pour le publipostage courrier ou sms
- * @param demandeur
- * @param etablissement
- * @param params
*/
public void creeDemandeDifferee(Autorite demandeur, Etablissement etablissement, def params) {
/**
* Méthode permet de construire un nom de traitement, il est composé par
* nom de modèle et nom de classe sélectionné
- * @param params
- * @return
*/
private String construitNomDeTraitement(Map params) {
/**
* Création du document de publipostage en direct
- * @param securiteSession
- * @param etablissement
* @param demandeur : personne qui fait la demande d'impression
* @param publipostageCommand : parametre de l'impression
* @return flux contenant un fichier pdf
/**
* Détermine le type de la demande
- * @param demande
* @return : le type de fonctionnalité associé à la demande
*/
TemplateTypeFonctionnaliteEnum lectureTypeFonctionnalite(
/**
* Crée la ou les absences associées à une sanction
- * @param securiteSession
- * @param sanction
* @return une liste d'appelLigne
*/
protected void internalCreeAbsencesForSanction(Autorite operateurSaisie,
/**
* Met à jour la ou les absences associées à la sanction
- * @param securiteSession
- * @param sanction
* @return la liste des appelLigne associée à la sanction
*/
protected void internalModifieAbsencesForSanction(Autorite operateurSaisie,
/**
* Supprime les absences associées à une sanction
- * @param securiteSession
- * @param sanction
*/
public void internalSupprimeAbsencesForSanction(Sanction sanction)
throws SuppressionAbsenceContrainteException {
* Modifie les absences liées à une sanction lorsque les dates de l'absence
* ont été modifiées sur la sanction.
* Cette méthode ne vérifie pas les droits
- * @param appelLignes
- * @param sanction
*/
private void internalModifieAppelLignesForSanction(List<AppelLigne> appelLignes,
Sanction sanction,
/**
* Retourne les absences prévues pour une structure et un jour donné
- * @param structure
- * @param jour
* @return un AbsenceJourneeInfo
*/
AbsenceJourneeInfo findAbsencesJourneeForJourAndStructure(
/**
* Retourne la date et l'heure de fin de journée de l'AbsenceJournee
- * @param absenceJournee
* @return la date et l'heure de fin de journée de l'AbsenceJournee
*/
private Date calculeHeureFinDeJournee(AbsenceJournee absenceJournee) {
/**
* Retourne la date et l'heure de début de journée de l'AbsenceJournee
- * @param absenceJournee
* @return la date et l'heure de début de journée de l'AbsenceJournee
*/
private Date calculeHeureDebutDeJournee(AbsenceJournee absenceJournee) {
/**
* Indique si l'AbsenceJournee correspond au dernier jour de l'absence
* associée à la sanction
- * @param absenceJournee
- * @param sanction
* @return un Boolean
*/
private boolean isDernierJour(AbsenceJournee absenceJournee, Sanction sanction) {
/**
* Indique si l'AbsenceJournee correspond au premier jour de l'absence
* associée à la sanction
- * @param absenceJournee
- * @param sanction
* @return un Boolean
*/
private boolean isPremierJour(AbsenceJournee absenceJournee, Sanction sanction) {
* Les heures des AppelLignes ne sont pas initialisées et par consequent les
* AppelLignes ne sont pas enregistres car on ne peut pas avoir un AppelLigne
* sans Appel ou Heure de debut/fin dans la bdd.
- * @param sanction
* @return une Map[AbsenceJournee -> AppelLigne]
*/
private Map construitMapJourneeAbsences(Sanction sanction,
/**
* Supprime les appelLignes.
* Cette méthode ne vérifie pas les droits
- * @param appelLignes
*/
private void internalSupprimeAppelLignes(List<AppelLigne> appelLignes) {
if (appelLignes.size() > 0) {
/**
* Retourne la date et heure de début d'absence
- * @param appelLigne
* @return une Date
*/
private Date calculeDateDebutLigne(AppelLigne appelLigne) {
/**
* Retourne la date et heure de fin d'absence
- * @param appelLigne
* @return une Date
*/
private Date calculeDateFinLigne(AppelLigne appelLigne) {
/**
* Recherche ou crée l'absenceJournee correspondant à l'établissement
* et au jour donné.
- * @param etablissement
- * @param jour
* @return une AbsenceJournee
*/
AbsenceJournee findOrCreateAbsenceJournee(Etablissement etablissement,
/**
* Crée les lignes d'absence associées à une AbsenceJournee
- * @param absenceJournee
- * @param absenceJourneeParams
* @param numJour : le numéro du jour de la semaine
*/
private List<AbsenceJourneeLigneInfo> internalCreeLignesAbsenceJournee(
* Cette méthode :
* - ne vérifie par les droits
* - gère la concurrence de création
- * @param absenceJourneeParams
* @return l'AbsenceJournee créée
*/
private AbsenceJournee internalCreeAbsenceJournee(AbsenceJourneeParams absenceJourneeParams)
EmploiDuTempsMarshallerService emploiDuTempsMarshallerService
/**
- * @param appelEleve
- * @param sdf
* @return une Map contenant les infos d'AppelEleve pour générer un JSON
*/
public Map marshall(AppelEleve appelEleve, SimpleDateFormat sdf) {
/**
* Retourne la liste des plages horaires correspondant aux id
- * @return
*/
private List<PlageHoraire> getPlageHoraires() {
List<PlageHoraire> result = []
/**
* Crée un appel temporaire pour le mettre dans la session
- * @param securiteSession
- * @param appelACreer
* @param evenement (optionnel) événement auquel l'appel doit être lié. Si ce paramètre
* n'est pas fourni; le libelleEvt sera utilisé pour créer un nouvel événement
* @param libelleEvt utilisé uniquement si le paramètre événement est null ; dans ce cas, un
* nouvel événement sera créé
- * @return
* @throws org.lilie.services.eliot.absences.saisie.plagehoraire.PlageHoraireOccupeeException
* @throws AutorisationException
* @throws org.lilie.services.eliot.absences.saisie.plagehoraire.PlageHoraireFermeeException
/**
* Suppression de l'appel (sécurité à ajouter)
- * @param securiteSession
* @param appelId identifiant de l'appel
*/
public void supprimeAppel(SecuriteSession securiteSession, Long appelId) {
/**
* Enregistre les modifications d'une liste d'appels
- * @param securiteSession
- * @param listeAppels
- * @param appelTemporaire
- * @param pref
* @param appelModificationInfo pour infos sur la modification
- * @return
*/
List<AppelLigneCreationInfo> modifieListeAppels(SecuriteSession securiteSession,
List<AppelAvecLignesInfo> listeAppels,
* Enregistre les modifs sur un appel. Si l'appel n'existe pas encore,
* on le creer avec les parametres sauvegardes dans la session dans AppelTemporaire.
*
- * @param securiteSession
* @param appelInfo appel a modifier
* @param appelTemporaire appel temporaire sauvegarde dans la session
* @param pref preferences d'establissement
* @param appelModificationInfo pour infos sur la modification
- * @return
*/
List<AppelLigneCreationInfo> modifieAppel(SecuriteSession securiteSession,
AppelAvecLignesInfo appelInfo,
/**
* Retourne la liste des appels si l'enseignant a le droit
- * @param securiteSession
- * @param structureEnseignementId
- * @param date
- * @return
*/
public List<AppelInfo> listeAppels(SecuriteSession securiteSession,
Long structureEnseignementId,
* Lecture du dto Appel à partir de l'identifiant de l'appel (sécurité à ajouter)
* La lecture en base se fait en une requete (les dépendances appelLignes et plageHoraires sont
* "eager"
- * @param securiteSession
* @param appelId identifiant de l'appel
* @return le dto
*/
/**
* L'enseignant enseigne t'il pour la structure ?
- * @param structureEnseignement
- * @param enseignant
* @return vrai si l'enseignant enseigne pour la structure
*/
private Boolean enseignantEnseigneStructure(
/**
* Cree un appel temporaire.
* Si l'evenement auqel lier l'apel n'existe pas, on le cree.
- * @param securiteSession
* @param params parametres d'appel
* @return AppelTemporaire
*/
*
* Cette methode est publique, pour que les testes d'integration pouissent l'utiliser.
*
- * @param securiteSession
- * @param appelTemporaire
* @return appel cree
*/
Appel internalCreeAppel(AppelTemporaire appelTemporaire) {
* liste des appels lignes avec des absences journée de l'élève
* ]
* ]
- * @param appel
- * @param structure
- * @return
*/
Map getAbsencesJournesParEleve(Appel appel, StructureEnseignement structure) {
Map absencesJourneeTriees = [:]
/**
* Transforme les absences avec des absences journées en des absences avec des appel
* Utilise une seule et supprime le reste
- * @param absencesJourneeTriees
- * @param appel
*/
void modifieAbsencesJourneeEnAbsenceWithAppel(Map absencesJourneeTriees, Appel appel) {
absencesJourneeTriees.each { Autorite eleve, List<AppelLigne> lignes ->
/**
* Crée l'évènement associé au cours
- * @param structureEnseignement
- * @param libelleEvt
- * @param dateDebut
- * @param dateFin
- * @return
*/
private Evenement creeEvenementCours(StructureEnseignement structureEnseignement,
String libelleEvt,
/**
* Retourne la liste des appel ligne correspondant à la liste
* des id d'appels
- * @param appelsId
- * @return
*/
private List<AppelLigne> getListAppelLigneforAppels(List<Long> appelsId) {
List<AppelLigne> lignes = []
/**
* Retourne la liste des appels par élèves pour la liste des appels
- * @param securiteSession
- * @param structureEnseignement
- * @param dateAppel
- * @param appelsId
- * @param absenceJourneeInfo
- * @param plageHoraires
- * @param etablissementCourant
- * @param recupEmploiDuTemps
- * @return
*/
public List<AppelEleve> getLignesSaisie(SecuriteSession securiteSession,
StructureEnseignement structureEnseignement,
/**
* Vérifie la cohérence entre la structure d'enseignement et l'établissement
* courant et lève une exception en cas de problème
- * @param structureEnseignement
- * @param etablissementCourant
*/
private void verifieCoherenceStructureEtablissement(StructureEnseignement structureEnseignement,
Etablissement etablissementCourant) {
/**
* Constitue un objet contenant les informations nécessaires à l'affichage
* d'une ligne de la grille d'appel
- * @param securiteSession
* @param eleve : Elève correspondant à la grille
* @param listeAppelLigne : les lignes d'appels des appels à afficher
* @param isCpeOuDirecteur : le statut CPE ou directeur de l'utilisateur connecté
- * @param preferencesEtablissement
- * @param recupEmploiDuTemps
* @return un AppelEleve
*/
private AppelEleve creeAppelEleveInfo(SecuriteSession securiteSession,
/**
* Retourne la liste ordonnée des autorités des élèves de la structure
- * @param structureEnseignement
- * @param securiteSession
* @return une List<Autorite>
*/
private List<Autorite> getListeAutoriteEleves(
/**
* Retourne l'heure de fin d'un appel
- * @param appel
- * @return
*/
private Time getFinAppel(Appel appel, PlageHoraire plage) {
if (appel) {
/**
* Retourne la liste des plages horaires avec les informations concernant leur ouverture
* et les appels associés
- * @param securiteSession
- * @param pref
- * @param structureEnseignement
- * @param date
- * @return
*/
public List<PlageAppelInfo> getGrilleHoraire(SecuriteSession securiteSession,
PreferencesEtablissementAbsences pref,
/**
* Teste s'il y a des absences prévisionnelles sur la plage horaire
- * @param absenceJourneeInfo
- * @param plageHoraire
* @return un Boolean
*/
Boolean plagePossedeAbsencesPrev(AbsenceJourneeInfo absenceJourneeInfo,
/**
* Retourne la liste des appels du jour
- * @param date
- * @param structureEnseignement
- * @return
*/
private List<Appel> getAppelsDuJour(Date date, StructureEnseignement structureEnseignement) {
Calendar calDebutJour = Calendar.getInstance()
/**
* Récupère la liste des élèves actifs dans la classe
- * @param allIdAutorite
- * @param classe
- * @return
*/
private List findAllEleveActifDansClasse(List<Long> allIdAutorite, StructureEnseignement classe) {
/**
* Permet de créer des lignes d'appels
- * @param securiteSession
- * @param appel
- * @param motifSansMotif
- * @param allCreationLigneAppel
- * @param structure
- * @param pref
- * @return
*/
private List<AppelLigneCreationInfo> creeLignesAppels(SecuriteSession securiteSession,
Appel appel,
/**
* Fait le save sur l'AppelLigne est gère les notifications
- * @param appelLigne
- * @param flush
* @param eleve : anti N+1 select correspond à appelLigne.autorite
* @param structureEnseignement (si une seule structureEns. : anti N+1 select)
* @return l'AppelLigne enregistré
/**
* Crée une notification lorsqu'une absence sans motif est enregistrée
- * @param appelLigne
* @param persEleve // anti N+1 select : correspond à appelLigne.autorite
* @param structEnseignement // anti N+1 select
*/
}
/**
- * @param appelLigne
- * @param eleve
* @return la structure d'enseignement de l'élève ou de l'appel
*/
private getStructureForAppelLigne(AppelLigne appelLigne, Personne eleve) {
}
/**
- * @param appelLigne
* @return La date de l'absence
*/
private getDateHeureAbsence(AppelLigne appelLigne) {
/**
* Modifie une ligne existante
- * @param appel
- * @param appelLigneInfo
*/
private void modifieLigne(Appel appel,
AppelLigneInfo appelLigneInfo,
/**
* Supprime les appels lignes en paramètre
- * @param idsAppelLignes
*/
void supprimeAppelLignes(List<Long> idsAppelLignes) {
if (idsAppelLignes.size() > 0) {
/**
* Récupère l'AppelLigne et vérifie que la ligne appartient bien à l'appel
* en cours de modification
- * @param appelLigneInfo
- * @param appel
* @return une AppelLigne
*/
private AppelLigne getAppelLigne(Appel appel, AppelLigneInfo appelLigneInfo) {
/**
* Vérifie que l'élève fait bien partie de la structure
- * @param eleve
- * @param structureEnseignement
*/
void verifieAppartenanceALaStructure(
Autorite eleve,
/**
* Copie des données du dto vers AppelLigne pour la création et la modification
- * @param appel
- * @param appelLigneInfo
- * @param appelLigne
- * @param motifSansMotif
- * @return
*/
private copieAppelLigneInfoVersAppelLigne(Appel appel, AppelLigneInfo appelLigneInfo, AppelLigne appelLigne,
Motif motifSansMotif) {
/**
* Copie AppelLigne vers AppelLigneInfo (uniquement pour les types,
* commentaires et motif)
- * @param appelLigne
- * @param abstractAppelLigneInfo
*/
void copieAppelLigneVersAbstractAppelLigneInfo(
AppelLigne appelLigne,
* @param appelLignesEleve : la liste de départ
* @param eleve : l'élève dont on veut extraire les lignes
* @param isCpeOuDirecteur : fonction de celui qui consulte
- * @param securiteSession
- * @param preferencesEtablissement
* @return une liste de StatutEleveAppelInfo
*/
List<StatutEleveAppelInfo> getAppelLignesForEleve(List<AppelLigne> appelLignesEleve,
/**
* Crée un StatutEleveAppelInfo à partir des données de l'AppelLigne
- * @param appelLigne
* @return un StatutEleveAppelInfo
*/
private StatutEleveAppelInfo creeStatutEleveAppelInfo(AppelLigne appelLigne) {
/**
* Crée l'AbsenceJourneeLigneParams et l'ajoute à l'AbsenceJourneeParams
* qui correspond au jour traité
- * @param securiteSession
- * @param dateCours
- * @param saisieDateADateLigneParams
*/
private ajouteAbsence(SecuriteSession securiteSession,
Date dateCours,
AppelLigneService appelLigneService
/**
- * @param rechercherParams
* @return le résultat de la recherche pour la saisie collective
*/
RechercherResultat findRechercherResultat(RechercherParams rechercherParams) {
/**
* Enregistre la saisie d'absences collective
- * @param securiteSession
- * @param saisieCollectiveParams
* @return un CalendrierHebdo
*/
CalendrierHebdo enregistre(SecuriteSession securiteSession, SaisieCollectiveParams saisieCollectiveParams) {
/**
* Complète le calendrier hebdo en créant les lignes et les cellules qui manquent
- * @param calendrierHebdo
- * @param saisieCollectiveReferentiel
* @return le CalendrierHebdo modifié
*/
CalendrierHebdo completeCalendrierHebdo(CalendrierHebdo calendrierHebdo,
/**
* Transforme la List<AbsenceJourneeLigneInfo> en CalendrierHebdo pour le rendu
* du résultat de l'enregistrement dans la grille
- * @param absenceJourneeLigneInfos
* @return CalendrierHebdo
*/
private CalendrierHebdo getCalendrierHebdo(List<AbsenceJourneeLigneInfo> absenceJourneeLigneInfos) {
/**
* Supprime les absences existantes
- * @param saisieCollectiveParams
- * @param listeAbsenceJourneeParams
*/
private supprimeAbsencesExistantes(
SaisieCollectiveParams saisieCollectiveParams,
/**
* Crée un RechercheAbsenceExistanteParams à partir de SaisieCollectiveParams
* et List<AbsenceJourneeParams>
- * @param saisieCollectiveParams
- * @param listeAbsenceJourneeParams
* @return un RechercheAbsenceExistanteParams
*/
private RechercheAbsenceExistanteParams getRechercheAbsenceExistanteParams(SaisieCollectiveParams saisieCollectiveParams, List<AbsenceJourneeParams> listeAbsenceJourneeParams) {
* Convertit un SaisieCollectiveParams en List<AbsenceJourneeParams> pour
* pouvoir utiliser saisieHebdomadaireService pour l'enregistrement des
* absences collectives
- * @param securiteSession
- * @param saisieCollectiveParams
- * @param referentiel
* @return la liste des List<AbsenceJourneeParams> correspondant au
* SaisieCollectiveParams
*/
static transactional = true
/**
- * @param saisieDispenseParams
- * @param listeAbsenceJourneeParams
* @return la liste des AbsenceJourneeParams à enregistrer, sans les absences déjà existantes
*/
List<AbsenceJourneeParams> retireAbsencesExistantes(RechercheAbsenceExistanteParams rechercheAbsenceExistanteParams) {
}
/**
- * @param saisieDispenseParams
- * @param listeAbsenceJourneeParams
* @return la liste des AppelLigne à supprimer
*/
List<AppelLigne> findAppelLigneExistantes(RechercheAbsenceExistanteParams rechercheAbsenceExistanteParams) {
/**
* Retourne l'AbsenceJourneeParams correspondant à une date en le créant si besoin
- * @param date
* @return un AbsenceJourneeParams
*/
protected AbsenceJourneeParams getAbsenceJourneeParamsForDate(Date date, Byte numJour) {
* Vérifie les droits
* @param securiteSesion : la session courante
* @param incidentParams : les params de l'incidents
- * @return
* @throws AutorisationException
* @author bahj
*/
/**
* Permet de séparer et d'appeler les fonctions en conséquences
* sur les partenaires à supprimer et les partenaires à créer
- * @param incident
- * @param incidentParams
* @throws IncidentException
* @author bahj
*/
/**
* Vérifie la présence de doublons dans la liste des partenaires à prévenir
- * @param incident
* @return true s'il existe des doublons
*/
Boolean existeDoublonsPartenaires(Incident incident) {
/**
* Verifie si l'incident est lie aux sanctions ou punitions
- * @param incident
* @return true/false
*/
Boolean internalIsIncidentReference(Incident incident) {
LocalPersonneService localPersonneService
/**
- * @param listeIncidentsInfo
* @return une map associant à un id externe, le nom d'affichage d'une autorité
*/
public Map getNomsAffichageByIdExterne(ListeIncidentsInfo listeIncidentsInfo) {
/**
* Retourne l'IncidentConsultationInfo correspondant à l'incident
- * @param incident
* @return un IncidentConsultationInfo
* @author jbui
*/
/**
* Formate une date et un heure pour
- * @param date
* @return la date et l'heure au format dd/mm/yyyy hh:mm
*/
private String formateDateHeure(Date date) {
/**
* Supprime un partenaire à prévenir
- * @param partenaire
* @author jbui
*/
void supprimePartenaireAPrevenirIncident(Incident incident,
/**
* Vérifie que le PartenaireAPrevenirIncident est bon pour être enregistré
- * @param partenaireAPrevenirIncident
*/
private void verifiePartenaireAPrevenirIncident(PartenaireAPrevenirIncident
partenaireAPrevenirIncident
/**
* Modifie une liste de protagonistes
- * @param protagonistes
* @return une List<ProtagonisteIncident>
*/
List<ProtagonisteIncident> modifieProtagonisteIncidents(
/**
* Supprime une liste de protagonistes
- * @param protagonistes
* @author jbui
*/
void supprimeProtagonisteIncidents(Incident incident,
/**
* Vérifie que le protagoniste est apte à être enregistré
- * @param protagonisteIncident
*/
private void verifieProtagonisteIncident(ProtagonisteIncident protagonisteIncident
) throws ProtagonisteIncidentException {
/**
* Crée une nouvelle punition en vérifiant les droits
- * @param securiteSession
- * @param PunitionParams
* @return une Punition
*/
Punition creePunition(SecuriteSession securiteSession,
/**
* Modifie une punition existante en vérifiant les droits
- * @param securiteSession
* @param punitionAModifier : l'objet du domaine à modifier
* @param punitionParams : les nouvelles données de la punition
* @return la Punition
/**
* Supprime une punition en vérifiant les droits
- * @param punitionASupprimer
* @throws AutorisationException
* @throws PunitionException
*/
/**
* Supprime la punition.
* Ne fait pas de vérification de droits
- * @param punition
*/
void internalSupprimePunition(Punition punition)
throws PunitionException {
/**
* Supprime les punitions d'un incident
- * @param incident
* @throws PunitionException
*/
public void internalSupprimePunitions(Incident incident) throws
/**
* Procède à l'enregistrement en base.
* Ne fait de vérification de droits
- * @param punition
* @throws PunitionException
*/
@SuppressWarnings('CatchException')
/**
* Retourne une liste de punitions selon les critères
- * @param securiteSession
* @param personne qui fait la requête
- * @param etablissement
- * @param champOrdre
- * @param ascendant
- * @param start
- * @param limit
* @return un PunitionListeInfo
*/
Map findPunitions(SecuriteSession securiteSession,
/**
* Crée une nouvelle sanction
* Vérifie les droits
- * @param securiteSession
- * @param sanctionParams
* @return la sanction crée
* @throws AutorisationException
* @throws SanctionException
/**
* Permet de modifier une sanction
* Vérifie les droits
- * @param securiteSesion
- * @param sanctionAModiier
- * @param sanctionPaams
* @rern
* @throws AutorisationException
* @throws SanctionException
/**
* Permet de supprimer une sanction
* vérife les droits
- * @param securiteSession
- * @param sanction
* @throws AutorisationException
*
*/
/**
* Supprime les sanctions d'un incident
- * @param incident
* @throws SanctionException
*/
public void internalSupprimeSanctions(SecuriteSession securiteSession,
/**
* Récupère la liste des sanctions correspandant aux critères
- * @param securiteSession
- * @param personne
* @param etablissement : l'établissement dont on veut les sanctions
* @param champOrdre : l'ordre de classement des sanctions
* @param ascendant : indique si le classement est croissant
/**
* Liste des sanctions associées à une personne
- * @param securiteSession
- * @param etablissement
- * @param personne
- * @return
*/
public Map findAllSanctionParPersonne(SecuriteSession securiteSession, // TOREFACT : créer une classe pour le type de retour de cette méthode
Etablissement etablissement,
/**
* Procède à l'enregistrement en base de la sanction.
* Ne fait de vérification de droits
- * @param sanction
*/
@SuppressWarnings('CatchException')
private void internalSave(Sanction sanction) throws SanctionException {
/**
* Supprime les absences existantes pour la période et l'élève de la sanction
* afin de pouvoir créer une absence associée à la sanction
- * @param sanction
*/
void internalSupprimeAbsencesExistantes(Sanction sanction) {
if (sanction.debutAbsence && sanction.finAbsence) {
}
/**
- * @param plageHoraire
- * @param numeroJour
* @return la cellule correspondant à la plage et au n° de jour
*/
CalendrierDispenseCellule getCellule(PlageHoraire plageHoraire, Byte numeroJour) {
}
/**
- * @param plageHoraire
* @return la ligne correspondant à la plage horaire
*/
private CalendrierDispenseLigne getLigne(PlageHoraire plageHoraire) {
/**
* Crée l'AbsenceJourneeLigneParams et l'ajoute à l'AbsenceJourneeParams
* qui correspond au jour traité
- * @param securiteSession
- * @param dateCours
- * @param saisieDateADateLigneParams
*/
private ajouteAbsence(SecuriteSession securiteSession,
Date dateCours,
RechercheAbsenceExistanteService rechercheAbsenceExistanteService
/**
- * @param eleve
- * @param classe
- * @param dateDebut
- * @param dateFin
* @return les infos du calendrier hebdo pour la saisie des dispenses
*/
CalendrierDispense findDispensesInfoForEleveAndPeriode(SecuriteSession securiteSession,
/**
*
- * @param securiteSession
- * @param saisieDispenseParams
*/
void enregistre(SecuriteSession securiteSession, SaisieDispenseParams saisieDispenseParams) {
SaisieDispenseReferentiel referentiel = saisieDispenseReferentielService.creeReferentiel(
}
/**
- * @param calendrierDispense
- * @param referentiel
* @return List < AbsenceJourneeParams >
*/
private List<AbsenceJourneeParams> getListeAbsenceJourneeParams(SecuriteSession securiteSession,
}
/**
- * @param referentiel
* @return le CalendrierDispense à partir des données du référentiel
*/
private CalendrierDispense calculeCalendrierDispenses(SaisieDispenseReferentiel referentiel) {
/**
* Indique s'il existe un jour ouvert pour la plage et la période donnée
- * @param jourSemaine
- * @param plageHoraire
- * @param referentiel
* @return true s'il en existe au moins un
*/
private Boolean existeJourNonFerie(Byte jourSemaine,
static transactional = true
/**
- * @param dateDebut
- * @param dateFin
- * @param classe
- * @param securiteSession
- * @param eleve
- * @param matiere
* @return un Referentiel pour le calcul
*/
SaisieDispenseReferentiel creeReferentiel(SecuriteSession securiteSession,
class EmploiDuTempsMarshallerService {
/**
- * @param emploiDuTemps
- * @param sdf
* @return une Map contenant les infos d'emploi du temps pour le JSON
*/
public Map marshall(EmploiDuTemps emploiDuTemps, SimpleDateFormat sdf) {
}
/**
- * @param plageHoraire
- * @param numeroJour
* @return la cellule correspondant à la plage et au n° de jour
*/
CalendrierHebdoCellule getCellule(PlageHoraire plageHoraire, Byte numeroJour) {
}
/**
- * @param plageHoraire
* @return Retourne ou crée si besoin la ligne correspondant à la plage horaire
*/
CalendrierHebdoLigne findOrCreateLigne(PlageHoraire plageHoraire) {
EmploiDuTempsMarshallerService emploiDuTempsMarshallerService
/**
- * @param ligneCalendrier
- * @param sdf
* @return une Map contenant les infos de la ligneCalendrier pour
* générer du JSON
*/
/**
* Retourne sous la forme d'une map les informations de l'AppelLigne
- * @param appelLigne
* @return une Map
*/
private Map getInfosAbsence(AppelLigne appelLigne,
/**
* Enregistre les données de la saisie hebdomadaire
- * @param securiteSession
- * @param absenceJournees
- * @return une List<AbsenceJourneeLigneInfo>
+ * @return une List<AbsenceJourneeLigneInfo>
*/
List<AbsenceJourneeLigneInfo> enregistreSaisieHebdo(
SecuriteSession securiteSession,
/**
* Récupère en base les données d'absences de l'élève associées à une
* AbsenceJournee
- * @param eleve
- * @param dateDebut
- * @param dateFin
- * @return
*/
private List<AppelLigne> findAbsencesJourneesForEleveAndPeriode(Personne eleve,
Date dateDebut,
/**
* Récupère en base les données d'absences de l'élève associées à un appel
- * @param eleve
- * @param dateDebut
- * @param dateFin
* @return une liste d'AppelLigne
*/
private List<AppelLigne> findAbsencesAppelsForEleveAndPeriode(Personne eleve,
/**
* Cherche en base les appels effectués pour la période et la classe
- * @param classe
- * @param dateDebut
- * @param dateFin
* @return une liste de liste contenant :
* - id de la plage horaire
* - id de l'appel
/**
* Constitue la grille à partir de la liste des plages horaires et des
* données d'absences de l'élève
- * @param plageHoraires
- * @param appelDatas
* @return une liste de Map
*/
private CalendrierHebdo creeGrilleAbsencesInfos(Calendrier calendrier,
/**
* Traite un jour du plage horaire
- * @param plageGrille
* @param jour numero du jour (1..7)
- * @param plageHoraire
- * @param dateDebut
- * @param sdf
- * @param jourFeries
- * @param calendrier
- * @param appelDatas
- * @param absencesAppels
- * @param absencesJournees
*/
private CalendrierHebdoCellule traiteUnJour(Integer jour,
PlageHoraire plageHoraire,
}
/**
- * @param appelId
- * @param absencesAppels
- * @param dateDebut
- * @param jour
- * @param plageHoraire
- * @param absencesJournees
* @return l'Appel correspondant aux critères
*/
private AppelLigne findAppelLigne(Long appelId,
}
/**
- * @param jour
- * @param calendrier
- * @param dateDebut
- * @param jourFeries
- * @param plageHoraire
* @return true si la plage horaire est ouverte
*/
private boolean isPlageOuverte(int jour,
/**
* Recherche un AppelLigne sur les autres appels
- * @param appelLignes
- * @param date
- * @param plageHoraire
* @return AppelLigne
*/
private AppelLigne getAppelLigneForJourAndPlage(List<AppelLigne> appelLignes,
/**
* Retourne la liste des identifiants des plages horaires
* de l'appel classées par la date de début
- * @param appelId
- * @return
*/
List<PlageHoraire> getPlagesHorairesForAppelId(Long appelId) {
List<PlageHoraire> resultats =
/**
* Crée les données pour les stats sur les niveaux
- * @param statsMensuelles
- * @return
*/
List marshallStatsNiveau(StatsMensuelles statsMensuelles) {
List result = []
/**
* Crée les données pour les stats sur les structures
- * @param statsMensuelles
* @return une List pour le JSON
*/
private List marshallStatsEleve(StatsMensuelles statsMensuelles) {
/**
* Crée les données pour les stats sur les structures
- * @param statsMensuelles
* @return une List pour le JSON
*/
private List marshallStatsStructure(StatsMensuelles statsMensuelles) {
}
/**
- * @param mois
- * @param tableauStatsMensuelles
* @return Les lignes du tableau de stats mensuelles
*/
Map marshallListeMois(List<Mois> mois,
/**
* Permet de parser des objets
* @author bahj
- * @param data
- * @return
*/
List<Map> marshallDataForJSON(List data) {
List<Map> resultats = []
/**
* Prépare les lignes du resultat en fonction du seuil demandé
* @param pref : les prerencesEtablissement courantes
- * @param tableauDeBordParams
* @return un TableauDeBord
*/
TableauDeBord prepareResultSetAvecSeuil(PreferencesEtablissementAbsences pref,
/**
* Retourne la liste des ids d'élèves, classée par le critère
- * @param autoriteEleveIds
- * @param criteres
* @return une Liste d'id d'élèves
*/
private List<Long> ordonneEleves(List<Long> autoriteEleveIds,
/**
* Sélectionne les élèves dépassant le seuil demandé
- * @param countParEleve
- * @param tableauDeBordParams
- * @return
*/
private List<Long> getSelectionEleveIds(Map countParEleve, TableauDeBordParams tableauDeBordParams) {
List<Long> eleveIds = []
/**
* Retourne la liste (totale) des élèves en fonction des params de recherche
- * @param tableauDeBordParams
* @return une liste d'autorités
*/
private List<Autorite> findListeEleves(TableauDeBordParams tableauDeBordParams) {
/**
* Retourne le type d'absences à compter en fonction des params de recherche
- * @param tableauDeBordParams
- * @return un TypeAbsencesACompterEnum
+ * @return un TypeAbsencesACompterEnum
*/
private TypeAbsencesACompterEnum getTypeAbsencesACompter(TableauDeBordParams tableauDeBordParams) {
TypeAbsencesACompterEnum typeACompter
/**
* Compte le nombre d'absence à l'internat ou à la demi pension selon le flag,
* sur la période et pour la liste de structures
- * @param criteres
* @return un entier
*/
Integer calculeTotalDemiPensionOrInternat(TableauDeBordParams criteres,
* Retourne le nombre d'absences à la demi-pension ou à l'internat en
* fonction des critères (dates et classes)
* @param criteres : les critères
- * @param isDemiPension
* @return un Integer
*/
private Integer calculeTotalDemiPensionOrInternatForCriteres(TableauDeBordParams criteres, boolean isDemiPension) {
/**
* Compte le nombre d'absences à l'internat
- * @param tableauDeBordParams
- * @param criteres
*/
void calculeLignesAbsencesInternat(TableauDeBordParams criteres,
TableauDeBord tableauDeBord
/**
* Compte le nombre d'absences à la demi-pension
- * @param tableauDeBordParams
- * @param criteres
*/
void calculeLignesAbsencesDemiPension(TableauDeBordParams criteres,
TableauDeBord tableauDeBord
/**
* Compte le nombre de départs anticipés sur la période et pour la liste de structures
- * @param criteres
* @return un entier
*/
Integer calculeTotalDepart(TableauDeBordParams criteres,
/**
* Compte le nombre de départs anticipés
- * @param tableauDeBordParams
- * @param criteres
*/
void calculeLignesAbsencesDepart(TableauDeBordParams criteres,
TableauDeBord tableauDeBord) {
class TableauDeBordPunitionService {
/**
* Compte le nombre de punitions sur la période et pour la liste de structures
- * @param criteres
* @return un entier
*/
Integer calculeTotalPunition(TableauDeBordParams criteres,
/**
* Calcule le nombre de punitions en fonction des critères (dates) et de la
* liste des élèves
- * @param criteres
- * @param tableauDeBord
- * @return
*/
private Integer calculeTotalPunitionForEleves(TableauDeBordParams criteres,
TableauDeBord tableauDeBord) {
/**
* Prépare les lignes du résultat en fonction du seuil demandé
- * @param criteres
- * @return
*/
TableauDeBord prepareResultSetAvecSeuil(TableauDeBordParams criteres) {
TableauDeBord result = new TableauDeBord()
/**
* Calcule le nombre total de lignes sans tenir compte de la pagination
- * @param criteres
* @return un Long
*/
Long calculeCount(TableauDeBordParams criteres) {
/**
* Retourne les données pour la page demandée
- * @param criteres
* @return List < TableauDeBordLigne >
*/
List<TableauDeBordLigne> prepareLignes(TableauDeBordParams criteres) {
/**
* Prépare les lignes du résultat en fonction du seuil demandé
- * @param criteres
- * @return
*/
TableauDeBord prepareResultSetAvecSeuil(TableauDeBordParams criteres,
Byte typeAbsence) {
/**
* Retourne le nombre total d'élèves sélectionnés
- * @param criteres
* @return un Long
*/
Long calculeCount(TableauDeBordParams criteres, Byte typeAbsence) {
/**
* Retourne les ligens (vides) du tableau de bord pour la page courante
- * @param criteres
* @return List < TableauDeBordLigne >
*/
private List<TableauDeBordLigne> prepareLignes(TableauDeBordParams criteres,
/**
* Construit la chaine hql pour la récupération des données d'absences
* selon le type recherché
- * @param typeAbsence
* @return une String hql
*/
private String construitHqlLignes(byte typeAbsence) {
/**
* Construit la restriction hql en fonction du type d'absences à gérer
- * @param typeAbsence
* @return un String
*/
private String getRestrictionHqlForTypeAbsence(Byte typeAbsence) {
/**
* Compte le nombre de retards sur la période et pour la liste de structures
- * @param criteres
* @return un entier
*/
Integer calculeTotalRetard(TableauDeBordParams criteres,
/**
* Calcule le nombre de retard en fonction des critères (structures + dates)
- * @param criteres
* @return un Integer
*/
private Integer calculeTotalRetardForCriteres(TableauDeBordParams criteres) {
/**
* Compte le nombre de retards
- * @param tableauDeBordParams
- * @param criteres
*/
void calculeLignesAbsencesRetard(TableauDeBordParams criteres,
TableauDeBord tableauDeBord
class TableauDeBordSanctionService {
/**
* Compte le nombre de sanctions sur la période et pour la liste de structures
- * @param criteres
- * @return
*/
Integer calculeTotalSanction(TableauDeBordParams criteres,
TableauDeBord tableauDeBord) {
/**
* Prépare les lignes du résultat en fonction du seuil demandé
- * @param criteres
- * @return
*/
TableauDeBord prepareResultSetAvecSeuil(TableauDeBordParams criteres) {
TableauDeBord result = new TableauDeBord()
/**
* Calcule le nombre total de lignes sans tenir compte de la pagination
- * @param criteres
* @return un Long
*/
Long calculeCount(TableauDeBordParams criteres) {
/**
* Retourne les données pour la page demandée
- * @param criteres
* @return List<TableauDeBordLigne>
*/
List<TableauDeBordLigne> prepareLignes(TableauDeBordParams criteres) {
/**
* Prépare le resultSet en le remplissant des lignes à complêter et du
* nombre total de lignes
- * @param tableauDeBordParams
- * @return
*/
TableauDeBord prepareResultSetAvecSeuil(PreferencesEtablissementAbsences pref,
TableauDeBordParams tableauDeBordParams) {
/**
* Crée les lignes du tableau de bord (une par élève)
- * @param criteres
* @return une List<TableauDeBordLigne>
*/
private List<TableauDeBordLigne> creeLignesTableau(TableauDeBordParams criteres) {
/**
* Retourne une AbsenceJournee pour l'établissement 1 et pour le 01/10/2009
- * @return
*/
AbsenceJournee getAbsenceJournee1() {
return creeAbsenceJournee(Date.parse('01/10/2009', 'dd/MM/yyyy'))
/**
* Retourne une AbsenceJournee pour l'établissement 1 et pour le 02/10/2009
- * @return
*/
AbsenceJournee getAbsenceJournee2() {
return creeAbsenceJournee(Date.parse('02/10/2009', 'dd/MM/yyyy'))
/**
* Retourne une AbsenceJournee pour l'établissement 1 et pour le 03/10/2009
- * @return
*/
AbsenceJournee getAbsenceJournee3() {
return creeAbsenceJournee(Date.parse('03/10/2009', 'dd/MM/yyyy'))
/**
* Retourne une AbsenceJournee pour l'établissement 1 et pour le 04/10/2009
- * @return
*/
AbsenceJournee getAbsenceJournee4() {
return creeAbsenceJournee(Date.parse('04/10/2009', 'dd/MM/yyyy'))
* - ELEVE_3_CLASSE_1 : présent
* - ELEVE_4_CLASSE_1 : en retard
* - ELEVE_5_CLASSE_1 : absent motif 1 non valable
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel5(PreferencesEtablissementAbsences pref) {
* - ELEVE_3_CLASSE_1 : présent
* - ELEVE_4_CLASSE_1 : présent
* - ELEVE_5_CLASSE_1 : présent
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel6(PreferencesEtablissementAbsences pref) {
* - ELEVE_3_CLASSE_1 : absent sans motif
* - ELEVE_4_CLASSE_1 : retard
* - ELEVE_5_CLASSE_1 : présent
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel7(PreferencesEtablissementAbsences pref) {
* - ELEVE_3_CLASSE_1 : absent motif1
* - ELEVE_4_CLASSE_1 : retard
* - ELEVE_5_CLASSE_1 : absent sans motif non valable
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel8(PreferencesEtablissementAbsences pref) {
* - ELEVE_3_CLASSE_1 : présent
* - ELEVE_4_CLASSE_1 : retard
* - ELEVE_5_CLASSE_1 : présent
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel9(PreferencesEtablissementAbsences pref) {
* - ELEVE_3_CLASSE_1 : absent sans motif
* - ELEVE_4_CLASSE_1 : présent
* - ELEVE_5_CLASSE_1 : absent motif1 non valable
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel10(PreferencesEtablissementAbsences pref) {
* Crée un appel au 10/09/2010, de 20:00 à 21:55 (PM) avec :
* - ELEVE_1_CLASSE_1 : retard
* - ELEVE_2_CLASSE_1 : RETARD
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppelWithRetard(PreferencesEtablissementAbsences pref) {
* Crée un appel au 10/09/2010, de 20:00 à 21:55 (PM) avec :
* - ELEVE_1_CLASSE_1 : absent non excusé
* - ELEVE_2_CLASSE_1 : absent excusé
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppelWithAbsences(PreferencesEtablissementAbsences pref) {
/**
* Crée un appel au 09/09/2010, de 04:00 à 04:55 avec :
* - ELEVE_2_CLASSE_1 : absent, motif 1
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel15(PreferencesEtablissementAbsences pref) {
/**
* Crée un appel au 10/09/2010, de 04:00 à 05:55 (2 plages) avec :
* - ELEVE_2_CLASSE_1 : absent, motif 2
- * @param pref
* @return l'id de l'appel créé
*/
Long creeAppel16(PreferencesEtablissementAbsences pref) {
/**
* Cree un appel
- * @param securiteSession
- * @param appelInfo
- * @return
*/
private Appel creeAppel(SecuriteSession securiteSession, AppelInfo appelInfo) {
AppelTemporaire appelTemporaire = appelService.creeAppelTemporaire(securiteSession, appelInfo)
/**
* Crée un incident avec 2 protagonistes sur la classe 1 et 1 sur la classe_1_2
- * @return
*/
Incident getIncident_3_protagonistes_classe_1_et_classe_1_2() {
SecuriteSession securiteSession = getSecuriteSession(
/**
* Retourne le nombre de minutes depuis 0:00 jusqu'à l'heure passée
- * @param heure
* @param cal : Calendar pouvant être passé pour éviter son instanciation
* @return un nombre de minutes
*/
/**
* Crée plusieurs incidents dans la base
- * @return
*/
private def creeListeIncidents() {
IncidentParams incidentParams1 = new IncidentParams(
/**
* Cree un appel a une date specifique
- * @param date
*/
private void creeAppelAUneDate(Date date) {
AppelInfo appelInfo = initDonneesCommunesTestAbsenceService.getAppelInfo1()
/**
* Cree un appel
- * @param securiteSession
- * @param appelInfo
- * @return
*/
private Appel creeAppel(SecuriteSession securiteSession, AppelInfo appelInfo) {
appelTemporaire = appelService.creeAppelTemporaire(securiteSession, appelInfo)
/**
* Recupere bilan pour un eleve et une periode donnee
- * @param acteurDir
- * @param acteurEleve
- * @param dateDabut
- * @param dateFin
- * @param priseEnCompteMotif
- * @return
*/
private Map getBilan(PopulationTestActeur acteurDir,
PopulationTestActeur acteurEleve,
/**
* Indique si un élève est contenu dans le TableauDeBord
- * @param eleve
- * @param tdb
* @return un Boolean
*/
private boolean isEleveDansTdb(PopulationTestActeur eleve, TableauDeBord tdb) {
/**
* Cree un appel
- * @param securiteSession
- * @param appelInfo
- * @return
*/
private Appel creeAppel(SecuriteSession securiteSession, AppelInfo appelInfo,
Evenement evenement,
\r
/**\r
* Verifie les absences fusionees\r
- * @param absences\r
*/\r
void verifieAbsences(List<EleveImpressionInfo> infos) {\r
\r
/**
* Indique s'il s'agit d'un agenda partagé
- * @param agenda
- * @return
*/
private Boolean estAgendaPartage(Agenda agenda) {
Boolean isAgendaPartage = false
/**
* Construit un agenda information pour la vue
* Si les préférences ne sont pas crées, il sont crées
- * @param agenda
* @return agendaInfo agenda info de l'agenda en paramètre
*
*/
/**
* Transforme les agendas personnalisé en des agendas info pour la vue
- * @param securiteSession
- * @param allAgendaPersonnalise
- * @return
*/
private List<AgendaInfo> getAgendaInfo(
Collection<AgendaPersonnalise> allAgendaPersonnalise,
* Formate un objet AgendaEvenementInfo pour le formulaire de propriétés des événements
* Remarque : différent de la méthode formateAgendaEvenementInfoForStore qui permet de
* formater un objet AgendaEvenementInfo pour le store JSON
- * @param eventInfo
* @return result
*/
private Map formateAgendaEvenementInfoForForm(AgendaEvenementInfo eventInfo) {
/**
* Parse les ressources de l'activité
* @param ressources liste des ressources
- * @return
*/
private List parseRessources(SecuriteSession securiteSession,
List<Ressource> ressources) {
/**
* Construit le lien de la ressource suivant si c'est un fichier une url
* ou un lien vers un document du catalogue
- * @param ressource
- * @return
*/
private String getLienFromRessource(SecuriteSession securiteSession, Ressource ressource) {
String lien = ''
* Etablissement du cahier.
* Si le cahier est attache a un etablissement, on le prend,
* sinon on prend l'etablissement courant.
- * @param cahierDeTextes
- * @return
*/
private Etablissement getEtablissementDuCDT(CahierDeTextes cahierDeTextes) {
return cahierDeTextes.findEtablissement() ?: etablissementCourant()
/**
* Indique si la personne est propriétaire de l'agenda
- * @return
*/
public boolean isProprietaire() {
allAutorisation.any {
/**
* Indique si le propriétaire de l'agenda va être supprimé
- * @return
*/
boolean isProprietaireAAccesRestreint() {
autoriteProprietaire?.aUnAccesRetreint()
/**
* Retourne les agendaPersonnalise de la session après avoir generer
* les préférences utilisateur agenda et trié par type et par nom
- * @param securiteSession
- * @return
*/
public Map<String, List<AgendaPersonnalise>> getAllAgendaPersonnalise(
SecuriteSession securiteSession
/**
* Crée des préférences par défaut pour l'utilisateur et l'agenda
- * @param securiteSession
- * @param allAgendaPersonnalises
- * @return
*/
private PreferencesUtilisateurAgenda getPreferencesUtilisateur(
SecuriteSession securiteSession,
* Si aucune préférence, création des préférences par défauts
* @param nom nom de l'agenda
* @param description description de l'agenda
- * @param structureEnseignement
* @param type type de l'agenda
* @param securiteSession session courante
* @param preferencesAgenda objet map qui peut contenir les champs suivants:
/**
* Construit un agendaInfo
- * @param agenda
* @param preferences : les preferences de l'utilisateur sur l'agenda
* @param session : la session courante
* @return agendaInfo : l'agenda information construit
/**
* retourne les préférences de l'utilisateur si elle existe
* sinon crée les préférences avec des valeur par défaut
- * @param agenda
* @param securiteSession : la session en cours
* @param forceCreationPreferences : flag indiquant si il faut forcer la création
* @return preference : la preférence créee
class MenuAideAgendaService extends MenuAideService {
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.agenda.aideEnLigne.url
* Retourne les information de construction du menu
* @param pageCourante la page courante
* @param securiteSession la session de sécurité Eliot de l'utilisateur
- * @return
*/
MenuInfo getMenuInfo(SecuriteSession securiteSession) {
/**
* Exécution transactionnelle
- * @param closure
*/
//jbui: On catche le plus large possible
@SuppressWarnings('CatchException')
/**
* Convertion d'un fichier vers une map
- * @param label
- * @param fichier
- * @param iconFileName
*/
private Map fichierToMap(String label, Fichier fichier, String iconFileName) {
return [
/**
* Ajout les groupes étendus à la liste json
- * @param session
- * @param jsonArbre
- * @return
*/
private void ajouterGroupesEtendus(SecuriteSession session, List jsonArbre) {
* la page de création
* @param dossierParent : dossier parent du fichier
* @param nomFichier : nom logique du fichier
- * @param description
- * @param parentId
- * @param organisationId
* @param partage : indique si on crée un fichier partagé ou pas
*/
private void traiteErreursAjoutFichier(Fichier dossierParent,
* le fichier ?
* @param isDossier : s'agit-il d'un dossier
* @param autoriteEncodee : autorité encodée de l'auteur
- * @return
*/
private String getIconCssClass(boolean isDossier, String autoriteEncodee) {
* Recherche un dossier par rapport à une organisation et un id de dossier
* Si le dossier recherché correspond à celui passé en paramètre, alors
* on le retourne
- * @param organisationId
- * @param nodeId
* @param dossierEspace dossier retourné si nodeId est celui de ce dossier
- * @return
*/
private Dossier findDossierByNodeId(String organisationId, String nodeId, Dossier dossierEspace) {
Dossier dossier
/**
* a ton accès aux permissions sur le fichier dans la session courante ?
- * @param fichier
- * @return
*/
private Boolean accesAuxPermissionsEstBloquee(Fichier fichier) {
/**
* Gère l'enregistrement du fichier dans la base
- * @param securiteSession
* @param fichier : fichier uploadé
* @param nom : nom logique du fichier
- * @param description
- * @param dossierParent
* @param partage : indique si le document est partagé
* @return un Document
*/
/**
* Vérifie que le nom du fichier est correcte et disponible
- * @param securiteSession
* @param nom : nom du fichier
* @param dossierParent : dossier de destination du fichier
*/
/**
* Vérifie si les fichiers existent déjà
- * @param securiteSession
- * @param orgId
- * @param fichierId
- * @param listeNomFichiers
- * @return
*/
public boolean fichierExiste(SecuriteSession securiteSession,
String orgId,
/**
* Bascule l'espace de partage d'une organisation
- * @param noeudOrganisation
- * @param rapport
*/
private void basculeOrganisation(Node noeudOrganisation,
DocsBasculeAnneeRapport rapport) {
/**
* Bascule les fichiers contenu dans un dossier
- * @param noeudDossier
- * @param rapport
*/
private void basculeContenuDossier(Node noeudDossier,
DocsBasculeAnneeRapport rapport) {
/**
* Bascule un fichier
- * @param noeudFichier
- * @param rapport
*/
private void basculeFichier(Node noeudFichier,
DocsBasculeAnneeRapport rapport) {
/**
* Réinitialise les permissions d'un fichier
- * @param noeud
- * @param rapport
*/
private void reinitialisePermissions(Node noeud) {
try {
/**
* Teste si un noeud JCR correspond à la racine d'une organisation
* Note jtra: A déplacer dans l'API eliot-docs-commons
- * @param node
* @return true si le noeud correspond à la racine d'une organisation, false
* sinon
*/
/**
* Teste si un noeud JCR correspond à un dossier
* Note jtra: A déplacer dans l'API eliot-docs-commons
- * @param node
* @return true si le noeud est un dossier, false sinon
*/
private boolean estDossier(Node node) {
/**
* Vérifie que la securiteSession correspond au Correspondant de Deploiement
* et retourne une securiteSession de type Eliot (systeme)
- * @param securiteSession
* @return SecuriteSession - ecuriteSession de type Eliot
* @throws AutorisationException
* @author bper
/**
* Permet de savoir si un groupe est un groupe d'enseignement ou pas
- * @param idExterne
- * @return
*/
public Boolean isGroupeEnseignement(String idExterne) {
if (!cache) {
class MenuAideDocsService extends MenuAideService {
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.docs.aideEnLigne.url
/**
* Indique s'il s'agit d'un noeud eliot
- * @param node
- * @return
*/
private boolean isNoeudEliot(javax.jcr.Node node) {
/**
* Générateur de l'arbre descriptif du dépot
- * @param html
- * @param noeud
- * @return
*/
private String nodeToHtml(String html, Node noeud) {
Iterator iterator = noeud.getNodes()
/**
* Retourne l'entête d'un descriptif de noeud
- * @return
*/
private String tableHTMLHeader() {
return '<<TABLE CELLPADDING="0" BORDER="0" CELLSPACING="0">'
/**
* retourne le pied d'un descriptif de noeud
- * @return
*/
private String tableHTMLFooter() {
return "</TABLE>>"
* @param name : nom de la valeur (propriété)
* @param value : valeur de la propriété
* @param color : couleur du nom
- * @return
*/
private String addPropertie(String data, String name, String value, String color = "blue") {
/**
* Ajoute un titre
- * @param data
- * @param name
- * @param color
- * @return
*/
private String addTitle(String data, String name, String color = "red") {
/**
* Dessin graphique du noeud
- * @param schemaDot
- * @param node
- * @param parentName
*/
private void dessineNoeud(SchemaDot schemaDot, Node node, String parentName) {
/**
* Lecture des types des noeuds
- * @param node
- * @return
*/
private String lectureType(String data, Node node) {
* @param data : données html du noeud
* @param node : noeud
* @param nomProp : nom de la propriété
- * @return
*/
private String addPropType(String data, Node node, String nomProp) {
Property property = node.getProperty(
/**
* Lecture d'un propriétés en particulier
- * @param node
- * @param nomProp
- * @return
*/
@SuppressWarnings('CatchException') // JTRA: On veut sortir le maximum d'information d'un repository même si la lecture des certains noeuds lève des exception
private String lecturePropriete(String data, Node node, String nomProp) {
/**
* Construction d'un fichier dot à partir du dépot (mime : text/vnd.graphviz)
- * @param securiteSession
- * @param repository
- * @return
*/
public String createDotFile(SecuriteSession securiteSession, Repository repository, Integer profondeur = 0, Integer profondeurMax = 0) {
/**
* Retourne un idHtml qui identifie un fichier à partir de l'id propre du
* fichier et de l'id de l'organisation
- * @param organisationId
- * @param fichierId
- * @return
*/
public static String genereIdComplet(String organisationId, String fichierId) {
return "ORG$organisationId-FIC$fichierId"
/**
* Retourne l'id de l'organisation associée à l'id complet d'un fichier
- * @param idComplet
- * @return
*/
public static String getOrganisationIdFromIdComplet(String idComplet) {
Matcher m = idComplet =~ PATTERN
/**
* Retourne l'id propre d'un fichier associé à l'id complet d'un fichier
- * @param idComplet
- * @return
*/
public static String getFichierIdFromIdComplet(String idComplet) {
Matcher m = idComplet =~ PATTERN
/**
* Retourne le contenu d'un message sans les scripts inclus
* (anti cross site scripting)
- * @param message
- * @return
*/
private String contenuSansXSS(Message message) {
String ANTI_XSS_REGEX = "\\<script\\s?.*?\\>(.|\\r\\n)+?\\<\\/(no)?script\\>"
/**
* Méthode HTTP GET
* URI: <api-rest>/configuration/<organisationId>/<variableId>?
- * @return
* - Si variableId => la valeur de cette variable
* - Sinon => la Map contenant toutes les variables de configuration de
* l'organisation
/**
* Deplacer des messages vers un dossier
- * @param securiteSession
* @param deplacementParams : les paramètres de déplacement
*/
def deplacerMessagesDansDossier(SecuriteSession securiteSession,
/**
* Ajoute un lien entre un MessageLecteur et un DossierMessage
- * @param dossierCible
- * @param unMessageLecteur
*/
private void addMessageLecteurToDossier(DossierMessage dossierCible, MessageLecteur unMessageLecteur) {
dossierCible.addToDossierMessageLecteurs(new DossierMessageLecteur(
/**
* Enlève le message lecteur de son dossier utilisateur
- * @param messageLecteur
*/
private void removeMessageFromAllDossiers(MessageLecteur messageLecteur) {
List<DossierMessage> listeASupprimer = DossierMessageLecteur.
/**
* Supprime le lien entre un MessageLecteur et un DossierMessage
- * @param monMessageLecteur
- * @param dossierUtilisateur
*/
private void removeMessageLecteurFromDossier(MessageLecteur monMessageLecteur, DossierMessage dossierUtilisateur) {
DossierMessageLecteur.findAllByMessageLecteurAndDossier(
/**
* Envoie la notification à ces destinataires
- * @param notification
*/
def notifieDestinataires(Notification notification) {
// TOIMP : notifie destinataires
/**
* Réalise re-indexation des messages, la suppression des autorités
* des groupes destinataires et historisation des destinataires.
- * @param securiteSession
- * @param basculeAnneeInfo
- * @param rapport
*/
void executeBascule(SecuriteSession securiteSession,
BasculeAnneeInfo basculeAnneeInfo,
/**
* Effectue l'historisation la et re-indexation de tous les messages dont
* l'autorité est destinataire
- * @param destinataire
- * @param groupeInfo
- * @param basculeAnneeInfo
- * @param rapport
- * @return la liste des messages traités
+ * @return la liste des messages traités
*/
private void traiteMessagesDestinataire(Autorite destinataire,
GroupeInfo groupeInfo,
* supprimer
* @param message : message à ajouter l'historique de destinataire
* @param groupeInfo : informations sur le groupe
- * @param codeAnnee
- * @param rapport
*/
private void historiseMessageDestinataire(Message message,
GroupeInfo groupeInfo,
/**
* Re-indexe un message
- * @param message
- * @param rapport
*/
private void reindexeMessage(Message message,
MessagerieBasculeRapport rapport) {
* Supprime l'autorité passée en paramètre
* @param groupeInfo : groupeInfo correspondant à l'autorité à supprimer
* @param autorite : autorité à supprimer
- * @param rapport
*/
private void supprimeAutorite(GroupeInfo groupeInfo,
Autorite autorite,
/**
* Crée un message de test.
- * @param securiteSessionAuteur
- * @param destinatairesTo
- * @param destinatairesCc
* @return nouveau message
* @author bper
*/
/**
* Crée les MessageLecteur pour un message.
- * @param message
*/
void distribueMessage(Message message) {
message.destinataires.each {MessageDestinataire md ->
/**
* Vérifie que MessageMessagerieDto contient les informations nécessaires
* sur le contenu du message.
- * @param securiteSessionAuteur
- * @param message
- * @param messageDto
- * @param destinatairesTo
- * @param destinatairesCc
* @author bper
*/
private void messageMessagerieDtoContenuTest(SecuriteSession securiteSessionAuteur,
/**
* Vérifie que MessageMessagerieDto contient les informations nécessaires
* sur les droits d'accès au message.
- * @param securiteSessionAuteur
- * @param message
- * @param messageDto
- * @param destinatairesTo
- * @param destinatairesCc
* @author bper
*/
private void MessageMessagerieDtoDroitsTest(SecuriteSession securiteSessionAuteur,
/**
* Gestion du breadCrumbs : Les classes descendantes peuvent surcharger cette
* partie pour implémenter leur propre gestion.
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
/**
* Vérifie si la période est publiée pour tous les profils sauf
* ENSEIGNANT, DOC, EDU, CTR, Admin Local et DIRECTEUR
- * @param periode
* @return true/false
* @author bper
*/
/**
* Traduction d'un message fournie par l'application
- * @param code
- * @return
*/
protected String traduis(String msgCode) {
return message(code: msgCode)
/**
* Traitement des exceptions specifiques a Notes
- * @return
*/
protected Collection<ExceptionHandler> getExceptionHandlers() {
return NotesExceptionHandler.values()
/**
* Returne les données de graphique de tableaud de notes
- * @param eleveId
- * @param enseignantId
- * @param periodeId
- * @param serviceId
* @author bper
*/
def graph = {
/**
* Convernteur de l'Evaluation
- * @param evaluation
* @param sousServices - Les sous-services correspondants au type de période
* donné ou le type de période équivalent. Ce paramètre
* est nécessaire pour trouver le coeff. de la modalité
/**
* Indique si la page est accessible pour l'utilisateur courant
- * @param page
- * @return
*/
private boolean pageAccessible(Page page) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Constructeur
- * @param controller
- * @param bulletinService
*/
BulletinComposant(AbstractNotesController controller,
BulletinService bulletinService,
/**
* Renvoie les donnée de buletin pour afficher (JSON) ou imprimer (model)
* @param eleveId L'id de la Personne
- * @param periodeId
* @param print if true redirige vers imprimerBulletin.gsp
* @author bper
*/
/**
* Renvoie la liste des élèves et la liste des période d'une classe pour charger
* les combos correspondats.
- * @param classeId
* @author bper
*/
def listeElevesAndPeriodes = {
/**
* Retourne la liste des périodes pour une classe
- * @param idClasse
* @author bper
*/
def listePeriodesPourClasse = {
/**
* Modifie une période
- * @param PeriodeCommand
* @author bper
*/
def modifierPeriode = {PeriodeCommand command ->
/**
* Crée une nouvelle période
- * @param PeriodeCommand
* @author bper
*/
def creerPeriode = {PeriodeCommand command ->
/**
* Vérifie s'il existe des notes et des appreciations saisies pour une période,
* s'ils n'existent pas supprime la période
- * @param idPeriode
* @author bper
*/
def actionSupprimerPeriode = {
/**
* Supprime une période et toutes les données liées
- * @param idPeriode
* @author bper
*/
def executeSupprimerPeriode = {
/**
* Applique le paramétrage d'une classe à d'autres classes
- * @param classeId
- * @param notation
- * @param examen
- * @param classes
* @author bper
*/
def reporteParametrage = {
/**
* Parse une valeur, traitant le 'null' et '' correctement
- * @param jsonElement
* @return BigDecimal ou null
* @author msan
*/
/**
* Modalité matière
- * @return
*/
ModaliteMatiere getModaliteMatiere() {
return (modalieMatiereId!=null ? ModaliteMatiere.get(modalieMatiereId) : null)
/**
* Modalité matière
- * @return
*/
ModaliteMatiere getNouveauModaliteMatiere() {
return (nouveauModaliteMatiereId!=null ?
/**
* Service parent de la modalité matière
- * @return
*/
Service getServiceParent() {
return (servicePerentId!=null ? Service.get(servicePerentId) : null)
/**
* Classe séléctionnée
- * @return
*/
StructureEnseignement getClasse() {
return (idClasse!=null ? StructureEnseignement.get(idClasse) : null)
/**
* Modifie un service
- * @param ServiceCommand
* @author bper
* @author msan
*/
/**
* Modifie un service
- * @param ServiceCommad
* @author bper
*/
def actionModifierService = { ServiceCommand command ->
/**
* L'utilisateur a confirmé la premiére validation
- * @return
*/
Boolean phase1Passee() {
return val2confirmee || val1confirmee
/**
* L'utilisateur a confirmé la deuxiéme validation
- * @return
*/
Boolean phase2passee() {
return val2confirmee
/**
* Liste des classes sur lesquelles ont peut applique le paramétrage
- * @param classeId
* @author bper
*/
def listeClassesReportParametrage = {
/**
* Returne la liste des type périodes de nature EXAMEN de l'établissement courrant
- * @param idClasse
* @return List < TypePeriodeInfo >
* @author bper
*/
/**
* Retourne la liste des types des périodes rattaché au service.
* Seulement les périodes évaluables sont retournées.
- * @param idService
* @author bper
* @author msan
*/
/**
* Ajoute matieres de l'etablissement courant dans le modele
- * @param modele
*/
private void ajouteAllMatieres(Map modele, Boolean asJson = true) {
List<Matiere> matieres = Matiere.findAllByEtablissementAndAnneeScolaire(
* Verifie la date de publication.
* S'il elle n'est pas correcte une map a retourne de donctroller est returnee.
* Sinon un null est retourne.
- * @param classe
- * @param datePublication
- * @return
*/
@SuppressWarnings('ReturnsNullInsteadOfEmptyCollection')
private Map checkDatePublication(StructureEnseignement classe,
AppreciationEleveEnseignementPeriodeService appreciationEleveEnseignementPeriodeService
/**
- * @param eleveId
* @param periodeId - type de période !
- * @param serviceId
* @author bper
*/
@SuppressWarnings('UnusedVariable')
/**
* Recharge les données
- * @param serviceId
- * @param typePeriodeId
- * @param eleveId
* @author bper
*/
@SuppressWarnings('UnusedVariable')
/**
* Enregistre l'appréciation d'un élève pour un service et un type de période donné.
- * @param serviceId
* @param typePeriodeId - l'id de type de période!
* @param eleveId - l'id de l'élève Personne
- * @param appreciation
* @author bper
*/
def enregistreAppreciation = {
SimpleDateFormat sdf = new SimpleDateFormat('dd/MM/yyyy', Locale.FRANCE)
/**
- * @param serviceId
- * @param typePeriodeId
* @author msan
* @author bper
* @authoe othe
/**
* Retourne les données du graph
- * @param eleveId
- * @param periodeId
* @author bper
*/
def graph = {
/**
* Parse une valeur, traitant le 'null' et '' correctement
- * @param jsonElement
* @return String ou null
* @author msan
* @author bper
/**
* Constructeur: utilise le tableau de notes existant.
- * @param controller
- * @param tableauDeNotesService
- * @param eleve
- * @param tdn
- * @return
*/
TableauDeNotesGraphComposant(AbstractNotesController controller,
TableauDeNotesService tableauDeNotesService,
/**
* Retourne le modèle à envoyer vers la vues.
- * @return
*/
Map getComposantModele(Boolean asJSON) {
List<TableauDeNotesGraphData> tdnGraphDatas = tableauDeNotesService.getTableauDeNotesGraphDatas(tdn, eleve)
/**
* Converteur pour TableauDeNotesGraphData.
- * @param tdnGraphData
- * @return
*/
private Map toMap(TableauDeNotesGraphData tdnGraphData) {
String evaluation = tdnGraphData.evaluation ?
/**
* Ordonne les enseignements dans l'ordre alphabetic par profs
- * @param enseignements
- * @param profs
- * @return
*/
List<Enseignement> trieParProf(List<Enseignement> enseignements, List<Personne> profs) {
return enseignements.sort { Enseignement ens ->
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.notes.aideEnLigne.url
/**
* Retourne toutes les classes d'un établissement dont au moins un élève est inscrit
* pour le Brevet.
- * @param etablissement
* @return liste des classes
* @author bper
*/
/**
* Retourne toutes les classes d'un établissement dont au moins un élève est inscrit
* pour le Brevet.
- * @param etablissement
* @return liste des classes
* @author bper
* @author msan
\r
/**\r
* Cherche la note textuelle par sa valeur\r
- * @param noteTextuellesEnum\r
- * @return\r
*/\r
BrevetNoteValeurTextuelle getNoteTextuelle(NoteTextuellesEnum noteTextuellesEnum) {\r
return BrevetNoteValeurTextuelle.findByValeur(noteTextuellesEnum.name())\r
\r
/**\r
* Reurne la série de Brevet pour l'élève donné.\r
- * @param eleve\r
* @return série de l'élève.\r
* @author bper\r
*/\r
\r
/**\r
* Retourne le flux de lecture sur le xsd de validation\r
- * @param templateDocument\r
- * @param templateEliot\r
* @return un InputStream\r
*/\r
protected InputStream getFluxFichierValidationXsd(String xsdFileName) {\r
\r
/**\r
* Valide un fichier XML par un XSD\r
- * @param xmlFileName\r
- * @param xsdFileName\r
*/\r
protected void valideXsd(String xmlFileName, String xsdFileName) {\r
def factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI)\r
\r
/**\r
* Escape les characteres speciaux XML\r
- * @param text\r
- * @return\r
*/\r
protected String escapeXML(String text) {\r
String result = text\r
\r
/**\r
* Tronque les libelles trop long\r
- * @param text\r
- * @return\r
*/\r
protected String tronque(String text, Integer longueur) {\r
if (text.length() <= longueur) {\r
\r
/**\r
* Cree le dossier avec les dossiers parents si necessaire\r
- * @param nomFichier\r
*/\r
protected void forceCreationDossier(String nomFichier) {\r
File fichier = new File(nomFichier)\r
\r
/**\r
* Securite Session de systeme\r
- * @param etablissement\r
- * @return\r
*/\r
protected SecuriteSession getSecuriteSessionSysteme(Etablissement etablissement) {\r
DefaultSecuriteSessionFactory.\r
/**
* Calcule les rangs des notes.
* Les rangs sont renseignes dans les notes dans trimestreServiceNotes
- * @param trimestreServiceNotes
*/
private void calculeRangs(LinkedHashMap<String, Map<Long, List<ApbNotes>>> trimestreServiceNotes) {
// Calcule les rangs
\r
/**\r
* Collecte les notes (moyennes) de brevet\r
- * @param classes\r
- * @return\r
*/\r
NotanetExportNotanet extrais(SecuriteSession securiteSession,\r
List<StructureEnseignement> classes) {\r
\r
/**\r
* Prepare DTOs d'eleves avec leur notes\r
- * @param securiteSession\r
- * @param eleveMap\r
- * @return\r
*/\r
List<NotanetEleve> extraisEleves(SecuriteSession securiteSession,\r
Map<Personne, NotanetEleve> eleveMap,\r
\r
/**\r
* Verifie que les epreuves et les notes adherent aux regles Notanet\r
- * @param notanetEleve\r
- * @param eleve\r
- * @param brevetNotes\r
- * @param notanetExportNotanet\r
*/\r
void verifieEpreuves(NotanetEleve notanetEleve, Personne eleve,\r
List<BrevetNote> brevetNotes,\r
/**\r
* Extrais une note. Valeur retournee corresponde a nombre de points a\r
* ajouter au total. Si la note est extraites, elle est ajoute dans la listeNotes.\r
- * @param securiteSession\r
- * @param note\r
- * @param exportNotanet\r
- * @param notanetEleve\r
* @param listeNotes liste ou la note est ajoutee\r
- * @return\r
*/\r
BigDecimal extraisNote(SecuriteSession securiteSession,\r
BrevetNote note,\r
\r
/**\r
* Extrais une note numerique\r
- * @param securiteSession\r
- * @param note\r
- * @param exportNotanet\r
- * @param notanetEleve\r
* @param listeNotes liste ou la note est ajoutee\r
* @return nombre de points a ajouter au total\r
*/\r
\r
/**\r
* Extrais une note textuelle\r
- * @param securiteSession\r
- * @param note\r
- * @param exportNotanet\r
- * @param notanetEleve\r
* @param listeNotes liste ou la note est ajoutee\r
*/\r
void extraisNoteTextuelle(SecuriteSession securiteSession,\r
\r
/**\r
* Extrais les DTOs des notes\r
- * @param securiteSession\r
- * @param notes\r
- * @param exportNotanet\r
- * @param notanetEleve\r
- * @return\r
*/\r
List<NotanetNote> extraisNotes(SecuriteSession securiteSession,\r
List<BrevetNote> notes,\r
\r
/**\r
* Note une infraction des regles Notanet\r
- * @param brevetNote\r
- * @param typeInfraction\r
- * @param notanetExportNotanet\r
- * @param notanetEleve\r
*/\r
void marqueInfraction(BrevetNote brevetNote, TypeInfraction typeInfraction,\r
NotanetExportNotanet notanetExportNotanet,\r
/**\r
* Formate note a 2 chiffres de la partie entiere et deux chiffres de la\r
* partie de fraction\r
- * @param total\r
- * @return\r
*/\r
String formateNote(BigDecimal note) {\r
return FORMATEUR_NOTES.format(note)\r
/**\r
* Formate total a 3 chiffres de la partie entiere et deux chiffres de la\r
* partie de fraction\r
- * @param total\r
- * @return\r
*/\r
String formateTotal(BigDecimal total) {\r
return FORMATEUR_TOTAL.format(total)\r
\r
/**\r
* Tru si valeur textuelle de la note est autorisee pour l'epreuve donnee\r
- * @param epreuve\r
- * @param note\r
- * @return\r
*/\r
private Boolean isValeurTextuelleAutorisee(BrevetEpreuve epreuve,\r
BrevetNoteValeurTextuelle note) {\r
/**
* Construis le rapport
- * @param builder
- * @return
*/
@SuppressWarnings(['MethodSize', 'AbcComplexity', 'CyclomaticComplexity'])
public buildHtml(MarkupBuilder builder) {
* formulaire de saisie de la selection du publipostage. Ceci ne se trouve
* pas dans un contrôleur car en fait on va faire appel à cette méthode
* dans les jobs.
- * @return
*/
public PublipostageNotesParams construitSelectionCommand(String argsJSON) {
Map params = new JSONObject(argsJSON)
/**
* Convertit le bulletin en TableauImpressionInfo
- * @param bulletin
* @return TableauImpressionInfo avec les données de Relevé
* @author bper
*/
/**
* Construis NoteTextuelleImpression depuis une liste des noteTextuelle
- * @param noteTextuelles
- * @return
*/
AllNoteTextuelleImpression construisNoteTextuelleInfo(List<NoteTextuelle> noteTextuelles) {
/**
* Crée la structure d'info pour un service
- * @param rsn
* @return MatiereImpressionInfo
* @author bper
*/
/**
* Crée la structure d'info pour un sous-service
- * @param rmmn
* @return SousMatiereImpressionInfo
* @author bper
*/
/**
* Construit une liste des notes
- * @param notes
* @return List < NoteImpressionInfo >
* @author bper
*/
/**
* Permet de construire le DTO d'impression des appréciations
- * @param etablissement
- * @param classe
- * @param periode
- * @param appreciations
- * @return
*/
public Appreciations donneesAImprimer(Etablissement etablissement,
StructureEnseignement classe,
/**
* Construction du tableau à partir des infos de synthèse
- * @param synthese
- * @return
*/
private List<CelluleTableau> construitTableau(Synthese synthese,
SecuriteSession securiteSession,
/**
* Retourne le libellé de la liste des enseignants
*
- * @param enseignants
* @return : le libellé est calculé de la manière suivante :
* <nom avec initiale prenom>,...
*/
* - de départs anticipés
*
* @param synthese synthèse en cours d'impression
- * @param tableau
- * @param securiteSession
* @return informations concernant la vie scolaire
*/
protected void listeVieScolaire(
/**
* Calcule les absences justifiées et non justifiées
- * @param synthese
- * @param preferencesEtablissementAbsences
- * @param motifIds
* @return un StatsPeriodes
*/
private StatsPeriodes calculeAbsencesTotales(
/**
* Calcule les retards
- * @param synthese
- * @param preferencesEtablissementAbsences
- * @param motifIds
* @return un StatsPeriodes
*/
StatsPeriodes calculeRetards(
/**
* Calcule les départs anticipés
- * @param synthese
- * @param preferencesEtablissementAbsences
- * @param motifIds
* @return un StatsPeriodes
*/
StatsPeriodes calculeDepartsAnticipes(
/**
* Crée les critères de recherche de base
- * @param synthese
- * @param preferencesEtablissementAbsences
- * @param motifIds
* @return un StatsMensuellesParams
*/
protected StatsMensuellesParams creeBaseCriteresRecherche(
/**
* Calcule les statistiques d'absences
- * @param synthese
- * @param preferencesEtablissementAbsences
- * @param params
* @return StatsPeriodes
*/
protected StatsPeriodes calculeStatistiquesAbsences(
/**
* Evaluations d'une période avec les notes fetchées.
- * @param periode
* @param seulementMonoperiodeEvals si true, les évaluation qui sont liées
* seulement à une période sont retournées
* @return Evaluations d'une période avec les notes fetchées
/**
* Supprime toutes les notes liées aux evaluations
- * @param evaluations
* @author msan
*/
void internalSupprimeNotes(List<Evaluation> evaluations) {
/**
* Traite les reports des proprietes des services d'une classe
- * @param securiteSession
- * @param reportServiceCorrespondances
*/
@SuppressWarnings(['NestedBlockDepth','CatchException'])
// - Les nombre de blocks est augmente par l'utilisation de la nouvelle
/**
* Calcul les SousServiceOrdreInfo à partir de SousServices cibles
* Les SousServices appartenant à la même ModaliteMatière créeront un SousServiceOrdreInfo
- * @param allSousServiceCible
- * @return
*/
private List<SousServiceOrdreInfo> calculOrdresCible(
List <SousService> allSousServiceCible
/**
* Report par etablissement
- * @param etablissement
- * @return
*/
Report findReportByEtablissement(Etablissement etablissement) {
return Report.createCriteria().get {
/**
* Cree un report
- * @param etablissement
- * @param reportParams
- * @return
*/
Report creeReport(Etablissement etablissement, ReportParams reportParams) {
Report report = new Report(
/**
* Supprime report et ses reportTraitements
- * @param etablissement
*/
void supprimeReport(Etablissement etablissement) {
findReportByEtablissement(etablissement)?.
/**
* Traitements de report en cours
- * @return
*/
ReportProprietes findTraitementsEnCours(Etablissement etablissementCourant) {
/**
* Marque debut de traitement d'un report
- * @param report
- * @param service
* @return id d'enregistrement de report
*/
ReportTraitement creeReportTraitement(Report report,
/**
* Marque le debut de traitement d'un service cible
- * @param reportTraitement
*/
void marqueDebutTraitement(ReportTraitement reportTraitement) {
if (log.infoEnabled) {
/**
* Marque la fin de traitement d'un service cible
- * @param reportTraitement
*/
void marqueFinTraitement(ReportTraitement reportTraitement) {
if (log.infoEnabled) {
/**
* Marque l'erreur de traitement d'un service cible
- * @param reportTraitement
*/
void marqueErreurTraitement(ReportTraitement traitement) {
ReportTraitement.withNewSession {session ->
/**
* Supprime les reportTraitements EN_ATTENTE.
* Cela est utilise pour interrompre le report en cours.
- * @param etablissementCourant
*/
void supprimeReportsTraitementEnAttente(Etablissement etablissementCourant) {
ReportTraitement.createCriteria().list {
/**
* Supprime les CreationSousServicesEtat EN_ATTENTE.
* Cela est utilise pour interrompre la creation de sous-service en cours.
- * @param etablissementCourant
*/
void supprimeReportsTraitementEnAttente(Etablissement etablissementCourant) {
/**
* Creations de sous-services en cours
- * @return
*/
CreationSousServicesProperties findCreationsEnCours(Etablissement etablissementCourant) {
/**
* Marque le debut de traitement d'un service cible
- * @param reportTraitement
*/
void marqueDebutTraitement(CreationSousServicesEtat creationSousServicesEtat) {
if (log.infoEnabled) {
/**
* Marque la fin de traitement d'un service cible
- * @param reportTraitement
*/
void marqueFinTraitement(CreationSousServicesEtat creationSousServicesEtat) {
if (log.infoEnabled) {
/**
* Marque l'erreur de traitement d'un service cible
- * @param reportTraitement
*/
void marqueErreurTraitement(CreationSousServicesEtat creationSousServicesEtat) {
CreationSousServicesEtat.withNewSession {session ->
/**
* Supprime creation de sous-serviceset ses enfants
- * @param etablissement
*/
void supprimeCreation(Etablissement etablissement) {
findCreationByEtablissement(etablissement)?.
/**
* Supprime creation de sous-serviceset ses enfants
- * @param etablissement
*/
void supprimeCreation(CreationSousServices creationSousServices) {
creationSousServices.delete(flush: true, failOnError: true)
/**
* Creation de sous-services par etablissement
- * @param etablissement
- * @return
*/
CreationSousServices findCreationByEtablissement(Etablissement etablissement) {
List<CreationSousServices> liste = CreationSousServices.createCriteria().list {
/**
* Cherche des creations a traiter.
* Les classes actuellement prises par le calcul des moyennes sont ignorees.
- * @return
*/
List<CreationSousServices> findCreationsAtraiter() {
return CreationSousServices.createCriteria().listDistinct {
/**
* Permet de récupérer le type de fonctionnalité associé à un template document
- * @param templateDocument
- * @return
*/
private TemplateTypeFonctionnaliteEnum getTypeFonctionnaliteFromTemplate(TemplateDocument templateDocument) {
if (templateDocument.templateEliot.typeFonctionnalite.code == TemplateTypeFonctionnaliteEnum.BREVET.nom) {
/**
* Appel du requetage pour relevé et bulletin
- * @param parametresSelectionPublipostage
- * @param securiteSession
- * @param etablissement
- * @param template
- * @return
*/
private List<EleveImpressionInfo> findAllInfoForBulletinEtReleve(PublipostageNotesParams parametresSelectionPublipostage, SecuriteSession securiteSession, Etablissement etablissement, TemplateDocument template) {
List<Personne> eleves = localPersonneService.
* - période d'année soit la dernière (pour l'ordre dans le set)
* - après compare par élève/classe et typePeriode (pour trouver si deux DMs
* sont pareille)
- * @param a
- * @param b
- * @return
*/
int compare(DirtyMoyenne a, DirtyMoyenne b) {
/**
* Constructeur
- * @param classe
- * @param eleves
- * @param dirtyMoyennes
* @return DirtyMoyenneSetBag
*/
DirtyMoyenneSetBag(StructureEnseignement classe,
/**
* Ajoute une DirtyMoyenne dans le Set approprié.
- * @param dm
*/
void add(DirtyMoyenne dm) {
switch (dm.typeMoyenne) {
/**
* True si DirtyMoyenneSetBag est vide
- * @return
*/
Boolean isVide() {
return itemCount == 0
/**
* Retoutne le nombre total des DirtyMoyennes
- * @return
*/
Long getItemCount() {
eleveServiceDMSet.size()+
* Met à jour la date de début de calcul. Cette méthode doit être applelée dans
* la même transaction que le caclul des moyennes. Le calcul doit être déjà
* vérroillé précédemment.
- * @param classe
* @author msan
* @author bper
*/
/**
* Met à jour la date de fin de calcul et enlève le verrou.
- * @param classe
* @author msan
* @author bper
*/
* Crée le verrou en mettant la valeur de l'attribut "calculEnCours" à true.
* Cette méthode doit etre appelée dans une transaction séparée avant de lancer
* le calcul des moyennes afin de verrouiller le calcul pour cette classe.
- * @param classe
* @author bper
*/
InfoCalculMoyennesClasse creeVerrou(StructureEnseignement classe) {
/**
* Enlève le verrou posé par un processus de calcul.
- * @param classe
* @author bper
*/
void enleveVerrou(StructureEnseignement classe) {
/**
* Enlève le verrou posé par un processus de calcul.
- * @param classe
* @author bper
*/
private void enleveVerrou(InfoCalculMoyennesClasse info) {
/**
* Crée ou cherche un Info
- * @param classe
* @author msan
*/
InfoCalculMoyennesClasse internalCreeOrFind(StructureEnseignement classe) {
/**
* Supprime toutes les DMs des classes pour les services donnés.
- * @param classes
- * @param services
* @author bper
*/
void supprimeByClassesAndServices(List<StructureEnseignement> classes,
/**
* Met à jour les dates de changement dans les DirtyMoyenne de type ELEVE_PERIODE
* pour les élèves passés en paramèrtes, quelles que soient les périodes des moyennes.
- * @param eleves
* @author bper
*/
void updateDatesDirtyMoyennes(List<Autorite> eleves) {
/**
* Passe les dms d'un sous-service à l'autre
- * @param ancienSS
- * @param nouvelSS
* @author msan
*/
void passeDMs(SousService ancienSS, SousService nouvelSS, StructureEnseignement classe, List<Autorite> eleves) {
/**
* Traite le sous-service. Soit deja existatnt, soit cree si besoin.
- * @param sousServicesExistants
- * @param typePeriode
- * @param service
- * @param creation
- * @param mmChangee
- * @param params
* @param sousServicesChanges sous-services qui ont change prenadnt le traitement
* @param typePeriodeChangee si le type de periode a change
- * @return
*/
private SousService internalTraiteSousService(List<SousService> sousServicesExistants,
TypePeriode typePeriode,
* Liste des types de periode a traiter, dependant de nature de periode
* @param naturePeriodeEnum nature de periode
* @param typePeriode type de periode edite dans el FO
- * @return
*/
List<TypePeriode> internalGetTypesPeriodeEdites(NaturePeriode nature,
TypePeriode typePeriodeEdite) {
/**
* Passe les devoirs et les resultats de service au sous-service
- * @param service
- * @param modaliteMatiere
- * @param sousService
- * @param typePeriode
*/
private void passeDevoirsResultatsASousService(Service service,
ModaliteMatiere modaliteMatiere,
/**
* Calcule la valeur suivante d'ordre
- * @param service
- * @param periode
- * @return
*/
private Long internalFindOrdreSuivant(Service service,
TypePeriode typePeriode) {
/**
* Vérifie que la rélation entre service et modaliteMatiere existe déjà
* pour la période donnée
- * @param service
- * @param modaliteMatiere
* @return true si la rélation existe déjà
*/
private Boolean internalVerifieRelationExiste(Service service,
/**
* True si le sous-service a des données liées
- * @param service
- * @param modaliteMatiere
- * @return
* @author msan
*/
Boolean sousServiceHasDonneesLiees(Service service, ModaliteMatiere modaliteMatiere) {
/**
* Change les sous-services pour être branchés sur trimestres, au lié de semestres.
* En suite, crée les sous-services pour T3
- * @param services
* @author msan
*/
void passeSousServicesAtrimestres(List<Service> services,
/**
* Find or crée sous-service
- * @param service
- * @param typePeriode
- * @param modaliteMatiere
- * @return
*/
SousService internalFindOrCree(Service service,
TypePeriode typePeriode,
/**
* Groupes (locaux et regroupements) de classe
- * @param classe
- * @return
*/
List<StructureEnseignement> findAllGroupeByClasse(StructureEnseignement classe) {
// TOCHECK bizarrement le comortement de requête est inverse que ce qui est décrit dans bug grails 7087
/**
* Code de texte (à i18n)
- * @return
*/
public String getCodeTexte() {
return this.codeTexte
/**
* Type d'appréciation
- * @return
*/
public TypeAppreciationEnum getTypeAppreciation() {
return this.typeAppreciation
/**
* Reaction aux evenements leves lies aux panneaux
- * @param evenementPanel
*/
void evenementLeve(EvenementPanel evenementPanel) {
/**
* Affiche les erreurs survenues
- * @param rapportTraitement
*/
void afficheErreur(RapportTraitement rapportTraitement) {
String message = "Les erreurs suivantes se sont produites pendant le traitement : \n\n"
/**
* Fais les actions suivants les exceptions levees pendant le traitement
- * @param exceptionAffichable
*/
void traiteExceptionTraitement(AffichableException exceptionAffichable) {
// pb avec le fichier Sconet
/**
* Ecoute jobs et genere les evenements par rapport a leur etats
- * @param evt
*/
void propertyChange(PropertyChangeEvent evt) {
if (evt.source == mergeJob) {
/**
* Loggue info pour la verification de performance
- * @param message
*/
void logguePerfInfo(String message) {
Date maintenant = new Date()
/**
* Reaction aux evenements leves lies aux panneaux
- * @param evenementPanel
*/
void evenementLeve(EvenementPanel evenementPanel) {
/**
* Affiche les erreurs survenues
- * @param rapportTraitement
*/
void afficheErreur(RapportTraitement rapportTraitement) {
String message = "Les erreurs suivantes se sont produites pendant le traitement : \n\n"
/**
* Fais les actions suivants les exceptions levees pendant le traitement
- * @param exceptionAffichable
*/
void traiteExceptionTraitement(AffichableException exceptionAffichable) {
// pb avec le fichier Sconet
/**
* Lance l'export
- * @param suiteAuMerge
*/
void lanceExport(Boolean suiteAuMerge) {
logguePerfInfo("Export lancé")
/**
* Ecoute jobs et genere les evenements par rapport a leur etats
- * @param evt
*/
void propertyChange(PropertyChangeEvent evt) {
if (evt.source == mergeJob) {
/**
* Loggue info pour la verification de performance
- * @param message
*/
void logguePerfInfo(String message) {
Date maintenant = new Date()
/**
* Création d'un objet d'extraction XML à partir d'un flux contenant un fichier
* XML
- * @param inputStream
- * @return
* @author othe
*/
private XMLStreamExtractor fluxXmlToExtractor(InputStream inputStream) {
* Permet de récupérer les informations d'entête à partir d'un
* reader contenant le fichier xml APB
* @param path : chemin du fichier xml
- * @return
* @author : othe
*/
public void extraitDonneesCartoucheDepuisXML(String path) {
/**
* Permet de récupérer les informations d'entête à partir du nom de fichier
* @param cheminFichier chemin du fichier xml
- * @return
* @author msan
*/
void extraitDonneesCartoucheDepuisNomFichier(String cheminFichier) {
/**
* Extrait l'information de type d'export à partir du fichier passé
* en paramètre
- * @param path
*/
private void extraitTypeExportCartouche(String path) {
Cartouche cartouche = DonneesCartouche.getCartouche()
/**
* Extrait le nom de l'établissement à partir des données
* passée en paramètre
- * @param path
*/
private void extraitEtablissementCartouche(String path) {
Cartouche cartouche = DonneesCartouche.getCartouche()
/**
* Permet de reconstruire la liste des informations eleves à partir d'un
* reader contenant le fichier xml APB
- * @param xmlStreamReader
- * @return
* @author : othe
*/
public DonneesAPB extraitDonneesAPB(XMLStreamReader xmlStreamReader) {
/**
* Dans APB annee scolaire 2011-2012 est represente comme 2012, dans Sconet comme 2011
- * @param anneeScolaireAPB
* @return anneeScolaireSconet
*/
private String anneeAPBtoAnneeSconet(String anneeScolaireAPB) {
/**
* Retourne le libellé de l'export
- * @return
*/
public String getLibelle() {
switch (typeExport) {
/**
* Permet de reconstruire la liste des informations eleves à partir d'un
* reader contenant le fichier xml APB
- * @param xmlStreamReader
- * @return
* @author msan
*/
public List<NotanetEleveInfo> extraitDonneesNotanet(XMLStreamReader xmlStreamReader) {
/**
* Permet de reconstruire la liste des informations eleves à partir d'un
* reader contenant le fichier xml Sconet
- * @param xmlStreamReader
- * @return
* @author msan
*/
public DonneesSconet extraitDonneesSconet(XMLStreamReader xmlStreamReader) {
/**
* Date Naissance formatee comme dans le fichier APB
- * @return
*/
String getDateNaissanceFormateeAPB() {
if (dateNaissanceAPB == null) {
/**
* Nom normalise pour la comparaison
- * @return
*/
String getNomNormalise() {
if (nomNormalise == null) {
/**
* Prenom normalise pour la comparaison
- * @return
*/
String getPrenomNormalise() {
if (prenomNormalise == null) {
/**
* Rapport de merge
- * @return
*/
RapportMerge getRapport() {
return this.rapportMerge
/**
* Creation de sous-dossier horodate + verif de droit d'ecriture
- * @param rapportMerge
- * @return
*/
RapportMerge creeDossierExport(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.CREATION_DOSSIER_EXPORT
/**
* Parsing de fichier Sconet
- * @param rapportMerge
- * @return
*/
RapportMerge parseSconet(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.PARSING_SCONET
/**
* Constructeur
- * @param params
*/
ApbMergeJob(ApbMergeJobParams params) {
super()
/**
* Rapport de merge
- * @return
*/
RapportMerge getRapport() {
return this.rapportMerge
/**
* Effectue le merge
- * @return
*/
@SuppressWarnings('CatchException') // JTRA : on veut ajouter toutes les erreurs dans un rapport
protected RapportMerge doInBackground() {
/**
* Verifie que le fichier APB correspond au XSD
- * @param rapportMerge
*/
void verifieFichierAPB(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.VERIFICATION_FICHIER_APB
/**
* Merge APB + Sconet et marque les eleves ou il faut choisir la modalite
* d'election
- * @param rapportMerge
- * @return
*/
RapportMerge merge(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.MERGE
/**
* Parsing de fichier APB brut
- * @param rapportMerge
- * @return
*/
RapportMerge parseAPB(RapportMergeApb rapportMerge) {
rapportMerge.phase = Phase.PARSING_APB
/**
* Repport d'export
- * @return
*/
RapportExport getRapport() {
return this.rapportExport
/**
* Constructeur
- * @param params
*/
ExportJob(ExportJobParams params) {
this.fichierAPBbrut = params.fichierAPBbrut
/**
* La methode d'execution
- * @return
*/
@SuppressWarnings('CatchException') // JTRA : On veut ajouter toutes les erreurs dans un rapport
protected RapportExport doInBackground() {
* @param dossierExport dossier d'export
* @param rne RNE d'etablissement
* @param typeExport type d'export (1, 2, 3)
- * @return
*/
private File creeFichierAPBetendu(File dossierExport, String rne,
Integer typeExport) {
/**
* Cree le fichier de rapport d'export
- * @param dossierExport
- * @return
*/
private File creeFichierRapport(File dossierExport) {
return new File(dossierExport, "rapport.html")
/**
* Cree le fichier de rapport d'export
- * @param rapportExport
- * @return
*/
RapportExport exportRapport(RapportExport rapportExport) {
rapportExport.phase = Phase.EXPORT_RAPPORT
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return ("Le fichier d'Admission Post-Bac d'eliot-notes ${nomFichier} n'est "+\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return ("Le fichier Notanet exporté d'eliot-notes ${nomFichier} n'est "+\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return message\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return "Le RNE d'établissement de fichier Sconet ($uajTrouve) ne correspond"+\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return "Le fichier fourni d'Admission Post-Bac d'eliot notes ($nomTrouve)"+\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return message\r
\r
/**\r
* Message d'exception\r
- * @return\r
*/\r
String toString() {\r
return "L'année scolaire de fichier Sconet ($anneeTrouvee) ne correspond "+\r
/**
* Constructeur
- * @param params
*/
NotanetMergeJob(NotanetMergeJobParams params) {
super()
/**
* Rapport de merge
- * @return
*/
RapportMerge getRapport() {
return this.rapportMerge
/**
* Effectue le merge
- * @return
*/
@SuppressWarnings('CatchThrowable')
protected RapportMerge doInBackground() {
/**
* Cree un rapport d'export
- * @param rapportMergeNotanet
- * @return
*/
RapportMerge creeRapport(RapportMergeNotanet rapportMergeNotanet) {
rapportMergeNotanet.phase = Phase.EXPORT_RAPPORT
/**
* Export les donnes notanet vers un fichier
- * @param rapportMergeNotanet
- * @return
*/
RapportMerge export(RapportMergeNotanet rapportMergeNotanet) {
rapportMergeNotanet.phase = Phase.EXPORT_NOTANET
/**
* Verifie que le fichier Notanet correspond au XSD
- * @param rapportMerge
*/
void verifieFichierNotanet(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.VERIFICATION_FICHIER_NOTANET
/**
* Merge Notanet + Sconet et marque les eleves ou il faut choisir la modalite
* d'election
- * @param rapportMerge
- * @return
*/
RapportMerge merge(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.MERGE
/**
* Parsing de fichier Notanet
- * @param rapportMerge
- * @return
*/
RapportMerge parseNotanet(RapportMerge rapportMerge) {
rapportMerge.phase = Phase.PARSING_NOTANET
/**
* Cree le fichier Notanet.
* @param dossierExport dossier d'export
- * @return
*/
private File creeFichierNotanetFinal(File dossierExport) {
return new File(dossierExport, construisNomFichier() + ".txt")
/**
* Cree le fichier de rapport d'export
- * @param dossierExport
- * @return
*/
private File creeFichierRapport(File dossierExport) {
return new File(dossierExport, construisNomFichier() + "_rapport.html")
/**
* Construis le nom de fichier final
- * @return
*/
private String construisNomFichier() {
return "Notanet_${this.uajEtablissement}_${this.codeAnneeScolaire}"
\r
/**\r
* Affiche eleve infos\r
- * @param eleveInfos\r
*/\r
void affichEleveInfos(List<EleveInfoEtendu> eleveInfos, List<MatiereInfo> matiereInfos ) {\r
\r
/**\r
* Libelle Sconet de matiere.\r
* Si on a un libelle on l'affiche, sinon on affiche le code sconet\r
- * @param idSconet\r
- * @param matiereMap\r
- * @return\r
*/\r
private String getLibelleMatiere(String idSconet, Map<String, String> matiereMap) {\r
// si on a un libelle on l'affiche, sinon on affiche le code sconet\r
\r
/**\r
* Gestion d'evenement qu'une modalite a change\r
- * @param e\r
*/\r
void tableChanged(TableModelEvent e) {\r
// desactive le button Enregistrer s'il reste des modalites a positionner\r
\r
/**\r
* Modalites choisises dans la grille\r
- * @return\r
*/\r
List<ModaliteChangeeInfo> getModalites() {\r
return this.elevesTableModel.getModalites()\r
/**
* Ajoute le libellé d'une section "étape"
- * @param libelle
*/
private void libelleEtape(String libelle) {
JMultilinesLabel premierTexte = new JMultilinesLabel(libelle)
/**
* Ajoute la description d'une section "étape"
- * @param description
*/
private void descriptionEtape(String description) {
float interlignage = 1.2
/**
* Création du panneau du bouton d'export
- * @param panelPreparation
*/
private void creePanneauBoutonExport(JPanel panelPreparation) {
panelExport = new JEliotPanel(new FlowLayout(FlowLayout.CENTER, 5, 5))
\r
/**\r
* Si il faut marquer cette ligne comme erronnee\r
- * @param table\r
- * @param row\r
- * @param column\r
- * @return\r
*/\r
private Boolean estErronee(JTable table, int row) {\r
def modalite = table.getValueAt(row, 3)\r
\r
/**\r
* True s'il y a des modalites a positionner\r
- * @return\r
*/\r
Boolean modalitesApositioner() {\r
return data.any { it[3] == ModaliteElection.N }\r
\r
/**\r
* Modalites choisies dans la grille\r
- * @return\r
*/\r
List<ModaliteChangeeInfo> getModalites() {\r
\r
/**
* Ecoute des modifs
- * @param documentListener
*/
public void setDocumentListener(DocumentListener documentListener) {
edtChemin.getDocument().addDocumentListener(documentListener)
/**
* Retourne le chemin du fichier selectionné
- * @return
*/
public getFilePath() {
edtChemin.getText()
/**
* Indique si le chemin courant est valide et si on peut l'ouvrir dans
* l'explorateur de fichiers
- * @return
*/
private boolean peutOuvrirCheminDansExplorateur() {
if (!bureau.peutOuvrirRepertoire()) {
/**
* Constructeur avec gestion de l'interlignage ( voir partie 2 de l'écran
* fiche mantis 18938)
- * @param text
* @param spacing : valeur d'interlignage
*/
public JMultilinesLabel(String text, float spacing) {
\r
/**\r
* Component racine de panel\r
- * @return\r
*/\r
abstract protected JComponent getComponentRacine()\r
\r
/**\r
* Ajout de listener des evenements\r
- * @param panelListener\r
*/\r
void addPanelListener(PanelListener panelListener) {\r
listeners.add(panelListener)\r
\r
/**\r
* Leve un evenement lie aux panneaux\r
- * @param evenement\r
*/\r
void firePanelEvenement(EvenementPanel evenement) {\r
listeners.each { PanelListener panelListener ->\r
\r
/**\r
* Change le contenu de panneau.\r
- * @param panel\r
*/\r
void setContenuCentre(AbstractPanel panel) {\r
this.panelContenu.removeAll()\r
/**
* Effectue l'export de fichier APB etendu
- * @param params
* @return nombre d'eleves exportes
*/
Long exportAPB(ExportParams params) {
/**
* Dans APB annee scolaire 2011-2012 est represente comme 2012, dans Sconet comme 2011
- * @param anneeScolaireAPB
* @return anneeScolaireSconet
*/
String anneeAPBtoAnneeSconet(String anneeScolaireAPB) {
/**
* Enleve attribut type-export
- * @param reader
- * @param writer
*/
void traiteBaliseFichier(XMLStreamReader reader, XMLStreamWriter writer) {
// enleve type-export
* Si la valeur d'attribut a remplacer est null, l'attribut n'est pas copie.
* Pour ecrire les attributes vides, mettez '' come valeur.
*
- * @param reader
- * @param writer
* @param attrtibutsAmodifier (optionel)
*/
private void copieStartElementCourant(XMLStreamReader reader,
/**
* Remplace la modalite d'election si on l'a
- * @param xmlStreamReader
*/
private void traiteModaliteElection(TraitementModaliteParams params) {
/**
* Regarde si la modalite a ete changee manuelement
- * @param ine
- * @param modaliteChangeeInfos
- * @param serviceNotationId
- * @param serviceNotationInfos
- * @return
*/
ModaliteElection getModaliteChangee(String ine,
List<ModaliteChangeeInfo> modaliteChangeeInfos,
/**
* Vérification de l'accès au répertoire
- * @param file
*/
static private void verifieRepertoire(File file) {
if (!file.isDirectory()) {
/**
* Vérifie si le chemin est celui d'un fichier accessible en lecture
- * @param file
*/
static private void verifieFichier(File file) {
if (!file.isFile()) {
/**
* lecture d'un fichier xml. Vérifie si le chemin existe et est accessible
- * @param path
- * @return
*/
static public XMLStreamReader lisFichierImport(String path){
return streamToXML(
/**
* ouvre un fichier disque ou zip et le charge dans un flux
- * @param path
- * @return
*/
static public InputStream ouvreFichierDansFlux(String path){
File file = new File(path)
/**
* Convertie le fichier dans un flux en fichier XML. Part du principe que le
* fichier est bien au format XML.
- * @param inputStream
- * @return
*/
static public XMLStreamReader streamToXML(InputStream inputStream) {
XMLStreamReader reader = XMLInputFactory.newInstance().
/**
* Teste l'extension du fichier pour déterminer s'il s'agit du fichier zip
- * @param file
* @return true si le fichier est un zip
*/
private static boolean isFichierZip(File file) {
* Création d'un nouveau répertoire d'export. Le format du nom de fichier est
* <classe>_<type>-<annee><mois><jour><heure><seconde>
* @param repertoireRacine : chemin du répertoire racine
- * @param classe
* @param typeExport : premier export ou deuxième export
* @return le dossier créé
*/
/**
* Validation du fichier APB
- * @param fluxXml
- * @param nomXsd
- * @param urlBase
- * @param docBase
*/
static public void valideFichier(InputStream fluxXml, String nomXsd,
URL urlBase, String docBase) {
/**
* Récupère le fichier xsd
- * @param nomXsd
- * @param urlBase
- * @param docBase
- * @return
*/
static public InputStream getXsd(String nomXsd, URL urlBase, String docBase) {
getFile(urlBase, docBase, "../applet/$nomXsd")
/**
* Récupère un fichier local ou distant si le fichier local n'existe pas
- * @param urlBase
- * @param filename
- * @return
*/
static public InputStream getFile(URL urlBase, String docBase, String filename) {
// if (ParametresCourant.get().log()) {
/**
* Validation de fichier APB
- * @param cheminAPB
- * @param urlBase
- * @param docBase
*/
static public void valideFichierAPB(String cheminAPB, URL urlBase, String docBase){
valideFichier(new FileInputStream(cheminAPB), FILENAME_XSD_APB, urlBase, docBase)
/**
* Validation de fichier Notanet
- * @param cheminNotanet
- * @param urlBase
- * @param docBase
*/
static public void valideFichierNotanet(String cheminNotanet, URL urlBase, String docBase){
valideFichier(new FileInputStream(cheminNotanet), FILENAME_XSD_NOTANET, urlBase, docBase)
/**
* Validation de fichier APB
- * @param cheminFichier
* @param nom de fichier XSD
- * @param urlBase
- * @param docBase
*/
static public void valideFichier(String cheminFichier, String nomXsd, URL urlBase, String docBase){
valideFichier(new FileInputStream(cheminFichier), nomXsd, urlBase, docBase)
* Cherche un eleveSconet correspondant.
* Soit idSconet est egual.
* Soit on matche par nom, prenom et la date de naissance.
- * @param eleveSconets
- * @param nom
- * @param prenom
* @param dateNaissance dans le format 1992-12-24
- * @param idSconet
- * @return
*/
protected EleveSconet chercheEleveSconet(List<EleveSconet> eleveSconets,
EleveInfo eleveInfo)
\r
/**\r
* Formate le string de date naissance de 1996-12-20 a 20-12-1996\r
- * @param str\r
- * @return\r
*/\r
String formateDateNaissance(String str) {\r
if (str==null || str=='') {\r
\r
/**\r
* Trie eleves par la classe, nom, prenom\r
- * @param eleveInfos\r
- * @return\r
*/\r
List<EleveSansCorrespondanceException> trieEleves(List<EleveSansCorrespondanceException> exceptions) {\r
\r
\r
/**\r
* Construis le fichier HTML avec le rapport d'export\r
- * @param builder\r
- * @param params\r
*/\r
@SuppressWarnings(['AbcComplexity', 'MethodSize']) // JTRA : Il s'agit d'un rapport\r
void ecritRapport(MarkupBuilder builder, RapportParams params) {\r
/**
* Merge infos de APB et Sconet
- * @param eleveInfos
- * @param elevesSconet
- * @return
*/
MergeResultatApb mergeInfos(List<EleveInfoEtendu> eleveInfos, List<EleveSconet> elevesSconet) {
List<EleveInfoEtendu> infosMerges = []
/**
* Cree un clone d'EleveInfo avec modaliteInfos donnes
- * @param eleveInfo
- * @param modaliteInfos
- * @return
*/
EleveInfoEtendu cloneAvecModalitesN(EleveInfoEtendu eleveInfo, List<ModaliteInfo> modaliteInfos) {
return new EleveInfoEtendu(
/**
* Merge infos de APB et Sconet
- * @param eleveInfos
- * @param elevesSconet
- * @return
*/
MergeResultatNotanet mergeInfos(List<NotanetEleveInfo> eleveInfos,
List<EleveSconet> elevesSconet) {
/**
* Export le contenu un Writer (PrintWriter, FileWriter, StringWriter ..)
- * @param eleveInfos
- * @param writer
*/
void exporteVersWriter(List<NotanetEleveInfo> eleveInfos, Writer writer) {
PSVWriter psvWriter = new PSVWriter(writer)
/**
* Exporte une liste d'eleve infos dans un fichier
- * @param eleveInfos
- * @param fichier
*/
void exporteVersFichier(List<NotanetEleveInfo> eleveInfos, File fichier) {
FileWriter fw = new FileWriter(fichier)
/**
* Export le contenu en CVS dans un String
- * @param eleveInfos
* @return contenu exporte
*/
String exporteVersString(List<NotanetEleveInfo> eleveInfos) {
/**
* Extrais donnes pour export d'eleve infos
- * @param eleveInfos
- * @return
*/
private List<List<String>> prepareDonnees(List<NotanetEleveInfo> eleveInfos) {
/**
* Permet de savoir si l'installation de java courante intégre les api du
* bureau
- * @return
*/
public boolean peutOuvrirRepertoire() {
if (Desktop.isDesktopSupported()) {
/**
* Ouvre le répertoire dans le bureau (gestionnaire de fichier du système)
- * @param dirName
*/
public void ouvreRepertoire(String dirName) {
if (peutOuvrirRepertoire()) {
\r
/**\r
* Imprimme une stacktrace dans le string\r
- * @param e\r
- * @return\r
*/\r
static String printStacktrace(Exception e) {\r
StringWriter stringWriter = new StringWriter()\r
/**
* indique quel est l'applet courante
- * @param applet
*/
public void setApplet(JApplet applet) {
this.applet = applet
/**
* Permet de retrouver l'instance des paramètres
- * @return
*/
static public ParametresCourant get() {
return parametresApplet
/**
* indique si le log log4j est actif
- * @return
*/
public boolean log() {
readBool('log')
/**
* Retourne le niveau de log du logger log4j
- * @return
*/
public Level getLog4jLevel() {
return Level.INFO
/**
* Lecture de l'établissement dans les paramètres de l'applet
- * @return
*/
public String getEtablissement() {
String resultat = readString("uajEtablissement")
/**
* Permet de définir automatiquement n'importe quelle paramétre
- * @param name
- * @return
*/
def getProperty(String name) {
switch (name) {
/**
* initialise le logger, avec un appender en mémoire
- * @param logger
*/
static public void init(Logger logger) {
Appender memoryAppender = MemoryAppender.getAppender()
/**
* Permet de récupérer l'appender singleton
- * @return
*/
static public MemoryAppender getAppender() {
return memoryAppender
/**
* Initialise l'objet à extraire si une des classes correspond
* à l'élément XML en cours de lecture.
- * @param clazzs
* @author bper
*/
private void initExtratingObj(List<Class> clazzs) {
\r
/**\r
* Ecris une ligne des valeurs\r
- * @param row\r
*/\r
void write(Collection<String> row) {\r
row.eachWithIndex { String element, int i ->\r
\r
/**\r
* Ecris une collection des lignes des valeurs\r
- * @param rows\r
*/\r
void writeAll(Collection<Collection<String>> rows) {\r
rows.each { this.write(it) }\r
/**
* get un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
* @author mjao
*/
private ResultatClasseServicePeriode getResultatClasseServicePeriode(
/**
* crée un ResultatEleveServicePeriode
- * @param periode
- * @param service
- * @param eleve
* @author mjao
*/
private ResultatEleveServicePeriode getResultatEleveServicePeriode(
/**
* Creation des périodes
- * @param typePeriode
- * @param structureEnseignement
- * @param dateDebut
- * @param dateFin
* @autor mjao
- * @return
*/
private Periode getOuCreePeriode(TypePeriode typePeriode,
StructureEnseignement structureEnseignement,
}
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
* @author mjao
*/
private Evaluation creeEvaluation(List<Periode> periodes,
/**
* Attache service à toutes les périodes de la structure
- * @param structureEnseignement
- * @param service
*/
private void attacheService(StructureEnseignement structureEnseignement, Service service) {
structureEnseignement.periodes.each { Periode periode ->
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
- * @return
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
}
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @author mjao
*/
private Enseignement creeEnseignement(Autorite enseignant, Service service) {
}
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @author mjao
*/
private StructureEnseignement creeRegroupement(List<StructureEnseignement> classes,
}
/**
* creer un sous-Service
- * @param service
- * @param typeperiode
- * @param modalite
* @return sous-service
*/
private SousService creeSousService(
/**
* crée un ResultatEleveServicePeriode
- * @param periode
- * @param service
- * @param eleve
* @author mjao
*/
private ResultatEleveServicePeriode getResultatEleveServicePeriode(
/**
* Creation des périodes
- * @param typePeriode
- * @param structureEnseignement
- * @param dateDebut
- * @param dateFin
- * @return
*/
private Periode getOuCreePeriode(TypePeriode typePeriode,
StructureEnseignement structureEnseignement,
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
* @return evaluation
* @author mjao
*/
}
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @author mjao
*/
private Enseignement creeEnseignement(Autorite enseignant, Service service) {
}
/**
* Crée une note
- * @param eleve
- * @param evaluation
* @author mjao
*/
private Note creeNote(Personne eleve, Evaluation evaluation, BigDecimal valeurNumerique) {
/**
* Attache service à toutes les périodes de la structure
- * @param structureEnseignement
- * @param service
*/
private void attacheService(StructureEnseignement structureEnseignement, Service service) {
structureEnseignement.periodes.each { Periode periode ->
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
- * @return
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periode, service)
/**
* return un ResultatEleveSousServicePeriode
- * @param periode
- * @param service
- * @param eleve
* @author mjao
*/
private ResultatEleveSousServicePeriode getResultatEleveSousServicePeriode(
/**
* get un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
* @author mjao
*/
private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(
/**
* Vérifie que toutes les notes sont supprimées pour toute la classe et une période
- * @param securiteSession
- * @param classe
- * @param periode
*/
private void verifieNotesSupprimes(SecuriteSession securiteSession,
StructureEnseignement classe,
/**
* Vérifie que tous les résultats sont supprimés pour toute la classe et une période
- * @param securiteSession
- * @param classe
- * @param periode
*/
private void verifieResultatsSupprimes(SecuriteSession securiteSession,
Enseignement enseignement,
/**
* Suprimme périodes de cette classe
- * @param classe
*/
private void supprimePeriodes(StructureEnseignement classe) {
List<Periode> periodes = classe.periodes.toList()
/**
* Vérifie que les services de cette classe sont liés à la même période
- * @param classe
- * @param periode
* @author msan
*/
private void verifieServicesLies(StructureEnseignement classe, Periode periode) {
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param mjao
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periode, service)
/**
* Cree les sous-services d'ecrit et d'oral et attache les au service.
* Si le coefficient est null, le sous-service n'est pas cree
- * @param service
* @param parametres Parametres de sous-services
*/
void attacheSousServices(Service service, SousServicesParametres parametres) {
/**
* Prepare les reportTraitements pour l'execution
- * @param classeSource
- * @param classeCible
- * @param servicesCible
- * @param ordre
- * @param coefficients
*/
void prepareTraitements(StructureEnseignement classeSource,
StructureEnseignement classeCible,
/**
* Positionne les coefficients des periodes de notation
- * @param service
- * @param coeff
*/
private void setCoeff(Service service, BigDecimal coeff) {
List<RelPeriodeService> relPeriodeServices = RelPeriodeService.findAllByService(service)
/**
* Positionne les coefficients par intervalle (S1, S2, T1 ...)
- * @param service
- * @param coeffMap
*/
private void setCoeff(Service service, Map<IntervalleEnum, BigDecimal> coeffMap) {
List<IntervalleEnum> intervalles = coeffMap.keySet().toList()
/**
* Verifie le changement des coefficients
- * @param service
- * @param coeff
*/
private void assertCoeff(Service service, BigDecimal coeff) {
List<RelPeriodeService> relPeriodeServices = RelPeriodeService.findAllByService(service)
/**
* Verifie le changement des coefficients
- * @param service
- * @param coeff
*/
private void assertCoeffs(Service service, Map<IntervalleEnum, BigDecimal> coeffMap) {
List<IntervalleEnum> intervalles = coeffMap.keySet().toList()
/**
* Verifie le changement des coefficients des sous-services
* si le coefficient est null, il n'est pas verifie
- * @param service
- * @param coefficientEcrit
- * @param coefficientOral
*/
private void assertCoeffsSousServices(Service service,
BigDecimal coefficientEcrit,
/**
* Verifie le changement de'ordre des sous-services
* si le coefficient est null, il n'est pas verifie
- * @param service
- * @param ordreEcrit
- * @param ordreOral
*/
private void assertOrdreSousServices(Service service,
Integer ordreEcrit,
/**
* Positionne l'ordre d'un service
- * @param service
- * @param ordre
*/
private void setOrdre(Service service, Integer ordre) {
/**
* Positionne l'ordre d'un service de matiere donne
- * @param service
- * @param ordre
*/
private void setOrdre(PopulationTestMatiere serviceMatiere,
Integer ordre,
/**
* Verifie l'ordre du service
- * @param service
- * @param ordre
*/
private void assertOrdre(Service service, Integer ordre) {
List<RelPeriodeService> relPeriodeServices =
/**
* Verifie que rien n'a change ce qui concerne les sous-services du service cible.
* Cas ou le service source n'a pas des sous-services et le service cible les a.
- * @param serviceCible
*/
void verifieRienChange(Service serviceCible,
SousServicesParametres parametresSource,
/**
* Verifie que les sous-services ont ete ajoutes au service cible.
* Cas ou le service source a des sous-services et le service cible ne les a pas.
- * @param serviceCible
*/
void verifieSousServicesAjoutes(Service serviceCible,
SousServicesParametres parametresSource,
* que le sous-service oral n'a pas change.
* Cas ou le service source a un sous-service en plus (Ecrit) et
* un sous-service qui existe deja dans le service cible (Oral).
- * @param serviceCible
*/
void verifieEcritAjoute(Service serviceCible,
SousServicesParametres parametresSource,
/**
* Cherche service de classe par matiere
- * @param structureEnseignement
- * @param populationTestMatiere
- * @return
*/
Service getService(StructureEnseignement classe,
PopulationTestMatiere populationTestMatiere) {
/**
* Verifie que la moyenne calculee correspond avec la moyenne attendue
- * @param notes
- * @param moyenneAttendue
*/
private void verifieMoyenne(ArrayList<Note> listeNotes, BigDecimal moyenneAttendue) {
* @param note12 eleve 1, evaluation 2
* @param note21 eleve 2, evaluation 1
* @param note22 eleve 2, evaluation 2
- * @return
*/
Map calculeMoyenneEnseignementPeriode(Note note11,
Note note12,
/**\r
* Verifie que les eleves ou il y a besoin de choisir une modalite d'election \r
* sont bien marques\r
- * @param mergeResultat\r
- * @param eleveInfos\r
- * @param eleveSconets\r
*/\r
void verifieModalitesAchoisirMarquees(MergeResultatApb mergeResultat,\r
List<EleveInfoEtendu> eleveInfos,\r
\r
/**\r
* Verifife que les modalites sont bien positiones\r
- * @param mergeResultat\r
- * @param eleveInfos\r
- * @param eleveSconets\r
*/\r
void verifieModalitesPositiones(MergeResultatApb mergeResultat, List<EleveInfoEtendu> eleveInfos, List<EleveSconet> eleveSconets) {\r
mergeResultat.eleveInfosTous.each { EleveInfoEtendu infoMerge ->\r
\r
/**\r
* Verifie que les eleves absant dans le fichier Sconet sont bien detectes\r
- * @param mergeResultat\r
*/\r
void verifieElevesAbsent(MergeResultatApb mergeResultat) {\r
List<String> elevesAbsants = mergeResultat.elevesPasPresantDansSconet.\r
\r
/**\r
* Verifie que les INEs sont bien matches avec les id Sconet\r
- * @param mergeResultat\r
- * @param eleveInfos\r
- * @param eleveSconets\r
*/\r
void verifieINEsMerges(MergeResultatApb mergeResultat) {\r
List<EleveInfoEtendu> eleves = mergeResultat.eleveInfosTous\r
\r
/**\r
* Verifie que les eleves absant dans le fichier Sconet sont bien detectes\r
- * @param mergeResultat\r
*/\r
void verifieElevesAbsent(MergeResultatNotanet mergeResultat) {\r
List<String> elevesAbsants = mergeResultat.elevesPasPresantDansSconet.\r
\r
/**\r
* Verifie que les INEs sont bien matches avec les id Sconet ou les trios\r
- * @param mergeResultat\r
*/\r
void verifieINEsMerges(MergeResultatNotanet mergeResultat) {\r
List<NotanetEleveInfo> eleves = mergeResultat.eleveInfosTous\r
\r
/**\r
* prepare les donnes de test\r
- * @return\r
*/\r
List<NotanetEleveInfo> getEleveInfos() {\r
return [\r
/**
* Gestion du breadCrumbs : Les classes descendantes peuvent surcharger cette
* partie pour implémenter leur propre gestion.
- * @return
*/
protected List getBreadCrumbsInfo() {
/**
* Traduction d'un message fournie par l'application
- * @param code
- * @return
*/
protected String traduis(String msgCode) {
return message(code: msgCode)
/**
* Retourne les données pour la construction du menu d'aide en ligne
- * @return
*/
protected AideItemInfo getAideInfo() {
AideItemInfo menuAideInfo = menuAideScolariteService.getMenuAideInfo(securiteSession)
/**
* True si le calendrier est initialise pour l'etablissement et l'annee scolaire
* courant
- * @return
*/
private Boolean getCalendrierInitialise() {
return calendrierService.getCalendrierForEtablissementAndAnneeScolaire(
/**
* Retourne la liste des établissements pour lesquels l'acteur est directeur
- * @param acteur
- * @return
*/
protected List<Etablissement> getListEtabImportableParActeur(SecuriteSession securiteSession) {
return (List<Etablissement>) securiteSession.getEtablissementsForFonctions(
/**
* Récupère le libellé des fonctions de chaque notification par rapport à leur code
- * @param notificationParametrage
* @return notificationParametrage
*/
private NotificationParametrageEtablissement getLibelleFonctionByCode(NotificationParametrageEtablissement notificationParametrage) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* retourne un texte descriptif des informations de charset
- * @return
*/
private String findCharsetInfo() {
String resultat = "DefaultCharset=" + Charset.defaultCharset().displayName() + (char) 13
/**
* retourne un texte descriptif des infos jmx
- * @return
*/
private String findAllJmxSysteme() {
RapportJmx maintenanceJmx = new RapportJmx()
/**
* Retourne un texte descriptif des variables système
- * @return
*/
private String findAllVarSysteme() {
String resultat = ""
/**
* Gestion du breadCrumbs
- * @return
*/
protected List<UrlLabelInfo> getBreadCrumbsInfo() {
List<UrlLabelInfo> breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Fil d'ariane pour l'édition des modèles
- * @return
*/
protected List getBreadCrumbsInfo() {
/**
* Permet de convertir les informations de type media sous forme de map
* dans le but de les mettre dans le modèle
- * @param typeMedia
- * @return
*/
private Map getMapforMedia(TypeMedia typeMedia) {
return [
/**
* Liste des média de sortie
- * @return
*/
private List listeMedia() {
List result = []
/**
* Liste des modèles disponibles
- * @return
*/
private List listModeleSms() {
/**
* Liste des modèles disponibles
- * @return
*/
private List listModeleCourrier() {
/**
* Enrichi le modèle avec les données des champs de publipostage et les informations
* du modèle (nom et id
- * @param templateDocument
- * @param params
- * @return
*/
protected Map prepareModelePourEditeur(TemplateDocument templateDocument) {
Map modele = prepareBaseModele(ScolaritePage.PARAMETRAGE_MODELE_DOCUMENT)
/**
* Retourne la liste des champs de publipostage
- * @param moduleEliot
- * @return
*/
protected List listeChampsPublipostage(ModuleEliot moduleEliot) {
List listeDesChampsDePublipostage = []
/**
* Permet de récupérer la classe de l'objet de donnée associé au templateDocument
- * @param templatedocument
- * @return
*/
private static def getClassDonnees(TemplateDocument templatedocument) {
Class clazzEleve
/**
* Notes de Francais
- * @param eleveImpression
*/
static void prepareNotesFrancais(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo francais = creerMatiereImpressionInfoFrancais()
/**
* Notes de Philo
- * @param eleveImpression
*/
static void prepareNotesPhilo(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo philo = creerMatiereImpressionInfoPhilo()
/**
* Notes de Math
- * @param eleveImpression
*/
static void prepareNotesMath(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo math = creerMatiereImpressionInfoMath()
/**
* Notes d'allemand
- * @param eleveImpression
*/
static void prepareNotesAllemand(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo allemand = creerMatiereImpressionInfoAllemand()
/**
* Notes de Hist
- * @param eleveImpression
*/
static void prepareNotesHist(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo hist = creerMatiereImpressionInfoHistoire()
/**
* Donnes des notes textuelles
- * @param eleveImpressionInfo
*/
static void prepareNotesTextuelles(EleveImpressionInfo eleveImpression) {
/**
* Permet de convertir les informations de type media sous forme de map
* dans le but de les mettre dans le modèle
- * @param typeMedia
- * @return
*/
private Map getMapforMedia(TypeMedia typeMedia) {
return [
/**
* Liste des média de sortie
- * @return
*/
private List listeMedia() {
List result = []
/**
* Liste des modèles disponibles
- * @return
*/
private List listModele() {
/**
* Calcul du zoom sur les zones jasper
- * @param zones
*/
private void zoom(List<ZoneTemplateJasperInfo> zones) {
zones.each {
/**
* Récupère les valeurs par défaut des mémos
- * @param zones
*/
private void calculeValeurParDefaut(TemplateDocument templateDocument,
List<ZoneTemplateJasperInfo> zones) {
/**
* Récupère les libellé des zones
- * @param zones
*/
private void calculeLibelleZones(List<ZoneTemplateJasperInfo> zones) {
* Retourne la liste des zones de l'état jasper associé à un modèle utilisateur
* (voir 1.2- L'éditeur de modèles § Liste des éléments composant un modèle )
* Préparation de la liste des zones pour le modèle
- * @param templateDocumentId
- * @param templateEliotId
- * @return
*/
private List listZones(long templateDocumentId,
long templateEliotId) {
/**
* Permet de préparer la réponse pour l'enregistrement d'image
- * @param success
- * @param map
- * @return
*/
private String messageRetour(boolean success, Map map) {
String msg = message(map)
/**
* Retire les caractères HTML du modèle de SMS
- * @param modeleSms
* @return la chaine sans HTML
*/
private String effaceHtmlTags(String modeleSms) {
/**
* Lecture du modèle de SMS associé à un template
- * @param templateDocument
- * @return
*/
private String lireModele(TemplateDocument templateDocument) {
TemplateChampMemo templateChampMemo = TemplateChampMemo.findByTemplateDocument(templateDocument)
/**
* Création ou mise à jour d'une config d'établissement pour le back-office
- * @param configList
* @return errors
*/
void insertUpdateBackofficeConfig(BackofficeConfigSaveParam backofficeConfigSaveParam) {
/**
* Gère la clause union pour les requêtes sqlFiltrePersonne
- * @param union
- * @param dernier
- * @param sql
- * @param closure
*/
private void requeteUnion(Boolean union,
Boolean dernier,
/**
* Partie Select pour les requêtes sqlFiltrePersonne
- * @return
*/
private String sqlFiltrePersonneSelect() {
"""
/**
* Partie du from commune aux requêtes sqlFiltrePersonne
- * @return
*/
private String sqlFiltrePersonneFromCommun(){
"""
/**
* Clause where pour les requêtes sqlFiltrePersonne
- * @return
*/
private String sqlFiltrePersonneWhere(Map filtre, List params) {
StringBuilder sql = new StringBuilder()
/**
* Requête spéciale elèves
- * @param filtre
- * @param params
- * @return
*/
private String sqlFiltreEleve (Map filtre, List params){
StringBuilder sql = new StringBuilder()
/**
* Requête spéciale parents
- * @param filtre
- * @param params
- * @return
*/
private String sqlFiltreParent (Map filtre, List params){
StringBuilder sql = new StringBuilder()
/**
* Requête spéciale personnes autres que parents et éléve
- * @param filtre
- * @param params
- * @return
*/
private String sqlFiltreAutrePersonne (Map filtre, List params){
StringBuilder sql = new StringBuilder()
/**
* gére la pagination
- * @param pagination
- * @param params
- * @param requeteSql
*/
private void pagine(Map pagination, List params, StringBuilder requeteSql) {
if (pagination.max) {
/**
* Liste les imports UDT
* @param filtre (uai et debutImport : optionnels tous les 2)
- * @return
*/
List listeImportsUdt(def filtre){
/**
* Date de fin d'import à remvoyer par listeImportsUdt
- * @param dateFinPreTraitement
- * @param dateFinImport
- * @param nbrEventEnAttente
- * @return
*/
private String dateFinImport(
Timestamp dateFinPreTraitement,
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.scolarite.aideEnLigne.url
/**
* Création d'un nom de template de document à partir d'un modèle
- * @param templateDocument
- * @return
*/
private String creeNom(String prefixe, TemplateDocument templateDocument) {
/**
* Création d'une copie de template de document
- * @param templateDocument
* @return la copie
*/
public TemplateDocument copie(String prefixe, TemplateDocument templateDocument) {
/**
* Indique si le template est obsolète
- * @param templateEliotEnum
- * @return
*/
protected boolean templateEliotEstObsolete(TemplateEliotEnum templateEliotEnum,
Integer version) {
/**
* Retourne le flux de lecture sur le fichier à importer
- * @param templateDocument
- * @param templateEliot
* @return un InputStream
*/
protected InputStream getFluxFichier(TemplateEliotEnum templateEliot) {
/**
* Retourne le chemin disque où se trouve les templates.
- * @return
*/
abstract protected String rootDir()
/**
* Crée le modèle tableau de notes
- * @param tableau
- * @param templateSynthese
*/
public void importDocument(ModelesUsine documentsUsine) {
/**
* Recherche un le sous template dans la liste des template eliot
- * @param sousModeles
- * @return
*/
public TemplateEliot findTemplateSousModeleInList(SousModeles sousModeles) {
return findTemplateEliotInList(
/**
* Import ou met à jour un sous modèles
- * @param sousModeles
- * @return
*/
public TemplateEliot verifieEtMetAJourSousModele(SousModeles sousModeles) {
path = sousModeles.toString()
* Un sous modèle peut-être composé de 1 à 3 modèles, imbriqués de
* manière hiérarchique.
*
- * @param sousModeles
*/
private void lectureFichiers(SousModeles sousModeles) {
/**
*
* @param sousModèles
- * @param templateEliot
- * @param templateTypeFonctionnalite
- * @param templateTypeDonnees
- * @return
*/
private TemplateEliot metAJourSousModele(
SousModeles sousModeles,
/**
* Gestion de l'aperçu
- * @param etablissement
- * @param templateDocument
- * @return
*/
public ByteArrayOutputStream apercu(Etablissement etablissement, TemplateDocument templateDocument) {
/**
* Construction de l'objet jasperdesign à partir du modele de doc ou du modele jasper
- * @param templateDocument
- * @param templateEliot
- * @return
*/
private JasperDesign construitModeleEdition(TemplateDocument templateDocument, TemplateEliot templateEliot) {
String jrxml = ""
/**
* Enregistre les options d'impression du bulletin de notes
- * @param templateDocument
- * @param zoneInfo
*/
private void modifiezoneTemplateJasperTypeBulletin(TemplateDocument templateDocument, ZoneTemplateJasperInfo zoneInfo) {
// on recherche l'éventuel sous-template associé au modèle de bulletin
/**
* Création d'un nouveau champ mémo
- * @param templateDocument
- * @param zoneInfo
*/
public void sauveChampMemo(TemplateDocument templateDocument, ZoneTemplateJasperInfo zoneInfo) {
new TemplateChampMemo(
/**
* Modification du nom d'un modèle
- * @param nom
- * @param templateDocument
*/
public void modifieNomModele(String nom, TemplateDocument templateDocument) {
templateDocument.nom = nom
/**
* Renvoie la liaison Fournisseur-Etablissement d'un couple fournisseur/etablissement
- * @param etablissement
- * @param fournisseur
* @return SMSFournisseurEtablissement
*/
SmsFournisseurEtablissement getFournisseurEtablissement(Etablissement etablissement,
/**
* Met à jour une liaison Fournisseur/Etablissement
* @param param , Attributs de la liaison Fournisseur/Etablissement
- * @param smsFournisseurEtablissement
- * @param smsFournisseur
*/
void updateFournisseurEtablissement(SmsFournisseurEtablissement smsFournisseurEtablissement,
SmsFournisseur smsFournisseur,
/**
* Crée une liaison Fournisseur/Etablissement
* @param param , Attributs de la liaison Fournisseur/Etablissement
- * @param etablissement
- * @param smsFournisseur
*/
void insertFournisseurEtablissement(Etablissement etablissement,
SmsFournisseur smsFournisseur,
/**
* Retourne un fournisseur de sms à partir de son nom
- * @param nom
* @return SmsFournisseur
*/
public SmsFournisseur findFournisseur(String nom,
/**
* Permet de récupérer la classe de l'objet de donnée associé au templateDocument
- * @param templatedocument
- * @return
*/
private static def getClassDonnees(TemplateDocument templatedocument) {
Class clazzEleve
/**
* Notes de Francais
- * @param eleveImpression
*/
static void prepareNotesFrancais(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo francais = creerMatiereImpressionInfoFrancais()
/**
* Notes de Philo
- * @param eleveImpression
*/
static void prepareNotesPhilo(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo philo = creerMatiereImpressionInfoPhilo()
/**
* Notes de Math
- * @param eleveImpression
*/
static void prepareNotesMath(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo math = creerMatiereImpressionInfoMath()
/**
* Notes d'allemand
- * @param eleveImpression
*/
static void prepareNotesAllemand(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo allemand = creerMatiereImpressionInfoAllemand()
/**
* Notes de Hist
- * @param eleveImpression
*/
static void prepareNotesHist(EleveImpressionInfo eleveImpression) {
MatiereImpressionInfo hist = creerMatiereImpressionInfoHistoire()
/**
* Donnes des notes textuelles
- * @param eleveImpressionInfo
*/
static void prepareNotesTextuelles(EleveImpressionInfo eleveImpression) {
/**
* Récupère la liste des textes
- * @param typePeriode
- * @return
*/
private List<String> listeZoneDeTextes(TypePeriode typePeriode) {
/**
* Retourne les données pour la construction du menu d'aide en ligne
- * @return
*/
protected AideItemInfo getAideInfo() {
AideItemInfo menuAideInfo = menuAideTextesService.getMenuAideInfo(securiteSession)
/**
* Crée la demande de migration
- * @param params
* @return RessourceMigrationDemande
*/
private RessourceMigrationDemande creeDemandeMigration(def params) {
/**
* Indique si une date est incluse dans les critères
- * @param date
- * @return
*/
Boolean isDateIncluse(Date date){
Boolean result = true
)
/**
- * @param cdtId
* @return le cdt correspondant à l'id
*/
protected CahierDeTextes parseCdtId(def cdtId) {
}
/**
- * @param activiteId
* @return l'activité en cours de modif ou null
*/
protected Activite parseActiviteId(def activiteId) {
/**
* Supression d'une activité.
* La vérification des droits est faite au niveau de l'action
- * @param activiteId
*/
def supprimer = {
Activite.withTransaction {
/**
* Lister info de tout l'arbre d'activité
- * @param params
- * @return
*/
private JSON listerRacine(Map params) {
/**
* Lister info branche chapitre/activité
- * @param params
- * @return
*/
private JSON listerBranche(Map params) {
/**
* Recherche le chemin de l'activité selectionnée dans le gestionnaire d'état
- * @return
*/
private String cheminCahierDeTextesSelectionne() {
String resultat = null
/**
* Recherche le chemin de l'activité selectionné
- * @param cahierDeTextes
- * @return
*/
private String cheminActiviteSelectionne(CahierDeTextes cahierDeTextes) {
/**
* Cherche les autorites de groupes d'utilisateur + son autorite
- * @param securiteSession
*
*/
void renseigneAutorites(SecuriteSession securiteSession) {
/**
* Constitue l'ActiviteParams
- * @param json
*/
private ActiviteParams parseActiviteParams(Map json) {
/**
* Marshalling données page accueil
- * @param sessionCourante
- * @param modele
- * @param acteurAllCahierPersonnalise
- * @param etatApplicationAccueil
- * @param locale
- * @return
*/
private Map marshallAccueil(SecuriteSession sessionCourante,
Map modele,
/**
* Récupère les informations concernant les arbres dossiers/cdt et activités
- * @param model
*/
private void marshallArbreActivite(Map model,
TextesAccueilEtatApplication etatApplicationAccueil) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Indique si le nom du cahierDeTextes est modifiable
- * @param cahierDeTextes
- * @return
*/
private Boolean nomCahierModifiable(CahierDeTextes cahierDeTextes) {
Boolean modifiable = true
/**
* Remplis le modele avec les droits des groupes at utilisateurs
- * @param modele
- * @param cdt
- * @param secSession
- * @param params
*/
private void donneesPourAffichageDroits(Map modele,
CahierDeTextes cdt,
/**
* Traite le cas ou on a des autorites qui sont dans l'annuaire logica
* mais pas encore dans l'annuaire eliot
- * @param idNomMap
- * @return
*/
private Map<String, String> traiteAutoritesSansPersonnes(Map<String,
String> idNomMap) {
/**
* Cree le label de nom de personne qui existe dans l'annuaire Logica mais
* n'existe pas dans l'annuaire eliot
- * @param nomAffichageLogica
- * @return
*/
private String creeNomAffichageManquante(String nomAffichageLogica) {
return message(
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
/**
* Charge listes d'enseignants, matières et structures d'enseignement pour un
* établissement
- * @param etablissement
- * @return
*/
def chargeListes = {
CahierDeTextes.withTransaction {
/**
* Retourne les urls dont la fenêtre d'accès au catalogue à besoin
- * @return
*/
private Map getUrlFenetreAccesCatalogue() {
return [urlImageChercher: resource(dir: 'images', file: 'properties.gif')]
/**
* Retourne les libellés de la fenêtre d'accès au catalogue.
- * @return
*/
private Map getLibellesFenetreAccesCatalogue() {
return [
/**
* Retourne la liste de toutes les demandes d'impression
- * @return
*/
private Map getDefaultSuiviImpression() {
return gettSuiviImpression(
/**
* Retourne la liste des demandes d'impression selon les critères
- * @return
*/
private Map gettSuiviImpression(
String sortField,
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
class MenuAideTextesService extends MenuAideService {
/**
* Retourne la configuration pour l'aide en ligne
- * @return
*/
protected def getConfigAideEnLigne() {
ConfigurationHolder.config.eliot.textes.aideEnLigne.url
}
/**
- * @param autorite
* @return un dossier de test pour l'utilisateur
*/
public Dossier getDossierForAutorite(Autorite autorite) {
/**
* Retourne le dossier des cahiers de classe
- * @return
*/
public DossierRempli getMesCahiersClasse() {
DossierRempli relMesCahiersClasse =
/**
* Ajoute une association enseignant/cahierDeTextes
- * @param cahierDeTextes
- * @param enseignant
*/
def ajouteEnseignantPourCahierDeTextes(CahierDeTextes cahierDeTextes, Personne enseignant){
enseignants.put(cahierDeTextes, enseignant)
}
/**
- * @param cahierDeTextes
* @return la Personne de l'enseignant associé au cahier de textes
*/
Personne getEnseignantPourCahierDeTextes(CahierDeTextes cahierDeTextes){
/**
* Récupère le cahier de textes à partir de son identifiant
* @param cdtId l'identifiant de cdt
- * @return
*/
CahierDeTextes getCahierDeTextes(Long cdtId) {
return CahierDeTextes.get(cdtId)
/**
* Retourne toutes les activités d'un cahier de textes
- * @param cahierDeTextes
* @param inclureActivitesNonPubliees si true, les activités non publiées seront incluses dans
* la structure (false par défaut)
* @return une liste d'activité
/**
* Retourne tous les chapitres d'un cahier de textes
- * @param cahierDeTextes
* @return une liste de chapitre
*/
List<Chapitre> findAllChapitreByCahierDeTextes(CahierDeTextes cahierDeTextes) {
/**
* Récupération de tous les cahiers de textes consultables pour un utilisateur.
- * @param securiteSession
*/
List<CahierDeTextes> findAllCahiersConsultables(SecuriteSession securiteSession) {
return CahierDeTextes.withCriteria {
/**
* Retourne les cdts accessibles en écriture pour une structure, une matière
* et une autorité données
- * @param struct
- * @param autorite
- * @param paginationParams
* @return List < CahierDeTextes >
*/
List<CahierDeTextes> findAllCahierModifiablesByStructure(
/**
* Retourne le nombre de cdt modifiable par l'autorité, et pour la structure
- * @param struct
- * @param autorite
* @return un entier
*/
int countCahierModifiablesByStructure(StructureEnseignement struct,
/**
* Retourne un objet PaginatedList contenant la liste des cdt modifiables par
* une autorité et pour une structure donnée
- * @param struct
- * @param autorite
- * @param paginationParams
- * @return un objet PaginatedList
+ * @return un objet PaginatedList
*/
PaginatedList findPaginatedListCahierModifiablesByStructure(
StructureEnseignement struct,
/**
* Retourne la structure des chapitres d'un cahier de textes
- * @param cdt
* @return un ChapitreCourtStructure
*/
ChapitreCourtStructure findChapitreCourtStructureForCahierDeTextes(
/**
* Crée l'objet ChapitreCourt à partir du chapitre et de la liste des
* chapitres du cahierDeTextes
- * @param chapitre
- * @param chapitres
* @return un ChapitreCourt
*/
ChapitreCourt getStructureChapitre(Chapitre chapitre, List<Chapitre> chapitres) {
/**
* Récupèration de cahier de textes de services par emploi du temps
- * @param securieSession
- * @return
*/
Collection<RelCahierEvenement> findAllCdtServiceByJour(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
/**
* Permet de copier les ressources d'un activite vers une autre
- * @param securiteSession
- * @param activiteSource
- * @param activiteDestination
*/
private void copieRessources(SecuriteSession securiteSession,
Activite activiteSource,
/**
* Retourne les enseignants associés à chaque cdt
- * @param cdts
- * @return
*/
EnseignantsPourCahierDeTextes findEnseignantForAllCahierDeTextes(List<CahierDeTextes> cdts) {
EnseignantsPourCahierDeTextes result = new EnseignantsPourCahierDeTextes()
}
/**
- * @param securiteSession
* @return la liste des dossiers perso
*/
List<DossierInfoAffichage> findAllDossiersPerso(SecuriteSession securiteSession) {
}
/**
- * @param securiteSession
* @return la liste des dossiers archives
*/
List<DossierInfoAffichage> findAllDossiersArchive(SecuriteSession securiteSession) {
/**
* Retourne la liste des activité qui correspondent aux critères
- * @param rechercheCmd
- * @param autoriteCherchante
* @return une List<Activite>
*/
public List<Activite> getListeActivites(RechercheCommand rechercheCmd,
}
/**
- * @param rechercheCmd
* @return la Closure de classement
*/
private Closure getClosureSort(RechercheCommand rechercheCmd) {
}
/**
- * @param rechercheCmd
* @return la Closure lorsqu'on n'a que la date de fin
*/
private Closure getClosureJusque(RechercheCommand rechercheCmd) {
}
/**
- * @param rechercheCmd
* @return la Closure lorsqu'on n'a que la date de début
*/
private Closure getClosureDepuis(RechercheCommand rechercheCmd) {
}
/**
- * @param rechercheCmd
* @return la Closure quand on a les dates de début et de fin
*/
private Closure getClosureBorneDates(RechercheCommand rechercheCmd) {
}
/**
- * @param keyword
- * @param autoriteCherchante
* @return la Closure de recherche sur les mots clés
*/
private Closure getClosureKeyword(String keyword, Autorite autoriteCherchante) {
}
/**
- * @param structureId
* @return la Closure de recherche sur la structure
*/
private Closure getClosureStructure(Long structureId) {
}
/**
- * @param libelleLongMatiere
* @return la Closure de recherche sur les matières
* Attention, elle ne porte pas sur un id mais un libelleLong,
* pour pouvoir remonter des matières homonymes liées à des
/**
* Cette méthode retrouve le dossier utilisateur à partir d'un noeud de dossier
* Si ce noeud est un dossier virtuel, cette méthode emets une exception
- * @param dossier
- * @return
*/
private Dossier getDossierReel(DossierInfoAffichage dossier) {
String nodeId = dossier.getId()?.substring(1)
/**
* Inserte la relation.
- * @param dossier
- * @param autorisation
* @return relation creee
*/
RelDossierAutorisationCahier insereRelation(DossierInfoAffichage dossier,
/**
* Crée le fichier correspondant à la copie de cahier de textes d'un visa
- * @param visa
* @return le fichier créé
*/
File creeFichierCahierVise(Visa visa) throws IOException {
}
/**
- * @param visa
* @return le fichier correspondant la copie de cahier de textes d'un visa
*/
File getFichierVisa(Visa visa) throws IOException {
/**
* Crée ou récupére le fichier de cahier visé
- * @param visa
* @param creeFichier si true, le fichier est crée, si false le fichier est seulement récupéré
* @return fichier de cahier visé
*/
/**
* Retourne la liste des états de discussion dans l'ordre
- * @return
*/
List<Map> marshallAllEtatDiscussion(List<EtatDiscussion> allEtatDiscussion) {
List<Map> result = []
}
/**
- * @param code
- * @param allTypeModeration
* @return une Map décrivant le type de modération dont le code est passé
*/
private Map getTypeModerationInfoForCode(String code,
/**
* Retourne les infos pour un état
- * @param code
- * @return
*/
private Map getEtatDiscussionInfoForCode(String code, List<EtatDiscussion> etats) {
EtatDiscussion etat = etats.find {it.code == code}
/**
* Enregistre les données relatives au forum de discussion
- * @param activite
- * @param command
*/
private void enregistreDiscussion(Activite activite,
ActiviteParams activiteParams,
/**
* Crée une activité
- * @param securiteSession
* @param infos les informations sur l'activité à créer
* @return l'activité créée
* @throws AutorisationException si l'utilisateur ne dispose des permissions
/**
* Crée l'activité maison associée
- * @param activiteParams
*/
void enregistreTravailALaMaison(SecuriteSession securiteSession,
ActiviteParams activiteParams) {
/**
* Crée une activité et essaie de l'associer automatiquement à un événement
- * @param securiteSession
- * @param activiteParams
* @return l'Activite créée
* @throws AutorisationException
* @throws IllegalStateException
* - suppression des activités
* - si l'indexation est activé, l'index sera supprimé =>
* N suppression (appel à une fonction d'indexeBusiness)
- * @param activites
* @throws IllegalStateException
*
* @author bahj
* - dont l'ordre est supérieur ou égal à ordreDepart
*
* Cette méthode est utilisé pour réordonner les chapitres & activités
- * @param ordreDepart
- * @param cahierDeTextes
- * @param chapitreParent
* @author jtra
*/
private void incrementeOrdreElementsSuivants(long ordreDepart,
* - sont fils de chapitreParent (ou à la racine si null)
* - dont l'ordre est supérieur ou égal à ordreDepart
* Cette méthode est utilisé pour réordonner les chapitres & activités
- * @param ordreDepart
- * @param cahierDeTextes
- * @param chapitreParent
* @author jtra
*/
private void incrementeOrdreChapitreSuivants(long ordreDepart,
* - sont fils de chapitreParent (ou à la racine si null)
* - dont l'ordre est supérieur ou égal à ordreDepart
* Cette méthode est utilisé pour réordonner les chapitres & activités
- * @param ordreDepart
- * @param cahierDeTextes
- * @param chapitreParent
* @author jtra
*/
private void incrementeOrdreActivitesSuivantes(long ordreDepart,
}
/**
- * @param securiteSession
- * @param activiteParams
* @return l'Activite modifiée
*/
public Activite modifieActivite(SecuriteSession securiteSession,
/**
* Vérifie la validité de l'activité et déclenche les exceptions si besoin
- * @param activite
*/
private void verifieActiviteParams(ActiviteParams activiteParams)
throws ActiviteValidationException {
/**
* Teste pour chaque activité si elle possède une resource publiée
- * @param activites
* @return une Map associant à chaque activité, un boolean indiquant si elle
* possède une resource publiée
*/
/**
* Recherche la dernière activité modifiée
- * @param cdt
- * @return
*/
/**
* Retourne la dernière activité modifié d'un cahier de textes
/**
* Recherche la date de la dernière activité (maison ou classe)
- * @param dateActivite
- * @return
*/
private Date getDateDerniereActivite(DateActivite dateActivite) {
if (dateActivite) {
/**
* Recherche la dernière activité modifiée
- * @param cdt
- * @return
*/
private Activite derniereActiviteModifiee(CahierDeTextes cdt) {
List<Activite> activites = Activite.executeQuery(
* @param locale : pour une localisation donnée
* @param seulementModifiable : on peut demander uniquement les cahiers de
* textes modifiables.
- * @return
*/
public List<DossierRempli> findAllCahierParDossiers(SecuriteSession securiteSession,
Locale locale = null,
/**
* Rend un arbre de cahier de textes complet à partir d'une liste de noeuds ouverts
- * @return
*/
public List<DossierRempli> getArbreCdtDatas(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
/**
* Retourne une instance de noeud de dossier
- * @param securiteSession
* @param dossierId : id du dossier
* @param ordre : à quelle position on veut le placer
* @param anneeScolaire : éventuelle année scolaire associée
- * @return
*/
public DossierInfoAffichage creerNodeForNodeId(SecuriteSession securiteSession,
String dossierId,
/**
* Récupère la classe du noeud dossier correspondant à l'id
- * @param dossierId
- * @return
*/
public Class findNodeClassForNodeId(String dossierId) {
Long id = Long.parseLong(dossierId)
/**
* True s'il s'agit de dossier d'archivage
- * @param nodeId
- * @return
*/
public Boolean isNodeArchive(String nodeId) {
try {
/**
* Calcule l'id d'un noeud de cahier de texte à partir de son numéro
- * @param node
- * @return
*/
public String addPrefixeNodeC(Long node) {
return NODE_TYPE_CDT + node.toString()
* On part du principe que le cahiers de texte passé en paramètre est
* accessible à l'autorité passée en paramètre. Attention, aucun contrôle
* n'est effectué par la méthode à ce sujet.
- * @param cahier
- * @param autorite
- * @return
*/
public Boolean isCahierPartage(CahierDeTextes cahier, Autorite autorite) {
* Indique si le cahier de texte est visé ou pas
* L'icône « visé » n'est valable que pour l'enseignant propriétaire du cahier
* et le groupe direction.
- * @param cahier
- * @param securiteSession
- * @return
*/
private Boolean isIconeCahierVise(CahierDeTextes cahier, SecuriteSession securiteSession) {
* L'icône « supp » n'est valable que pour les utilisateurs auquel
* le cahier à été partagé
*
- * @param securiteSession
- * @param cahier
* @return le code CSS
*/
// TOREFACT : 0016328: Convertir les méthodes de rendu JSON de l'arbre dossier/cdt en converter
/**
* Retourne les icones des cdt
- * @param securiteSession
- * @param cahiers
* @return une Map associant
*/
public IconesPourCahierDeTextes getAllIconesForAllCdt(
/**
* Retourne les icones associées aux cdt privés
- * @param cahiers
* @return une Map associant à chaque cdt privé, la classe de son icone
*/
IconesPourCahierDeTextes getAllIconesForAllCdtPrives(SecuriteSession securiteSession,
/**
* Retourne les icones associées aux cdt de classe ou cdts archives
- * @param securiteSession
- * @param cahiers
* @return une Map associant à chaque cdt, la classe de son icone
*/
IconesPourCahierDeTextes getAllIconesForAllCdtDeClasse(
/**
* Récupère l'utilisateur associé à une session
- * @param securiteSession
- * @return
*/
private Autorite utilisateur(SecuriteSession securiteSession) {
return (Autorite) SessionUtils.utilisateur(securiteSession)
/**
* Ajoute une association cdt/icone
- * @param cahierDeTextes
- * @param icone
*/
def ajouteIconeCahierDeTextes(CahierDeTextes cahierDeTextes, String icone){
iconeCdts.put(cahierDeTextes, icone)
/**
* Ajoute une liste d'association à la liste existante
- * @param iconesPourCahierDeTextes
*/
def ajouteListeIconesPourCahierDeTextes(IconesPourCahierDeTextes iconesPourCahierDeTextes){
this.iconeCdts += iconesPourCahierDeTextes.getIconeCdts()
}
/**
- * @param cahierDeTextes
* @return retourne l'icone associée au cdt
*/
String getIconeForCahierDeTextes(CahierDeTextes cahierDeTextes){
/**
* Traduction i18n - assure la traduction de code i18n en fonction de locale
* comme dans un controleur.
- * @param code
- * @param args
- * @return
*/
// TOREFACT : 0016328: Convertir les méthodes de rendu JSON de l'arbre dossier/cdt en converter
public String message(String code, Object[] args = []) {
/**
* propriétaire du dossier
- * @return
*/
public Autorite getProprietaire() {
this.proprietaire
/**
* propriétaire du dossier
- * @param autorite
*/
public void setProprietaire(Autorite autorite) {
this.proprietaire = autorite
/**
* Rend un arbre d'activités complet à partir d'une liste de noeuds ouverts
- * @param etatArbre
- * @return
*/
public List getArbreActivitesDatas(SecuriteSession securiteSession,
EtatArbreActivite etatArbre) {
/**
* Rend un arbre d'activités complet à partir d'une liste de noeuds ouverts
- * @param chapitreActiviteParCahier
* @param etatArbre*
- * @return
*/
public List getArbreActivitesDatas(ChapitreActiviteParCahier chapitreActiviteParCahier,
EtatArbreActivite etatArbre) {
}
/**
- * @param cahierDeTextesContenuElements
- * @param chapitre
* @return la liste ordonnées des éléments fils de chapitre
*/
private List extraitElementsFilsOrdonnes(List<CahierDeTextesContenuElement> cahierDeTextesContenuElements,
}
/**
- * @param chapitre
* @return une Map représentant le chapitre
*/
private Map serialiseChapitre(Chapitre chapitre,
}
/**
- * @param noeuds
* @return la liste des chapitres correspondant aux noeuds
* @deprecated
*/
/**
* Déclenche l'exécution de tous les batchs de bascule d'année
- * @param nouvelleAnnee
*/
TextesBasculeAnneeRapport executeBascule(SecuriteSession securiteSession,
BasculeAnneeInfo basculeAnneeInfo
/**
* Re-index le contenu de CDT. Les erreurs sont loggué et ne sont pas remontés.
- * @param securiteSession
- * @param cahierDeTextes
*/
private void reindexeContenuCDT(SecuriteSession securiteSession,
CahierDeTextes cahierDeTextes,
/**
* Re-index droits de CDT. Les erreurs sont loggué et ne sont pas remontés.
- * @param securiteSession
- * @param cahierDeTextes
- * @param etablissementIDs
*/
private void reindexeDroitsCDT(SecuriteSession securiteSession,
CahierDeTextes cahierDeTextes,
/**
* Cherche les etablissements de la cite scolaire dans laquelle se trouve
* la structure d'enseignement
- * @param structureEnseignement
- * @return
*/
List<Etablissement> getEtablissementsCiteScolaire(StructureEnseignement structureEnseignement) {
return citeScolaireService.
/**
* Récupère la liste des cahiers de textes de services de la structure d'enseignement
*
- * @param structureEnseignement
* @return cahierDeTextes : la liste de cahier de texte de service
*
*/
/**
* Supprimer toutes les anciennes autorisations de cdt
- * @param cahierDeTextes
*
*/
void supprimeAutorisations(CahierDeTextes cahierDeTextes,
/**
* Supprimer les autorisations des groupes d'enseignement de cdt
- * @param cahierDeTextes
* @deprecated les droits concernant les groupes de scolarité, toutes applications confondues,
* sont basculés par le module eliot-scolarite
*/
/**
* Ajoute les droits en consultation de l'autorité en paramètre
* sur le cahier de textes de service ou un cahier prive vise
- * @param cahierDeTextes
- * @param autorite
*
*/
void ajouteDroitConsultation(CahierDeTextes cahierDeTextes,
/**
* Retourne l'autorité du personnel de direction de l'établissement en paramètre
- * @param etablissement
*
*/
Autorite getPersonnelDeDirection(Etablissement etablissement,
* Mis à jour les propriétés suivantes de cahier de textes:
* - description: ajoute les informations contenues dans le service
* - anneeScolaire: mis à jour l'année scolaire
- * @param cahierDeTextes
* @param cahierDeTextesType type de cahier a traiter
* (on ne peut pas se fier sur cahier.type() dans le contexte de bascule d'annee)
* @param anneeScolaireAPositionner anne scolaire a positionner
/**
* Vérifie que la securiteSession correspond au Correspondant de Deploiement
* et retourne une securiteSession de type Eliot (systeme)
- * @param securiteSession
* @return SecuriteSession - ecuriteSession de type Eliot
* @throws org.lilie.services.eliot.securite.AutorisationException
* @author bper
/**
* Liste des dossiers de l'arbre des cahiers de textes
- * @param securiteSession
- * @param locale
- * @return
*/
public ActeurAllCahierPersonnalise allDossiersVides(SecuriteSession securiteSession,
Locale locale
/**
* Liste des dossiers et des cahiers de textes de l'arbre des cahiers de textes
- * @param securiteSession
- * @param locale
* @deprecated
- * @return
*/
public ActeurAllCahierPersonnalise allDossiersAvecCahiers(SecuriteSession securiteSession,
Locale locale) {
/**
* Vérifie le droit de consultation des cahiers de textes sur l'établissement
- * @param securiteSession
- * @param etablissement
*/
public void verifieAutorisationConsultationEtablissement(SecuriteSession securiteSession,
Etablissement etablissement) {
/**
* Indique si l'utilisateur courant a le droit de créer des cahiers de textes
- * @param securiteSession
- * @return
*/
public boolean isCreationCahierDeTextes(SecuriteSession securiteSession) {
!(
/**
* Indique si la présentation par emploi du temps est active pour l'utilisateur courant
- * @param securiteSession
- * @param acteurAllCahierPersonnalise
- * @return
*/
public boolean isPresentationEmploiDeTempsActive(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise) {
/**
* indique si l'utilisateur a le droit à la vue par emploi du temps
- * @param securiteSession
- * @return
*/
public boolean hasUtilisateurDroitPresentationEmploiDuTemps(SecuriteSession securiteSession) {
boolean ajouterPresentationParTemps =
/**
* Indique que le session courante est celle d'1 directeur ou d'un admin local
- * @return
*/
public boolean isSessionDirOrAdml(SecuriteSession securiteSession) {
return (securiteSession.hasFonctionIn(
/**
* Vérifie si la securiteSession est directeur ou adml et que le cahier est un cahier de classe
- * @param securiteSession
- * @param cahier
- * @param messageErreur
*/
public boolean estDirecteurOuAdmlSurCahierClasse(SecuriteSession securiteSession,
CahierDeTextes cahier) {
/**
* Permet de parser un boolean en provenance des parametres d'une action de controlleur
- * @param params
* @param nom : nom de la valeur
- * @return
*/
public Boolean parseBoolean(Map params, String nom) {
(params[nom] != null) ? Boolean.parseBoolean(params[nom]) : null
/**
* Parse un etablissement
- * @param params
- * @return
*/
public Etablissement parseEtablissement(Map params) {
// Get Etablissement
/**
*
- * @param params
- * @return
*/
public StructureEnseignement parseStructureEnseignement(Map params) {
/**
*
- * @param params
- * @return
*/
public Personne parseEnseignant(Map params) {
Personne enseignant = null
/**
*
- * @param params
- * @return
*/
public Matiere parseMatiere(Map params) {
/**
*
- * @param params
- * @return
*/
public DossierInfo parseDossierInfo(Map params) {
/**
* Réindexe le cahier de textes
- * @param securiteSession
- * @param cahierDeTextes
*/
private void reindexe(SecuriteSession securiteSession, CahierDeTextes cahierDeTextes) {
/**
* Permet de déplacer les chapitre/activité d'un cahier de texte source vers un cahier de textes cible
- * @param source
- * @param cible
*/
private void deplaceChapitreActivite(CahierDeTextes source, CahierDeTextes cible) {
/**
* Recherche le plus grand numéro d'ordre des chapitre/activite du cahier de texte
- * @param cible
- * @return
*/
private Long findMaxOrdreCahierDeTextes(CahierDeTextes cible) {
Long maxChapitreOrdre =
/**
* Indique si l'utilisateur associé à la session est propriétaire du cahier
- * @param securiteSession
- * @param cahier
- * @return
*/
private Boolean estProprietaire(SecuriteSession securiteSession,
CahierDeTextes cahier) {
/**
* Retourne la liste de cahiers qui sont incorporés dans cahier
- * @param cahier
- * @return
* @author bahj
*/
List<CahierDeTextes> findAllCahierByParentIncorporation(CahierDeTextes cahier) {
/**
* Récupération etat page d'accueil + ouverture noeud par défaut
- * @param securiteSession
- * @param acteurAllCahierPersonnalise
- * @param params
- * @return
*/
public TextesAccueilEtatApplication gestionEtat(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
/**
* Récupère les données courante de l'arbre des activités
- * @return
*/
public List getEtatArbreActivites(SecuriteSession securiteSession) {
/**
* Récupère l'etat de la page d'accueil
- * @return
*/
public TextesAccueilEtatApplication getEtatAccueil() {
return (TextesAccueilEtatApplication) etatApplicationSessionService.getEtatApplication(
/**
* Retourne l'état de la page d'accueil
- * @return
*/
private TextesAccueilEtatApplication getEtatAccueil(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise) {
/**
* Retourne l'état de l'application par défaut selon les règles métier
- * @return
*/
public TextesAccueilEtatApplication getEtatAccueilParDefaut(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise) {
/**
* Enregistre l'état en provencance du FO
- * @param id
- * @param params
*/
public void saveStateFrontOffice(String id, String params) {
TextesAccueilEtatApplication etatApplicationAccueil = new TextesAccueilEtatApplication()
* Gestion de la consolidation de l'état de la page d'accueil avec un item (CDT,
* Activité,chapitre) passé en paramètre
*
- * @param securiteSession
- * @param params
*/
public void ouvertureAccueilAvecParametresUrl(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
/**
* Ouverture de l'activité passé en paramètre
- * @param activiteId
*/
private void ouvreActivite(SecuriteSession securiteSession, Activite activite) {
TextesAccueilEtatApplication etatChapitre =
/**
* Ouverture du chapitre passé en paramètre dans l'url
- * @param chapitreId
*/
private void ouvreChapitre(SecuriteSession securiteSession, Chapitre chapitre) {
TextesAccueilEtatApplication etatChapitre =
/**
* Ouverture du cahier de textes passé par l'url
- * @param cahierDeTextesId
*/
private void ouvreCahierDeTextes(SecuriteSession securiteSession, CahierDeTextes cahierDeTextes) {
TextesAccueilEtatApplication etatCahierDeTextes =
/**
* permet de consolider l'état de l'accueil
- * @param etatApplication
*/
private TextesAccueilEtatApplication consolideEtat(TextesAccueilEtatApplication etatApplication) {
etatApplicationSessionService.consolideEtat(
/**
* Assure la sérialisation dossiers utilisateurs
- * @param relCdtDossierInfos
- * @param securiteSession
- * @return
*/
private List serializeDossiersCahiersUtilisateur(List<DossierRempli> relCdtDossierInfos,
SecuriteSession securiteSession
* retourne l'objet d'état de la page d'accueil des cahiers de textes avec
* un cahier de textes ouvert
* @param autorite : personne connectée
- * @param cahierDeTextes
* @return un objet d'état de la page d'accueil
*/
public TextesAccueilEtatApplication creeEtatCahierDeTexte(Autorite autorite,
/**
* retourne le json du cahier de textes selectionné
- * @param cahierDeTextes
- * @return
*/
private String jsonCdtSelectionne(CahierDeTextes cahierDeTextes) {
'{"name":"stateIdCdtSelectionneArbreDossier","value":"c' +
/**
* Création des données json correspondantes à l'ouverture d'un cahier de textes
* @param autorite :
- * @param cahierDeTextes
* @return un json
*/
private String jsonCahiersDeTextes(Autorite autorite,
* Recherche du dossier contenant un cahier de textes
* @param cahierDeTextes : cahier de textes dont on recherche le dossier
* @param autorite : propriétaire du cahier de textes
- * @return
*/
private Long rechercheIdDossier(CahierDeTextes cahierDeTextes,
Autorite autorite) {
/**
* recherche l'autorisation associée au propriétaire du cahier de textes
- * @param cahierDeTextes
- * @param autorite
* @return l'autorisation associée au cahier de textes
*/
private Autorisation findAutorisationProprietaireDuCahierDeTextes(CahierDeTextes cahierDeTextes,
/**
* Recherche l'autorisation associé au cahier de texte
- * @param cahierDeTextes
- * @param autorite
- * @return
*/
private Autorisation findAutorisationSurCahierDeTextes(CahierDeTextes cahierDeTextes,
Autorite autorite) {
/**
* Permet au backoffice de modifier l'arbre
- * @param noeudId
- * @param chemin
* @author othe
*/
public void cree(Long noeudId, List<Long> cheminIds) {
/**
* Nom du noeud root pour ce type d'arbre
- * @return
*/
public static String getRootId() {
"aroot"
/**
* Permet au backoffice de modifier l'arbre
- * @param noeudId
- * @param chemin
* @author othe
*/
//TOREFACT : 0016113: Redéfinition des liaisons BO/FO
/**
* Nom du noeud root pour ce type d'arbre
- * @return
*/
private String getRootId() {
"drootTemps"
/**
* Permet au backoffice de modifier l'arbre
- * @param noeudId
- * @param chemin
* @author othe
*/
public void cree(Long noeudId, List<Long> cheminIds) {
/**
* Nom du noeud root pour ce type d'arbre
- * @return
*/
private String getRootId() {
CODE_ROOT
/**
* Permet de créer un document docbook composé de plusieurs cahiers de textes
* à partir d'un template et d'un modele
- * @param template
- * @param model
- * @return
*/
public String renderDocbookPourPlusieursCdt(Map model) {
return docbookTemplateService.render(MODELE_PLUSIEURS_CDT, model)
/**
* Permet de créer un document docbook composé d'un cahier de textes
* à partir d'un template et d'un modele
- * @param template
- * @param model
- * @return
*/
public String renderDocbook(Map model) {
return docbookTemplateService.render(MODELE_UN_CDT, model)
/**
* création d'un document pdf à partir d'un template gsp + des données contenu
* dans model; Version prévue pour gérer plusieurs cahiers de textes
- * @param template
- * @param model
- * @return
*/
public OutputStream renderPdfPourPlusieursCdt(Map model) {
String docbookXML = renderDocbookPourPlusieursCdt(model)
/**
* création d'un document pdf à partir d'un template gsp + des données contenu
* dans model
- * @param template
- * @param model
- * @return
*/
public OutputStream renderPdfPourUnCdt(Map model) {
String docbookXML = renderDocbook(model)
/**
* Récupération de l'url du webservices
- * @return
*/
private String getUrl() {
String urlServeur = grailsApplication.config.eliot.url.webservices
/**
* Recherche la prochaine demande d'impression pour plusieurs cahiers de textes
- * @return
*/
private DemandeTraitement findDemandeImpressionPlusieursCahiersDeTextes() {
demandeTraitementService.getDemandeTraitementPrioriteMax(
/**
* Recherche la prochaine demande d'impression pour un cahier de textes
- * @return
*/
private DemandeTraitement findDemandeImpressionUnSeulCahierDeTextes() {
demandeTraitementService.getDemandeTraitementPrioriteMax(
/**
* Peut voir activités publiés du cahier de textes
- * @param securiteSession
- * @param cahierDeTextes
- * @return
*/
private boolean peutVoirActiviteNonPubliee(SecuriteSession securiteSession,
CahierDeTextes cahierDeTextes) {
/**
* enregistre le fichier pdf d'impression
- * @param demandeTraitement
- * @param documentPDF
*/
public void saveFichierPDF(DemandeTraitement demandeTraitement, OutputStream documentPDF) {
FileOutputStream fichierPDF = getFichierOutputStream(demandeTraitement)
/**
* enregistre le fichier log lié à l'impression
- * @param demandeTraitement
- * @param documentPDF
*/
public void saveFichierLog(DemandeTraitement demandeTraitement, OutputStream documentLog) {
FileOutputStream fichierLog = getFichierOutputStreamLog(demandeTraitement)
/**
* enregistrement d'un fichier en zone de stockage
- * @param documentLog
- * @param fichierLog
*/
private void saveFichier(OutputStream documentLog, FileOutputStream fichierLog) {
ByteArrayOutputStream bo = (ByteArrayOutputStream) documentLog
/**
* Mets la partie Time de Date a 0
- * @param date
- * @param calendar
- * @return
*/
Date extraisPartieDate(Date date, Calendar cal) {
cal.setTime(date)
/**
* Récupère les données pour l'impression
- * @param cdt
- * @param avecChapitreVide
- * @param dateDebut
- * @param dateFin
- * @return
*/
public ElementLivre findDonneesImpression(
CahierDeTextes cdt,
/**
* Ajoute les cahiers de textes vides pour le cahier de textes
- * @param cdt
- * @param elementCahierDeTextes
*/
private void ajouteChapitresVide(CahierDeTextes cdt, ElementCahierDeTextes elementCahierDeTextes) {
/**
* Imprime un seul cahier de textes
- * @param demande
- * @param param
- * @param cdt
*/
public void imprimeUnCdt(
DemandeTraitement demande,
/**
* Imprime plusieurs cahiers de textes
- * @param demande
- * @param param
- * @param cdts
*/
public void imprimePlusieursCdt(
DemandeTraitement demande,
/**
* Permet de logger les fichiers docbook générés
- * @param donnees
- * @param plusieursCDT
- * @param demande
*/
private void logDocbook(Map donnees, boolean plusieursCDT, DemandeTraitement demande) {
if (!ConfigurationHolder.config.eliot.textes.impression.docbook.log) {
/**
* Liste des ressources
- * @return
*/
public List<RessourceInfo> getRessources() {
/**
* Retourne le type d'activité
- * @return
*/
public String typeActivite() {
String nom = getActivite()?.typeActivite?.libelle
/**
* Retourne le nom du contexte
- * @return
*/
public String contexte() {
getActivite()?.contexteActivite?.nom
/**
* Retourne le code de l'activité
- * @return
*/
public String codeActivite() {
getActivite()?.contexteActivite?.code
/**
* indique si l'on a des dates à imprimer
- * @return
*/
public boolean hasDates() {
(getActivite()?.dates?.size() > 0)
/**
* Indique si le noeud est vide (ne contient aucun enfant)
- * @return
*/
public boolean isEmpty() {
enfants.size() == 0
/**
* Est ce que le livre contient une préface ?
- * @return
*/
public boolean isPreface() {
(
/**
* Indique qu'il s'agit d'un livre sans sommaire
- * @return
*/
public String avecSommaire() {
/**
* Indique si le cahier de textes est vide
- * @return
*/
public boolean isEmpty() {
enfants.size() == 0
/**
* corrige le fichier docbook en cas d'incohérence
* @param xml : le fichier xml à corriger
- * @return
*/
private String corrigeDocbook(String xml) {
/**
* Permet de transformer un document dom xml en chaine
- * @param doc
- * @return
*/
private String xmlDocumentToString(org.w3c.dom.Document doc) {
/**
* parcourt et corrige l'arbre du dom d'un document xml
- * @param nodeList
*/
private void parcourtEtCorrige(org.w3c.dom.NodeList nodeList) {
/**
* Création d'un noeud listitem pour "réparer" les listes imbriquées
- * @param node
*/
private void reparerListesImbriquees(Node node) {
Element elementListe = node.getOwnerDocument().createElement(TAG_LISTITEM)
/**
* Création de la configuration du moteur de rendu des template pour
* docbook
- * @return
*/
private Configuration creeConfigFreeMarker() {
Configuration cfg = new Configuration()
/**
* Ajout le composant de traitement de la balise @description
- * @param model
*/
private void ajouteTransformationHtml(Map model) {
DescriptionDirective descriptionDirective = new DescriptionDirective()
/**
* Construction d'un dom à partir d'une chaine xml
- * @param xml
- * @return
*/
private static Document loadXMLFrom(String xml) {
InputStream is = new ByteArrayInputStream(xml.getBytes())
/**
* Recherche les noeuds equation/math pour les transformer en mathML
- * @param document
- * @param nodeList
*/
private void rechercheEquation(Document document, NodeList nodeList) {
nodeList.each { Node node ->
/**
* Trasnformation des noeuds contenant de l'asciiMath en MathML
- * @param document
- * @param node
*/
private void transformeEquation(Document document, Node node) {
String equationAsciiMath = node.firstChild.nodeValue
/**
* Convertion d'un dom en string
- * @param document
- * @return
*/
private String document2String(Document document) {
/**
* Convertion des noeuds xml contenant des chaines asciimath en mathml
- * @param xml
- * @return
*/
private String asciiMath2MathML(String xml) {
Document doc = loadXMLFrom(xml)
/**
* Transforme une description ecrite par tinyMCE en docbook
- * @param description
- * @return
*/
private String transformDescription(String description) {
String htmlRoot = FeuillesDeStyle.table + "<html>" + description + "</html>"
/**
* Retourne le feuille de style de convertion
- * @return
*/
private StreamSource feuilleDeStyle() {
InputStream fichierXsl = stringToInputStream(FeuillesDeStyle.xsl)
/**
* Convertion d'une chaine vers un flux
- * @param texte
- * @return
*/
public InputStream stringToInputStream(String texte) {
return new ByteArrayInputStream(texte.getBytes("UTF-8"));
/**
* convertion du fichier html contenu dans un flux vers un fichier docbook contenu
* dans un flux
- * @param is
- * @return
*/
private OutputStream convertionDocbook(InputStream is) {
* Retourne les information de construction du menu
* @param pageCourante la page courante
* @param securiteSession la session de sécurité Eliot de l'utilisateur
- * @return
*/
public MenuInfo getMenuInfo(SecuriteSession securiteSession,
Page pageCourante) {
LocalPersonneService localPersonneService
/**
- * @param securiteSession
- * @param etablissement
- * @param personne
- * @param matiere
- * @param dossierType
- * @param dossierId
* @return les contenus des combos de filtrage pour la recherche des cdts
*/
Map getContenusCombos(SecuriteSession securiteSession,
}
/**
- * @param etablissement
- * @param personne
- * @param matiere
* @return la liste des structures selon les critères
*/
private List<StructureEnseignement> getListeStructures(Etablissement etablissement,
/**
* Retourne les informations utiles à textes concernant les structures
* d'enseignement d'un établissement
- * @param etablissement
* @return une liste de StructureEnseignement
*/
private List<StructureEnseignement> findAllStructureEnseignementByEtablissement(
/**/
/**
- * @param etablissement
- * @param personne
- * @param matiere
* @return la liste des matières selon les critères
*/
private List<Matiere> getListeMatieres(SecuriteSession securiteSession,
}
/**
- * @param etablissement
- * @param personne
- * @param matiere
* @return la liste des profs selon les critères
*/
private List<Map> getListeProfs(Etablissement etablissement,
/**
* Liste les cahiers de texte non vides
- * @param cdts
- * @return
*/
private Set listeCdtNonVides(List<Long> cdtsId) {
/**
* True si l'utilisateur loggue est le propritaire de cahier trouve
- * @return
*/
public Boolean utilisateurEstProprietaire() {
allAutorisation.any {
/**
* Indique si le propriétaire va être supprimé
- * @return
*/
private boolean proprietaireAccesRestreint() {
proprietaire?.aUnAccesRetreint()
/**
* Retrouve la classe css de l'icône associée au cahier de textes
- * @param securiteSession
- * @return
*/
public String getIconeCss(SecuriteSession securiteSession) {
if (cahierDeTextes.estCahierDeService() || cahierDeTextes.estCahierArchive()) {
* Indique si le cahier de texte est visé ou pas
* L'icône « visé » n'est valable que pour l'enseignant propriétaire du cahier
* et le groupe direction.
- * @param cahier
- * @param securiteSession
- * @return
*/
private Boolean isIconeCahierVise(CahierDeTextes cahier,
SecuriteSession securiteSession) {
/**
* Recherche la liste des cahiers de textes personnalisés contenu dans un dossier correspondant à la session
- * @param securiteSession
- * @param dossier
- * @param seulementModifiable
- * @return
*/
public List<CahierDeTextesPersonnalise> getAllCahierDeTextesPersonnalisePourDossier(SecuriteSession securiteSession,
Dossier dossier,
/**
* Retrouve les activités contenues dans un chapitre
- * @param chapitre
- * @return
*/
public List<Activite> findAllActiviteForChapitre(Chapitre chapitre) {
/**
* Retrouve toutes les activités des chapitres
- * @param chapitres
- * @return
*/
public List<Activite> findAllActivitesForAllChapitres(List<Chapitre> chapitres) {
if (!chapitres) {
/**
* Cherche les chapitre enfants du chapitre parent
* @param chapitre : parent
- * @return
*/
public List<Chapitre> findAllChapitresEnfantsForChapitre(Chapitre chapitre) {
}
/**
- * @param chapitres
* @return les chapitres enfants des chapitres passés en paramètre
*/
public List<Chapitre> findAllChapitresForAllChapitres(Set<Chapitre> chapitres) {
/**
* Cherche les chapitres à la racine
- * @return
*/
public List<Chapitre> findAllChapitresSansChapitre() {
/**
* Fait la liste des chapitre et activite sous un chapitre
- * @param chapitre
- * @return
*/
public List toList(Chapitre chapitre) {
/**
* Retrouve toutes les informations des chapitres et activités contenus dans le cahier de textes
- * @param cahierDeTextes
- * @return
*/
public ChapitreActiviteParCahier findChapitreActiviteParCahier(SecuriteSession securiteSession,
CahierDeTextes cahierDeTextes,
/**
* Pourcentage de fichiers DB
- * @return
*/
int getFichierDbPct() {
if((fichierDbNb + fichierFileNb) == 0){
/**
* Pourcentage de fichiers FILE
- * @return
*/
int getFichierFilePct() {
if((fichierDbNb + fichierFileNb) == 0){
/**
* Suppression des ressources associées à une liste d'activités
- * @param activites
*/
public void supprimeRessourcesActivites(List<Activite> activites) {
// Suppression des ressources de l'activités
/**
* Cree et indexe une ressource
- * @param securiteSession
- * @param params
- * @return
*/
Ressource creeRessource(SecuriteSession securiteSession,
RessourceParams params) {
/**
* Supprime une ressource
- * @param ressource
- * @return
*/
@SuppressWarnings('CatchException') // JTRA : On traite toutes les exceptions pouvant être levée par l'indexation pour rendre les erreurs non bloquantes
public Ressource supprimeRessource(Ressource ressource) {
/**
* Modifie le statut de publication de la ressource
- * @param ressourceParams
* @return la ressource modifiée
*/
public Ressource modifieRessourcePublication(SecuriteSession securiteSession,
/**
* Retourne une ressource
* @param idRessource id de ressource
- * @return
* @author msan
*/
public Ressource getRessource(Long idRessource) {
/**
* Sauvegarde une ressource et indexe la
- * @param ressource
* @return ressource. null si l'enregistrement echoue
*/
@SuppressWarnings('CatchException') // JTRA : On traite toutes les exceptions pouvant être levée par l'indexation pour rendre les erreurs non bloquantes
/**
* True si la ressource est visible pour l'utilisateur loggue
- * @param securiteSession
- * @param ressource
- * @return
* @author msan
*/
Boolean estRessourceVisible(SecuriteSession securiteSession, Ressource ressource) {
/**
* Lance la migration des ressources dans un temps limité
- * @param tempsLimite
- * @param heureNb
- * @param minuteNb
*/
void migreRessources(RessourceMigrationDemande demande) {
RessourceMigrationRapport rapport = new RessourceMigrationRapport(
}
/**
- * @param demande
* @return le nom du fichier de rapport correspondant à la demande
*/
private getNomFichier(RessourceMigrationDemande demande,
/**
* Enregistre le rapport sur le disque
- * @param rapport
- * @param chemin
- * @return
*/
private enregistreRapport(RessourceMigrationRapport rapport, String chemin) {
File fichierRapport = new File(chemin)
/**
* Migre les fichiers de la liste dans un temps limite
- * @param fichierIds
- * @param tempsLimite
- * @param heureNb
- * @param minuteNb
*/
private migreListe(List<Long> fichierIds,
RessourceMigrationDemande demande,
/**
* Ajoute le fichier correctement traité au rapport
* @param fichier : le fichier correctement traité
- * @param rapport
*/
private ajouteFichierTraiteAuRapport(RessourceMigrationFichierTraite ressourceMigrationFichierTraite,
RessourceMigrationRapport rapport) {
* Méthode mise en place pour loguer la stracktrace de l'exception compte tenu
* du fait que Jackrabbit retourne une exception qui est "cause d'elle-même",
* ce qui génère une stacktrace infinie...
- * @param e
- * @return
* @author jbui
*/
private String getStacktrace(Exception e) {
List<RessourceMigrationFichierEnErreur> fichierEnErreur = []
/**
- * @param demandeur
- * @return
*/
RessourceMigrationRapport(Autorite demandeur) {
this.dateHeureDebut = new Date()
/**
* setter
- * @param date
*/
void setDate(Date date) {
this.date = date
}
/**
- * @param node
* @return le texte brut contenu par le node et ses sous-nodes
*/
private String getNodeText(Node node) {
/**
* Recherche les activités pour la vue journalière
- * @param securiteSession
* @param rechercheCmd : les critères
* @return List < CdtAct >
*/
/**
* Collecte les données nécessaires à la création de la liste de dto
- * @param securiteSession
- * @param rechercheCommand
* @return un DataVueJournaliere
*/
DataVueJournaliere getDataVueJournaliere(SecuriteSession securiteSession,
/**
* Construit la liste des CdtAct
- * @param activites
- * @param rechercheCmd
* @return une List<CdtAct>
*/
private List<CahierDeTextesActiviteInfo> getCdtActs(DataVueJournaliere dataVueJournaliere) {
}
/**
- * @param securiteSession
- * @param activite
- * @param rechercheCmd
* @return une liste d'CdtAct en fonction de l'activité
*/
private List<CahierDeTextesActiviteInfo> getCdtActsForActivite(
}
/**
- * @param securiteSession
- * @param activite
- * @param rechercheCmd
* @return une liste d'CdtAct en fonction de la date
* d'activité en classe
*/
/**
* Créer un objet CdtAct à partir de tous type d'activité
* (maison ou classe)
- * @param dataVueJournaliere
- * @param activite
- * @param dateActivite
* @return un CdtAct
*/
private CahierDeTextesActiviteInfo getCdtActForActiviteTousTypes(
}
/**
- * @param securiteSession
- * @param activite
- * @param rechercheCmd
* @return une liste d'CdtAct en fonction de l'activité maison
*/
private CahierDeTextesActiviteInfo getCdtActForActiviteMaison(
}
/**
- * @param activite
* @return la date d'échéance de l'activité, ou null
*/
private Date getDateEcheance(Activite activite) {
/**
* Verifie que la plage de recherche ne depasse pas 1 mois et 1 jour
- * @param depuis
- * @param jusque
- * @return
*/
Boolean verifiePlageRecherche(Date depuis, Date jusque) {
Calendar cal = GregorianCalendar.getInstance()
/**
* Convertion des noeuds xml contenant des chaines asciimath en mathml
- * @param xml
- * @return
*/
private String asciiMath2MathML(String xml) {
Document doc = loadXMLFrom(xml)
/**
* Verifie que les proprietes de ressources importees sont pareilles
* comme des ressources originelles
- * @param activiteOriginale
- * @param activiteImportee
*/
void compareRessourcesImportees(Activite activiteOriginale, Activite activiteImportee) {
List<Ressource> ressourcesOriginales = Ressource.findAllByActivite(
/**
* Verifie que les proprietes des fichiers sont pareilles
- * @param fichierA
- * @param fichierB
*/
void compareFichier(Fichier fichierA, Fichier fichierB) {
if (fichierA == null && fichierB == null) {
/**
* Crée un service minimal
* @param matiere matière
- * @param structureEnseignement
* @param origine de service
* @author msan
* @author mjao
}
/**
* Attache service à toutes les périodes de la structure
- * @param structureEnseignemen
- * @param service
* @autor mjao
*/
private void attacheService(StructureEnseignement structureEnseignement, Service service) {
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
* @return RelPeriodeService
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @return Enseignement
* @author mjao
*/
/**
* Crée un service minimal
* @param matiere matière
- * @param structureEnseignement
* @param origine de service
* @author msan
* @author mjao
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
* @return RelPeriodeService
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
}
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @return Enseignement
* @author mjao
*/
/**
* Permet de faire un dump hexa d'une chaine de caractères
- * @param chaine
*/
private void dumpString(String chaine) {
/**
* Initialisation des cahiers
- * @return
*/
private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersEtabDossierArchives() {
return [
/**
* Initialisation des cahiers
- * @return
*/
private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersEnseignant() {
return [
/**
* Initialisation des cahiers
- * @return
*/
private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersMatiere() {
return [
/**
* Initialisation des cahiers
- * @return
*/
private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersStructure() {
return [
/**
* Initialisation des cahiers
- * @return
*/
private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersVise() {
return [
\r
/**\r
* Effectue la recherche des documents\r
- * @param docIds\r
- * @param niveauDetailDocument\r
- * @param motsCles\r
*/\r
private void chercheDocs(List<String> docIds, List<String> motsCles = null) {\r
catalogueSessionService.findAllDocumentByCriteria(\r