CahierDeTextesType type // cahier prive, cahier de service , cahier archive
CahierDeTextesImport cahierDeTextesImport
Etablissement etablissement
+ Boolean estFusionne = Boolean.FALSE // par défaut
+ Boolean estMasque = Boolean.FALSE // par défaut
private Autorite proprietaire
private Personne proprietairePersonne
]
String toString() {
- return "${id}"
+ return "${id}, vide : " + estVide()
}
/**
int hashCode() {
return (id != null ? id.hashCode() : 0);
}
+
+ /**
+ * indique si le cahier de textes est visible
+ * @return
+ */
+ boolean estVisible() {
+
+ // si cahier de texte maitre
+ if ((estFusionne) && (!parentIncorporation)) {
+ return true
+ }
+
+ !(estFusionne || estMasque)
+ }
+
+
}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ ~ This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ ~
+ ~ Lilie is free software. You can redistribute it and/or modify since
+ ~ you respect the terms of either (at least one of the both license) :
+ ~ - under the terms of the GNU Affero General Public License as
+ ~ published by the Free Software Foundation, either version 3 of the
+ ~ License, or (at your option) any later version.
+ ~ - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ ~ License, or any later version
+ ~
+ ~ There are special exceptions to the terms and conditions of the
+ ~ licenses as they are applied to this software. View the full text of
+ ~ the exception in file LICENSE.txt in the directory of this software
+ ~ distribution.
+ ~
+ ~ Lilie is distributed in the hope that it will be useful,
+ ~ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ~ Licenses for more details.
+ ~
+ ~ You should have received a copy of the GNU General Public License
+ ~ and the CeCILL-C along with Lilie. If not, see :
+ ~ <http://www.gnu.org/licenses/> and
+ ~ <http://www.cecill.info/licences.fr.html>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="othe">
+
+ <comment>
+ Ajout colonne "est_fusionne" dans table "entcdt.cahier_de_textes"
+ </comment>
+
+
+ <addColumn schemaName="entcdt" tableName="cahier_de_textes">
+ <column name="est_fusionne" type="boolean" defaultValueBoolean="false">
+ <constraints nullable="false" />
+ </column>
+ </addColumn>
+
+ <comment>
+ Ajout colonne "est_masque" dans table "entcdt.cahier_de_textes"
+ </comment>
+
+ <addColumn schemaName="entcdt" tableName="cahier_de_textes">
+ <column name="est_masque" type="boolean" defaultValueBoolean="false">
+ <constraints nullable="false" />
+ </column>
+ </addColumn>
+
+ </changeSet>
+
+</databaseChangeLog>
\ No newline at end of file
<include file="changelogs/scolarite/2013-07-08-0027533.xml"/>
<include file="changelogs/securite/2013-07-08-0029100.xml"/>
<include file="changelogs/scolarite/2013-07-09-0027533.xml"/>
+ <include file="changelogs/scolarite/2013-07-15-0028848.xml"/>
</databaseChangeLog>
*/
@SuppressWarnings('CatchException')
private Map formateAgendaEvenementInfoForStore(AgendaEvenementInfo evt, boolean encode) {
+
Map result = (Map) [:]
+
if (evt.recurrence) {
result.id = evt.id.toString() + "-" + evt.occurence.toString() +
"_" + evt.idAgenda.toString()
// utilisée pour ajouter ou pas l'item de menu contextuel : 'Créer de nouvelles activités
try {
+
+ result.peutCreerActivite = false
+
if (ConfigurationHolder.config.eliot.agenda.liaison.textes.actif.asBoolean()) {
+
SecuriteSession securiteSession = getSecuriteSession()
- Agenda agendaCourant = Agenda.get(Integer.parseInt(evt.idAgenda))
- if (agendaCourant.typeAgenda.code == TypeAgendaEnum.STANDARD.getCode()) {
- result.peutCreerActivite = false
- }
- else if (securiteSession.autorites?.contains(agendaCourant.getProprietaire())) {
- result.peutCreerActivite = true
- }
- else {
- Autorite autorite = (Autorite) securiteSession.defaultAutorite
- Evenement evtCourant = Evenement.get(Integer.parseInt(evt.id))
- Service serviceAssocie = evtCourant.enseignement.service
- CahierDeTextes cdtCourant =
- cahierDeTextesService.findCahierDeTextesByEnseignantAndService(
- autorite,
- serviceAssocie
- )
- AccessManager accessManager = new AccessManager(
- cdtCourant.item, securiteSession)
- result.peutCreerActivite = accessManager.peutModifierLeContenu()
+ Autorite autorite = (Autorite) securiteSession.defaultAutorite
+ Evenement evtCourant = Evenement.get(Integer.parseInt(evt.id))
+ Service serviceAssocie = evtCourant.enseignement.service
+ CahierDeTextes cdtCourant =
+ cahierDeTextesService.findCahierDeTextesByEnseignantAndService(
+ autorite,
+ serviceAssocie
+ )
+
+ if (!cdtCourant.estMasque){
+ Agenda agendaCourant = Agenda.get(Integer.parseInt(evt.idAgenda))
+ if (agendaCourant.typeAgenda.code != TypeAgendaEnum.STANDARD.getCode() &&
+ securiteSession.autorites?.contains(agendaCourant.getProprietaire())) {
+ result.peutCreerActivite = true
+ }
+ else {
+ AccessManager accessManager = new AccessManager(
+ cdtCourant.item, securiteSession)
+ result.peutCreerActivite = accessManager.peutModifierLeContenu()
+ }
}
+
}
- else {
- result.peutCreerActivite = false
- }
+
} catch (Exception e) {
result.peutCreerActivite = false
}
+
return result
}
* <http://www.cecill.info/licences.fr.html>.
*/
+
+
import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.lilie.services.eliot.url.UrlServeurResolutionMode
}
suiviImpressions {
- nombreLignesParPage = 100
+ nombreLignesParPage = 100
}
liaison {
environments {
production {
eliot.webservices.nomApplication = 'eliot-webservices'
+
}
development {
- eliot.url.webservices="http://127.0.0.1:8080"
+ eliot.url.webservices = "http://127.0.0.1:8080"
eliot.webservices.urlServeur = 'http://127.0.0.1:8080'
eliot.webservices.nomApplication = 'eliot-webservices'
eliot.textes.impression.docbook.log = false
+ eliot.webservices.actif = false
+ eliot.textes.impression.docbook.log = true
+
}
test {
- eliot.url.webservices="http://127.0.0.1:8080"
+ eliot.url.webservices = "http://127.0.0.1:8080"
eliot.webservices.urlServeur = 'http://127.0.0.1:8080'
eliot.webservices.nomApplication = 'eliot-webservices'
}
*/
class AbstractTextesController extends AbstractEliotController {
+ SimpleDateFormat sdf = new SimpleDateFormat(
+ DateConstantes.DD_MM_YYYY,
+ Locale.FRANCE
+ )
+
private static final BALISE_IMG_DISCUSSION = "<img src='../images/comment.gif' " +
"class='activity_attach' title='Discussion' />"
import org.lilie.services.eliot.applications.textes.exceptions.ActiviteValidationException
import org.lilie.services.eliot.erreurs.VerificationFichierException
import org.lilie.services.eliot.temps.TempsEvenementService
-import org.lilie.services.eliot.scolarite.Enseignement
+
import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
-import org.lilie.services.eliot.temps.Evenement
-import org.lilie.services.eliot.temps.DateUtil
+
import org.springframework.web.servlet.support.RequestContextUtils
import org.lilie.services.eliot.applications.textes.ActiviteAvecDocumentsCatalogue
import org.lilie.services.eliot.applications.textes.ActiviteService
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.applications.textes.ActiviteAdjacenteService
import org.lilie.services.eliot.webservice.WebserviceService
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.TextesCahierDeTextesService
import org.lilie.services.eliot.textes.TextesChapitreService
import org.lilie.services.eliot.textes.activite.formulaire.ActiviteFormulaireMode
import org.lilie.services.eliot.textes.arbre.ArbreService
import org.lilie.services.eliot.textes.DossierRempli
-import org.lilie.services.eliot.textes.TypeActiviteParDefaut
+
import org.lilie.services.eliot.scolarite.TypeActiviteService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.textes.activite.initialisation.ActiviteClasse
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.SessionUtils
-import org.lilie.services.eliot.DateConstantes
import org.lilie.services.eliot.temps.DateUtil
-import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.FichierUtilsService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.securite.AccessManager
import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.textes.droits.ActionPossibleService
import org.lilie.services.eliot.textes.etat.accueil.AccueilEtatSessionService
import org.lilie.services.eliot.textes.etat.accueil.TextesAccueilEtatApplication
import org.lilie.services.eliot.textes.page.Page
import org.lilie.services.eliot.textes.visa.VisaService
import org.springframework.web.multipart.MultipartFile
-import java.text.SimpleDateFormat
import org.lilie.services.eliot.demon.DemandeTraitementService
import org.lilie.services.eliot.textes.DroitsService
import org.lilie.services.eliot.textes.TextesChapitreService
-import org.lilie.services.eliot.textes.CahierIncorporationService
import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheInfo
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.Fichier
import org.lilie.services.eliot.textes.NodeUtils
import org.lilie.services.eliot.textes.Chapitre
import org.lilie.services.eliot.textes.Activite
-import org.lilie.services.eliot.textes.Visa
-import org.lilie.services.eliot.textes.CahierIncorporationInfo
import org.lilie.services.eliot.textes.ActeurAllCahierPersonnalise
import org.lilie.services.eliot.textes.arbre.ArbreService
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesArbreService
import org.lilie.services.eliot.textes.arbre.DossierInfoAffichage
import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
-import org.lilie.services.eliot.applications.textes.CahierDeTextesInfo
import org.lilie.services.eliot.webservice.WebserviceService
import org.lilie.services.eliot.textes.TextesDossierService
import org.lilie.services.eliot.textes.arbre.DossierTypeEnum
import org.lilie.services.eliot.textes.recherchecahierdetextes.FiltreRechercheCahierDeTextesService
import org.lilie.services.eliot.textes.arbre.dossier.Archives
-import org.lilie.services.eliot.annuaire.GroupeInfo
-import org.lilie.services.eliot.annuaire.DistantGroupeSessionService
import org.lilie.services.eliot.textes.recherchecahierdetextes.RechercheCahierDeTextesService
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.url.EliotUrlService
-import org.lilie.services.eliot.CodeComparator
+import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
/**
* Controller dirigeant tout ce qui touche aux cahiers de textes.
TextesChapitreService textesChapitreService
FichierService fichierService
FichierUtilsService fichierUtilsService
- CahierIncorporationService cahierIncorporationService
+ CahierFusionService cahierFusionService
LocalPersonneService localPersonneService
EtablissementService etablissementService
VisaService visaService
AutoriteNomAffichageService autoriteNomAffichageService
ArbreService arbreService
- CahierDeTextesArbreService cahierDeTextesArbreService
DroitsEtPermissionsService droitsEtPermissionsService
AccueilEtatSessionService accueilEtatSessionService
- ActionPossibleService actionPossibleService
CalendrierService calendrierService
DemandeTraitementService demandeTraitementService
CiteScolaireService citeScolaireService
WebserviceService webserviceService
TextesDossierService textesDossierService
FiltreRechercheCahierDeTextesService filtreRechercheCahierDeTextesService
- DistantGroupeSessionService distantGroupeSessionService
RechercheCahierDeTextesService rechercheCahierDeTextesService
EliotUrlService eliotUrlService
-
- SimpleDateFormat sdf = new SimpleDateFormat(
- DateConstantes.DD_MM_YYYY,
- Locale.FRANCE
- )
+ CahierDeTextesRequestParserService cahierDeTextesRequestParserService
+ CahierDeTextesMarshallerService cahierDeTextesMarshallerService
+ CahierDeTextesDroitsService cahierDeTextesDroitsService
+ CahierDeTextesEmploiDuTempsService cahierDeTextesEmploiDuTempsService
+ CahierDeTextesMasqueService cahierDeTextesMasqueService
private static final FICHIER_TAILLE_MAX_MO =
ConfigurationHolder.config.eliot.textes.fichier.tailleMax.megaOctets
private static final Integer ACCORDEON_DOSSIER = 1
private static final Integer ACCORDEON_EDT = 0
- CodeComparator comparateurLogique = new CodeComparator()
-
/**
* Action par défaut (correspond à l'url racine de l'application)
*/
)
)
- boolean activerPresentationParTemps = false
-
// Si l'utilisateur est un enseignant, et la variable de config est à true,
// l'utilisateur aura accès à deux types de présentation de cdt,
// une présentation par emploi du temps
// et une présentation par dossier
boolean ajouterPresentationParTemps =
- grailsApplication.config.eliot.textes.affichage.presentationCdt.emploiDuTemps &&
- getSecuriteSession().hasFonctionIn([FonctionEnum.ENSEIGNANT])
+ cahierDeTextesDroitsService.hasUtilisateurDroitPresentationEmploiDuTemps(getSecuriteSession())
// Si les deux types de présentations sont actives, si la recherche par défaut
// n'est pas vide, la présentation qui sera ouverte est celle par emploi du temps,
// sinon la présentation par dossier
-
- Calendar aujourdHui = Calendar.instance
-
- if (ajouterPresentationParTemps &&
- textesCahierDeTextesSessionService.findAllCdtServiceByJour(
- getSecuriteSession(),
- acteurAllCahierPersonnalise,
- aujourdHui).size() > 0
- ) {
- activerPresentationParTemps = true
- }
+ boolean activerPresentationParTemps = ajouterPresentationParTemps &&
+ cahierDeTextesDroitsService.isPresentationEmploiDeTempsActive(getSecuriteSession(),
+ acteurAllCahierPersonnalise)
// Si l'utilisateur est un responsable ou invite : désactive Créer cahier
// de textes
- boolean desactiverCreationCdt = (
- getSecuriteSession()?.hasFonctionIn(
- [
- FonctionEnum.PERS_REL_ELEVE,
- FonctionEnum.INVITE
- ]
- )
- )
+ boolean desactiverCreationCdt = !cahierDeTextesDroitsService.isCreationCahierDeTextes(getSecuriteSession())
TextesAccueilEtatApplication etatApplicationAccueil = gestionEtat(
acteurAllCahierPersonnalise
CahierDeTextes.withTransaction {
Map resulat = tryCatch {
- Etablissement etab = get(params)
+ Etablissement etab = cahierDeTextesRequestParserService.parseEtablissement(params)
- verifieAutorisationConsultationEtablissement(etab)
+ cahierDeTextesDroitsService.verifieAutorisationConsultationEtablissement(getSecuriteSession(), etab)
- // Get enseignant
- Personne profPersonne = null
- String enseignantIdStr = params.enseignantId
- if (enseignantIdStr) {
- Long enseignantId = Long.parseLong(enseignantIdStr)
- profPersonne = Personne.get(enseignantId)
- if (!profPersonne) {
- throw new IllegalArgumentException(
- "Enseignant [$enseignantId] n'existe pas"
- )
- }
- }
+ Personne profPersonne = cahierDeTextesRequestParserService.parseEnseignant(params)
- // Get matière
- Matiere matiere = null
- String matiereIdStr = params.matiereId
- if (matiereIdStr) {
- Long matiereId = Long.parseLong(matiereIdStr)
- matiere = Matiere.get(matiereId)
- if (!matiere) {
- throw new IllegalArgumentException(
- "Matière [$matiereId] n'existe pas"
- )
- }
- }
+ Matiere matiere = cahierDeTextesRequestParserService.parseMatiere(params)
// Get dossier
Long dossierId = null
}
}
+
def rechercher = {
CahierDeTextes.withTransaction {
Map resultat = tryCatch {
- Etablissement etablissement = get(params)
-
- verifieAutorisationConsultationEtablissement(etablissement)
-
- // Parse params
- Long dossierId = params.dossierId ? Long.parseLong(params.dossierId.substring(1)) : null
- Long enseignantId = params.enseignantId ? Long.parseLong(params.enseignantId) : null
- Long structureId = params.structureId ? Long.parseLong(params.structureId) : null
- Long matiereId = params.matiereId ? Long.parseLong(params.matiereId) : null
- Boolean estVise = (params.visa != null) ? Boolean.parseBoolean(params.visa) : null
- Boolean avecCahiersArchives = (params.inclureArchives != null) ?
- Boolean.parseBoolean(params.inclureArchives) : false
-
- DossierInfo dossierInfo = null
- Personne enseignant = null
- StructureEnseignement structureEnseignement = null
- Matiere matiere = null
-
- if (dossierId != null) {
- dossierInfo = new DossierInfo(dossierId)
- if (dossierInfo.typeDossier == DossierTypeEnum.UTILISATEUR &&
- dossierInfo.dossier == null) {
- throw new IllegalArgumentException(
- "Dossier utilisateur [id: $dossierId] n'existe pas"
- )
- }
- }
+ Etablissement etablissement = cahierDeTextesRequestParserService.parseEtablissement(params)
+ cahierDeTextesDroitsService.verifieAutorisationConsultationEtablissement(getSecuriteSession(), etablissement)
- if (structureId != null) {
- structureEnseignement = StructureEnseignement.get(structureId)
- if (!structureEnseignement) {
- throw new IllegalArgumentException(
- "Structure d'enseignement [$structureId] n'existe pas"
- )
- }
- }
-
- if (enseignantId != null) {
- enseignant = Personne.get(enseignantId)
- if (!enseignant) {
- throw new IllegalArgumentException(
- "Personne [$enseignantId] n'existe pas"
- )
- }
- }
-
- if (matiereId != null) {
- matiere = Matiere.get(matiereId)
- if (!matiere) {
- throw new IllegalArgumentException(
- "Matière [$matiereId] n'existe pas"
- )
- }
- }
+ Boolean estVise = cahierDeTextesRequestParserService.parseBoolean(params, 'visa')
+ Boolean estVide = cahierDeTextesRequestParserService.parseBoolean(params, 'vide')
+ Boolean avecCahiersArchives = cahierDeTextesRequestParserService.parseBoolean(params, 'inclureArchives')
+ StructureEnseignement structureEnseignement = cahierDeTextesRequestParserService.parseStructureEnseignement(params)
+ Personne enseignant = cahierDeTextesRequestParserService.parseEnseignant(params)
+ Matiere matiere = cahierDeTextesRequestParserService.parseMatiere(params)
+ DossierInfo dossierInfo = cahierDeTextesRequestParserService.parseDossierInfo(params)
session.criteresRecherche = [
- etablissementId: etablissement.id,
- dossierId: "d" + dossierId,
- structureId: structureId,
- enseignantId: enseignantId,
- matiereId: matiereId,
+ etablissementId: etablissement?.id,
+ dossierId: "d" + dossierInfo?.id,
+ structureId: structureEnseignement?.id,
+ enseignantId: enseignant?.id,
+ matiereId: matiere?.id,
visa: estVise,
+ vide: estVide,
avecCahiersArchives: avecCahiersArchives
]
- GroupeInfo infoGroupeDirection =
- (GroupeInfo) distantGroupeSessionService.getGroupeInfoDeDirection(
- etablissement
- )
-
List<CahierDeTextesRechercheInfo> cdtsInfo =
rechercheCahierDeTextesService.findCahiersForEtablissement(
securiteSession,
estVise,
avecCahiersArchives,
dossierInfo,
- infoGroupeDirection
+ estVide
)
- return [cahiers: cahiersToMap(cdtsInfo)]
+ return cahierDeTextesMarshallerService.marshall(cdtsInfo, request.locale)
}
render resultat as JSON
}
// Vérifie les droits d'accès à la fenêtre
def afficherRecherche = {
CahierDeTextes.withTransaction {
+
if (!securiteSession.hasFonctionIn([FonctionEnum.DIRECTION])) {
throw AutorisationException.consultationContenuException()
}
donneesPourAffichageDroits(
modele,
cdt,
- SessionUtils.securiteSession(session),
+ securiteSession,
params)
- modele += accesDroitEtPermissions(cdt)
+ modele += cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession, cdt)
render(view: '_editDroits', model: modele)
}
Map modelParams = prepareBaseModele(page)
- String nomProprietaire
- String cdtInfoSuppression
CahierDeTextes cdt = CahierDeTextes.get(params.id)
- actionPossibleService.verifierAccesConsultation(
+ cahierDeTextesDroitsService.verifierAccesConsultation(
getSecuriteSession(),
cdt
)
- modelParams.peutModifierCdt = actionPossibleService.peutModifier(
+ modelParams.peutModifierCdt = cahierDeTextesDroitsService.peutModifier(
getSecuriteSession(),
cdt
)
Autorite autProprietaire = cdt.getProprietaire()
- if (autProprietaire?.type == Autorite.TYPE_ELIOT) {
- nomProprietaire = Autorite.ENT
- }
- else {
- nomProprietaire = localPersonneService.getNomAffichage(
- cdt.proprietaire
- )
- }
-
- if (cdt.isEnCoursDeSuppression() &&
- autProprietaire != getSecuriteSession().defaultAutorite
- ) {
-
- nomProprietaire += " " + message(code: "eliot.textes.compteEnCoursSupp")
- cdtInfoSuppression = message(code: "eliot.textes.cdtInfoSuppression")
- }
+ boolean isProprietaire = (getSecuriteSession().defaultAutorite.id == autProprietaire.id)
// Préférences de l'utilisateur
RelCahierActeur rel = flash.rel ?:
numTab = peutAfficherVisas ? 3 : 2
}
- modelParams += accesDroitEtPermissions(cdt)
+ modelParams += cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession, cdt)
modelParams += [
'cdt': cdt,
- 'nomProprietaire': nomProprietaire?.encodeAsHTML(),
- cdtInfoSuppression: cdtInfoSuppression?.encodeAsHTML(),
'rel': rel,
tab: numTab,
peutAfficherVisas: peutAfficherVisas,
listeVisa: prepareVisas(peutAfficherVisas, cdt) as JSON
]
+ modelParams += cahierDeTextesMarshallerService.marshallInfoProprietaire(cdt, autProprietaire, isProprietaire)
+
if ("recherche".equals(params.origine)) {
modelParams.menu = Menu.RECHERCHE_CDT_SERVICE
}
boolean isCahierDeClasse = textesCahierDeTextesSessionService.
isCdtServiceDeClasse(cdt)
- if (isCahierDeClasse) {
- List nomAffichageCahiersIncorpores = []
- cdt.cahiersIncorpores.each { CahierDeTextes cdtIncorpore ->
- // TOREFACT : provisoir : à reprendre pour utiliser que la fonction
- // : nomAffichage afin d'uniformiser le nom de cahier de textes
- // affiché dans toutes les pages de l'application
- String modalite = cdtIncorpore.service?.modaliteCours?.libelleCourt ?: cdtIncorpore.service?.modaliteCours?.libelleLong
- String nomAffichage = cdtIncorpore.nomAffichage(
- utilisateur()) + ' - ' + modalite
-
- nomAffichageCahiersIncorpores.add(nomAffichage)
- }
-
- modelParams += [
- nomAffichageCahiersIncorpores: nomAffichageCahiersIncorpores.sort()
- ]
+ if (isCahierDeClasse && isProprietaire) {
+ modelParams += cahierDeTextesMarshallerService.marshallCahierDeTextesFusionnes(securiteSession, cdt)
}
return modelParams
CahierDeTextes cdt = CahierDeTextes.get(params.id)
- actionPossibleService.verifierAccesModification(
+ cahierDeTextesDroitsService.verifierAccesModification(
getSecuriteSession(),
cdt
)
boolean isCahierDeClasse = textesCahierDeTextesSessionService.
isCdtServiceDeClasse(cdt)
+ log.debug "isCahierDeService : $isCahierDeService"
+ log.debug "isCahierDeClasse : $isCahierDeClasse"
+
Map modelParams = [
cdtCmd: cdtCmd,
ongletPermissionDesactive: ongletPermissionDesactive,
]
if (isCahierDeClasse) {
- modelParams += getModelParamsForCahiersIncorporation(cdt)
+ modelParams += cahierDeTextesMarshallerService.marshallFusionCahierInfo(
+ getSecuriteSession(),
+ cdt)
}
modelParams += modele
flash.message = message(code: 'cdt.pref.maj.succes')
}
- Map modele = accesDroitEtPermissions(cdt)
+ Map modele = cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(cdt)
modele += [id: params.id, tab: params.tab, origine: params.origine]
redirect(
setCahierDeTextesCommand(cmd, cdt)
} else {
- actionPossibleService.verifierAccesModification(
+ cahierDeTextesDroitsService.verifierAccesModification(
getSecuriteSession(),
cdt
)
}
// mise à jour de l'état des cahiers d'incorporation
+ List initialCdtsIncorpores = []
if (params.initialCdtsIncorpores) {
- List initialCdtsIncorpores =
- JSON.parse(params.initialCdtsIncorpores) as List
-
- List cdtFilsIncorpores = []
-
- if (params.cdtFilsIncorpores) {
- if (params.cdtFilsIncorpores instanceof String) {
- cdtFilsIncorpores = [params.cdtFilsIncorpores]
- } else {
- cdtFilsIncorpores = params.cdtFilsIncorpores
- }
- } else {
- cdtFilsIncorpores = []
- }
+ initialCdtsIncorpores = JSON.parse(params.initialCdtsIncorpores) as List
+ }
- // Le cdt est sélectionné pour être incorporé
- cdtFilsIncorpores.each { String id ->
+ // fusionner les cahiers contenus dans nouveauxCdtsIncorpores
+ if (params.cdtsAIncorporer) {
+ // spliter la chaine par les virgules
+ List cdtsAIncorporer = params.cdtsAIncorporer.split(',')
+ cdtsAIncorporer.each { String id ->
if (!initialCdtsIncorpores.contains(id as Integer)) {
- log.info "$id va être incoroporé"
+ log.debug "$id va être fusionné"
CahierDeTextes cdtAIncorpore = CahierDeTextes.get(Long.parseLong(id))
- cahierIncorporationService.incorporeCahierDans(
+ cahierFusionService.fusionneCahierDans(
SessionUtils.securiteSession(session),
cdtAIncorpore,
cdt
)
}
}
+ }
- // Le cdt n'est plus selectionné, donc on le désincorpore
- // Le cdt n'est plus selectionné, donc on le désincorpore
- initialCdtsIncorpores.each { Integer id ->
- if (!cdtFilsIncorpores.contains(id as String)) {
- log.info "$id va être désincorporé"
+ // détacher les cahiers contenus dans cdtsDetaches
+ if (params.cdtsADetacher) {
+ List cdtsADetacher = params.cdtsADetacher.split(',')
+ cdtsADetacher.each { String id ->
+ if (initialCdtsIncorpores.contains(id as Integer)) {
+ log.debug "$id va être détaché"
CahierDeTextes cdtADesincorpore = CahierDeTextes.get(id)
- cahierIncorporationService.desincorporeCahier(
+ cahierFusionService.detacheCahier(
SessionUtils.securiteSession(session),
cdtADesincorpore
)
]
if (isCahierDeClasse) {
- modelParams += getModelParamsForCahiersIncorporation(cdt)
+ modelParams += cahierDeTextesMarshallerService.marshallFusionCahierInfo(
+ getSecuriteSession(),
+ cdt)
}
render(
]
- modele += accesDroitEtPermissions(cdt)
+ modele += cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession,cdt)
render(view: 'proprietes',
model: modele
)
)
- List resultats = getListeCdtParEmpTemps(
+ List<RelCahierEvenement> allCahierDeTextesParEdt = cahierDeTextesEmploiDuTempsService.listeCdtParEmploiDuTemps(
+ securiteSession,
acteurAllCahierPersonnalise,
- DateUtil.recupereDateDuneChaineLongue(dateSelectionnee)
+ DateUtil.recupereDateDuneChaineLongue(dateSelectionnee))
+
+ List resultats = cahierDeTextesMarshallerService.mashallListeCdtParEmploiDuTemps(
+ securiteSession,
+ allCahierDeTextesParEdt
)
render resultats as JSON
).premierJour
)
+ boolean isDirectionOuADML = false;
+ if (securiteSession.hasFonctionIn(
+ [FonctionEnum.ADMIN_LOCAL,
+ FonctionEnum.DIRECTION]
+ )) {
+ isDirectionOuADML = true;
+ }
+
Map model = [
isAcceesRestreint: isAccesRestreint(),
desactiverCreationCdt: desactiverCreationCdt,
state: etatApplicationAccueil ? etatApplicationAccueil.toJSON() : [] as JSON,
menuInfo: modele.menuInfo,
activerPresentationParTemps: activerPresentationParTemps,
- dateDebutAnnee: debutAnneeScolaire
+ dateDebutAnnee: debutAnneeScolaire,
+ contientCdtMasque:cahierDeTextesMasqueService.hasCahierDeTextesMasque(getSecuriteSession()),
+ isDirectionOuADML: isDirectionOuADML
]
model += modele
List cdtParEdts = []
if (etatApplicationAccueil?.dateSelectionnee) {
- cdtParEdts = getListeCdtParEmpTemps(
+
+ List<RelCahierEvenement> allCahierDeTextesParEdt = cahierDeTextesEmploiDuTempsService.listeCdtParEmploiDuTemps(
+ getSecuriteSession(),
acteurAllCahierPersonnalise,
DateUtil.recupereDateDuneChaineLongue(
etatApplicationAccueil?.dateSelectionnee
- )
+ ))
+
+
+ cdtParEdts = cahierDeTextesMarshallerService.mashallListeCdtParEmploiDuTemps(
+ getSecuriteSession(),
+ allCahierDeTextesParEdt
)
}
acteurAllCahierPersonnalise,
request.locale
) as JSON
+
model.etatArbreCdtEdt = cdtParEdts as JSON
model.etatArbreActivite = (arbreActivite ? [(cdtId): arbreActivite] : [:]) as JSON
}
return etatApplicationAccueil
}
- private List<Map> cahiersToMap(List<CahierDeTextesRechercheInfo> cdtsInfo) {
- List<Map> cahiers = []
-
- cdtsInfo?.each { CahierDeTextesRechercheInfo cdtInfo ->
-
- String cdtNom = cdtInfo.cdtNom
- // Nom de cdt archive
- if (cdtInfo.estCahierArchive) {
- cdtNom = message(code: "eliot.textes.dossier.archive.nom", args: [
- cdtNom,
- cdtInfo.anneeDebut,
- cdtInfo.anneeFin
- ])
- }
- // Nom de cdt avec un nom personalise
- if (cdtInfo.nomAlias) {
- cdtNom = "${cdtInfo.nomAlias} ($cdtNom)"
- }
-
- cahiers << [
- id: cdtInfo.cdtId,
- nom: cdtNom,
- enseignant: localPersonneService.getNomAffichage(
- cdtInfo.proprietaireNom,
- cdtInfo.proprietairePrenom
- ),
- structure: cdtInfo.structureCode,
- matiere: cdtInfo.matierreLibelleLong,
- nbAct: cdtInfo.nbrActivitePubliees ?: 0,
- dateSaisie: cdtInfo.activiteDateModification ?: null,
- dateDernierVisa: cdtInfo.dateDernierVisa ?: null,
- estCahierArchive: cdtInfo.estCahierArchive
- ]
- }
-
- cahiers.sort {a, b ->
- comparateurLogique.compare(
- a.nom.toUpperCase(),
- b.nom.toUpperCase()
- )
- }
- return cahiers
- }
-
/**
* Trmplis le modele avec les droits des groupes at utilisateurs
* @param modele
return modele
}
- /**
- * Lecture des droits de lecture/écriture sur l'onglet des droits et permissions
- * @param cahierDeTextes
- * @return
- */
- private Map accesDroitEtPermissions(CahierDeTextes cahierDeTextes) {
-
- AccessManager accessManager = new AccessManager(
- cahierDeTextes.item,
- getSecuriteSession()
- )
-
- boolean disableEdit = !(
- accessManager.peutModifierLesPermissions() &&
- !getSecuriteSession().defaultAutorite.aUnAccesRetreint()
- )
-
- boolean disableDroitsEtPermissions = !accessManager.peutConsulterLesPermissions()
-
- return [
- 'disableEdit': disableEdit,
- 'disableDroitsEtPermissions': disableDroitsEtPermissions
- ]
-
- }
-
/**
* Prépare des données du modèle pour le visa
* @param peutAfficherVisas
*/
private Map prepareVisas(boolean peutAfficherVisas, CahierDeTextes cdt) {
- Map resultat = [
- render: peutAfficherVisas,
- renderTo: 'listeVisa',
- visas: []
- ]
-
- if (peutAfficherVisas) {
-
- List<Visa> visas = visaService.findAllVisaByCahierDeTextes(
- securiteSession,
- cdt
- )
+ Map resultat = cahierDeTextesMarshallerService.marshallVisa(
+ securiteSession,
+ peutAfficherVisas,
+ cdt
+ )
- resultat.visas = visas.collect { Visa visa ->
- [
- id: visa.id,
- date: sdf.format(visa.dateVisee),
- auteur: visa.auteur?.nomAffichage(),
- commentaire: visa.commentaire?.encodeAsHTML(),
- lien: "${createLink(action: 'afficheVisa', controller: 'visa', params: [visaId: visa.id])}"
- ]
+ resultat.visas =
+ resultat.visas.collect {Map map ->
+ map.lien = "${createLink(action: 'afficheVisa', controller: 'visa', params: [visaId: map.id])}"
}
- }
-
return resultat
}
return ""
}
- private List getListeCdtParEmpTemps(ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
- Date date) {
- List resultats = []
- Calendar dateJour = Calendar.getInstance()
- dateJour.setTime(
- date
- )
-
- Collection<RelCahierEvenement> cdtsEvntsInfo =
- textesCahierDeTextesSessionService.findAllCdtServiceByJour(
- securiteSession,
- acteurAllCahierPersonnalise,
- dateJour
- )
-
- cdtsEvntsInfo.each { RelCahierEvenement cdtEvntInfo ->
- CahierDeTextes cahier = cdtEvntInfo.cahierDeTextes
-
- SimpleDateFormat df = new SimpleDateFormat(
- "HH'h'mm",
- Locale.FRANCE
- )
-
- String creneauDebut = df.format(cdtEvntInfo.evenement.dateHeureDebut)
- String creneauFin = df.format(cdtEvntInfo.evenement.dateHeureFin)
- String creneau = '(' + creneauDebut + ' - ' + creneauFin + ')'
-
- Boolean peutSupprimerLeCdt = actionPossibleService.peutSupprimer(
- getSecuriteSession(),
- cahier
- )
-
- Boolean peutModifierLeContenuDuCdt = actionPossibleService.peutModifier(
- getSecuriteSession(),
- cahier
- )
-
- String nomAffichage = creneau + " " + cahier.nomAffichage(utilisateur(), false)
-
- // Si le cdt est incorporé, le cdt père est celui qui porte les activités
- Long identifiantCdt = cahier.parentIncorporation ?
- cahier.parentIncorporation.id :
- cahier.id
-
- resultats << [
- id: NodeUtils.addPrefixeNodeCdtParTemps(
- identifiantCdt,
- cdtEvntInfo.evenement.id
- ),
- text: nomAffichage,
- titreCahier: cahier.nom,
- leaf: false,
- children: [],
- expanded: true,
- expandable: false,
- iconCls: cahierDeTextesArbreService.getIconeCdt(
- securiteSession,
- cahier),
- peutSupprimerLeCdt: peutSupprimerLeCdt,
- peutModifierLeContenuDuCdt: peutModifierLeContenuDuCdt
- ]
- }
- return resultats
- }
-
- private Map getModelParamsForCahiersIncorporation(CahierDeTextes cdt) {
- List<CahierIncorporationInfo> cahiersFilsIncorporationInfo =
- cahierIncorporationService.getFilsCompatiblesIncorporationInfo(
- SessionUtils.securiteSession(session),
- cdt
- )
- List initialCdtsIncorpores = []
- cdt.cahiersIncorpores.each {
- initialCdtsIncorpores.add(it.id)
- }
-
- cahiersFilsIncorporationInfo.sort { CahierIncorporationInfo cdtInfo ->
- cdtInfo.nomAffichage
- }
-
- return [
- cahiersFilsIncorporationInfo: cahiersFilsIncorporationInfo,
- initialCdtsIncorpores: initialCdtsIncorpores
- ]
- }
private Autorite utilisateur() {
return (Autorite) SessionUtils.utilisateur(session)
}
}
- private void verifieAutorisationConsultationEtablissement(Etablissement etablissement)
- throws AutorisationException {
- if (!securiteSession.hasFonctionIn([FonctionEnum.DIRECTION], etablissement.id)) {
-
- // Cherche l'ensemble des établissements des cités scolaires
- // dont la personne est directeur
- List<Etablissement> etabsDePersonne =
- citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
- etablissementService.findAllEtablissementsForPersonneDIR(
- securiteSession.getPersonne()
- )
- )
-
- if (!etabsDePersonne.contains(etablissement)) {
- throw new AutorisationException(
- "L'utilisateur [${securiteSession.getPersonne()}] " +
- "n'a pas droit de consulter l'information sur " +
- "l'établissement [$etablissement]"
- )
- }
- }
- }
-
/**
* Traite le cas ou on a des autorites qui sont dans l'annuaire logica
* mais pas encore dans l'annuaire eliot
args: [nomAffichageLogica])
}
-/**
- * Gestion du breadCrumbs
- * @return
- */
+ /**
+ * Construis un apercu de cahier de textes
+ */
+ def apercevoir = {
+ CahierDeTextes cdt = CahierDeTextes.get(params.cdtId)
+
+ cahierDeTextesDroitsService.verifierAccesConsultation(
+ getSecuriteSession(),
+ cdt
+ )
+
+ List infosCahiers = []
+
+ infosCahiers << cahierDeTextesMarshallerService.marshallApercu(
+ getSecuriteSession(),
+ cdt)
+
+ render(
+ view: '/cahierDeTextes/apercu',
+ model: [
+ infosCahiers: infosCahiers,
+ wsequation: eliotUrlService.getUrl(
+ getSecuriteSession(),
+ EliotApplicationEnum.WEBSERVICES,
+ WebserviceService.EQUATION
+ ),
+ webserviceDisponible: webserviceService.estDisponible()
+ ]
+ )
+ }
+
+ /**
+ * Construis un apercu de plusieurs cahiers de textes
+ */
+ def apercevoirPlusieursCdts = {
+
+ List<CahierDeTextes> cdts = []
+
+ List<Integer> cdtIds = params.cdtIds.split(',').collect {it as int}
+
+ cdtIds.each() {
+ cdts << CahierDeTextes.get(it)
+ }
+
+ List infosCahiers = []
+
+ cdts.each() {
+
+ cahierDeTextesDroitsService.verifierAccesConsultation(
+ getSecuriteSession(),
+ it
+ )
+
+ infosCahiers << cahierDeTextesMarshallerService.marshallApercu(getSecuriteSession(), it)
+ }
+
+ render(
+ view: '/cahierDeTextes/apercu',
+ model: [
+ infosCahiers: infosCahiers,
+ wsequation: eliotUrlService.getUrl(
+ getSecuriteSession(),
+ EliotApplicationEnum.WEBSERVICES,
+ WebserviceService.EQUATION
+ ),
+ webserviceDisponible: webserviceService.estDisponible()
+ ]
+ )
+ }
+
+ /**
+ * Gestion du breadCrumbs
+ * @return
+ */
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
return breadCrumbsInfo
}
- private Etablissement get(Map params) {
- // Get Etablissement
- String etablissementIdStr = params.etablissementId
- if (etablissementIdStr == null) {
- throw new IllegalArgumentException("etablissementId n'est pas spécifié")
- }
- Long etablissementId = Long.parseLong(etablissementIdStr)
- Etablissement etablissement = Etablissement.get(etablissementId)
- if (!etablissement) {
- throw new IllegalArgumentException(
- "Etablissement [$etablissementId] n'existe pas"
- )
- }
-
- return etablissement
-
- }
-
- /**
- * Construis un apercu de cahier de textes
- */
- def apercevoir = {
- CahierDeTextes cdt = CahierDeTextes.get(params.cdtId)
-
- actionPossibleService.verifierAccesConsultation(
- getSecuriteSession(),
- cdt
- )
-
- List infosCahiers = []
- infosCahiers << getInfosPourApercu(cdt)
- render(
- view: '/cahierDeTextes/apercu',
- model: [
- infosCahiers: infosCahiers,
- wsequation: eliotUrlService.getUrl(
- getSecuriteSession(),
- EliotApplicationEnum.WEBSERVICES,
- WebserviceService.EQUATION
- ),
- webserviceDisponible: webserviceService.estDisponible()
- ]
- )
- }
-
- /**
- * Construis un apercu de plusieurs cahiers de textes
- */
- def apercevoirPlusieursCdts = {
-
- List<CahierDeTextes> cdts = []
-
- List<Integer> cdtIds = params.cdtIds.split(',').collect {it as int}
-
- cdtIds.each() {
- cdts << CahierDeTextes.get(it)
- }
-
- List infosCahiers = []
-
- cdts.each() {
-
- actionPossibleService.verifierAccesConsultation(
- getSecuriteSession(),
- it
- )
-
- infosCahiers << getInfosPourApercu(it)
- }
-
- render(
- view: '/cahierDeTextes/apercu',
- model: [
- infosCahiers: infosCahiers,
- wsequation: eliotUrlService.getUrl(
- getSecuriteSession(),
- EliotApplicationEnum.WEBSERVICES,
- WebserviceService.EQUATION
- ),
- webserviceDisponible: webserviceService.estDisponible()
- ]
- )
- }
-
- /**
- * Prepare les donnes de model pour l'apercu de cahier
- * @param cdt
- * @return
- */
- private Map getInfosPourApercu(CahierDeTextes cdt) {
- SecuriteSession securiteSession = SessionUtils.securiteSession(session)
-
- Collection chapitresEtActivites =
- textesChapitreService.getChapitresEtActivitesListePlate(
- cdt,
- securiteSession,
- true
- )
-
- boolean estProprietaire = cdt.getProprietaire().idExterne ==
- utilisateur().idExterne
-
- Personne prof = Personne.findByAutorite(cdt.getProprietaire())
-
- return [
- cdtInfo: new CahierDeTextesInfo(
- nomAffichage: cdt.nomAffichage(
- (Autorite) securiteSession.defaultAutorite
- ),
- description: cdt.description?.encodeAsHTML(),
- estPrive: cdt.estCahierPriveViseOuNonVise(),
- structureEnseignementCode: cdt.service?.structureEnseignement?.code,
- matiereLibelle: cdt.service?.matiere?.libelleLong?.encodeAsHTML()
- ),
- chapitresEtActivites: chapitresEtActivites,
- estProprietaire: estProprietaire,
- professeur: prof
- ]
- }
}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.AbstractTextesController
+import grails.converters.JSON
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.CodeComparator
+
+/**
+ * gestion du masquages/démasquage des cahiers de textes de vide
+ * @author othe
+ */
+class CahierDeTextesMasqueController extends AbstractTextesController {
+
+ private static final CodeComparator comparateurLogique = new CodeComparator()
+
+ CahierDeTextesMasqueService cahierDeTextesMasqueService
+
+ def masque = {
+ try {
+ List cahiersAMasquer = []
+
+ def cdtIds = params.cdtIds
+ if (cdtIds instanceof String){
+ cahiersAMasquer.add(cdtIds)
+ }
+ else {
+ cahiersAMasquer = cdtIds
+ }
+
+ List<CahierDeTextes> cahierDeTextesAMasquer = listeCahiersDeTextes(cahiersAMasquer)
+
+ if (cahierDeTextesAMasquer.size() == 0) {
+ throw new IllegalArgumentException("Erreur paramètre : Il n'y a aucun cahier de textes à masquer")
+ }
+
+ cahierDeTextesMasqueService.masque(cahierDeTextesAMasquer)
+
+ String messageReponse = ''
+ if (cahierDeTextesAMasquer.size() > 1) {
+ messageReponse = message(code: 'eliot.textes.masques.message.succes')
+ } else {
+ messageReponse = message(code: 'eliot.textes.masque.message.succes')
+ }
+
+ render([success: true, message: messageReponse] as JSON)
+ // On fait cette gestion qqsoit l'erreur
+ } catch (Exception e) {
+ log.error "masque", e
+ render([success: false, message: message(code: 'eliot.textes.masque.message.erreur')] as JSON)
+ }
+ }
+
+ def montre = {
+ try {
+ List cahiersAAfficher = []
+
+ def cdtIds = params.cdtIds
+ if (cdtIds instanceof String){
+ cahiersAAfficher.add(cdtIds)
+ }
+ else {
+ cahiersAAfficher = cdtIds
+ }
+
+ List<CahierDeTextes> cahierDeTextesAMontrer = listeCahiersDeTextes(cahiersAAfficher)
+
+ if (cahierDeTextesAMontrer.size() == 0) {
+ throw new IllegalArgumentException("Erreur paramètre : Il n'y a aucun cahier de textes à montrer")
+ }
+
+ String messageReponse = ''
+ if (cahierDeTextesAMontrer.size() > 1) {
+ messageReponse = message(code: 'eliot.textes.montres.message.succes')
+ } else {
+ messageReponse = message(code: 'eliot.textes.montre.message.succes')
+ }
+
+ cahierDeTextesMasqueService.montre(getSecuriteSession(), cahierDeTextesAMontrer)
+
+ flash.message = messageReponse;
+ render([success: true] as JSON)
+ // On fait cette gestion qqsoit l'erreur
+ } catch (Exception e) {
+ log.error "montre", e
+ render([success: false, message: message(code: 'eliot.textes.montre.message.erreur')] as JSON)
+ }
+
+ }
+
+ private List<CahierDeTextes> listeCahiersDeTextes(List<String> listeCahierDeTextesIds) {
+ List<CahierDeTextes> allCahierDeTextes = []
+ listeCahierDeTextesIds?.each{ String cahierId ->
+ if (cahierId && cahierId != ""){
+ allCahierDeTextes.add(CahierDeTextes.load(Long.parseLong(cahierId)))
+ }
+ }
+ return allCahierDeTextes
+ }
+
+ def liste = {
+ try {
+ List<Map> resultat = cahierDeTextesMasqueService.findAllCahierMasque(getSecuriteSession()).collect {
+ [
+ id: it.id,
+ libelle: it.nomAffichage((Autorite) getSecuriteSession().defaultAutorite)
+ ]
+ }
+
+ resultat.sort {a, b ->
+ comparateurLogique.compare(
+ a.libelle.toUpperCase(),
+ b.libelle.toUpperCase()
+ )
+ }
+
+ render([success: true, liste: resultat] as JSON)
+
+ } catch (Exception e) {
+ log.error "liste", e
+ render([success: false, message: message(code: 'eliot.textes.masque.liste.message.erreur')] as JSON)
+ }
+
+ }
+
+}
TextesImpressionStockageService textesImpressionStockageService
CalendrierService calendrierService
- SimpleDateFormat sdf = new SimpleDateFormat(
- DateConstantes.DD_MM_YYYY,
- Locale.FRANCE
- )
- SimpleDateFormat impressionSdf = new SimpleDateFormat(
- "yyyy-MM-dd",
- Locale.FRANCE
- )
-
def index = {
if (!securiteSession.hasFonctionIn(
[org.lilie.services.eliot.annuaire.FonctionEnum.DIRECTION]
eliot.textes.recherche.libelle.tous=Tous
eliot.textes.recherche.libelle.non=Non
eliot.textes.recherche.libelle.oui=Oui
+eliot.textes.recherche.libelle.vide=Vide
+eliot.textes.recherche.libelle.masquerCahiers=Masquer les cahiers de textes classes
+
eliot.textes.recherche.message.rechercheEnCours=Recherche en cours...
+eliot.textes.recherche.message.popupMasquageInfo=Les cahiers de textes ayant au moins une activité ne sont pas inclus dans les cahiers de textes à masquer.
+
+eliot.textes.recherche.button.boutonMasquer= Masquer
+eliot.textes.button.boutonAfficher= Afficher
+eliot.textes.button.boutonAnnuler= Annuler
eliot.textes.cahier.impression.visePar=Visé par {0} le {1}
eliot.textes.cahier.impression.commntaires=Commentaire : {0}
eliot.textes.libelle.activitesAdjacentes=Activités adjacentes
eliot.textes.libelle.AucunCoursCorespondant=Aucun cours correspond à la date de l'activité
eliot.textes.libelle.ouvert=Ouvert le
+eliot.textes.libelle.popupAfficherCahiersMasques=Afficher les cahiers de textes masqués
eliot.texte.travailALaMaison.annuler.titre=Confirmation du devoir à la maison
eliot.texte.travailALaMaison.annuler.message=Confirmez-vous l'annulation de la création du devoir à la maison ?
eliot.textes.dossier.archive.nom={0} ({1}/{2})
-eliot.textes.modififcationActivite.documents.enregistrementEchoue=Un ou plusieurs document(s) n'ont pas pu être joint(s) à l'activité.
\ No newline at end of file
+eliot.textes.modififcationActivite.documents.enregistrementEchoue=Un ou plusieurs document(s) n'ont pas pu être joint(s) à l'activité.
+
+eliot.textes.masque.message.succes=Le cahier de textes a été masqué avec succès.
+eliot.textes.masques.message.succes=Les cahiers de textes ont été masqués avec succès.
+eliot.textes.masque.message.erreur=Une erreur s'est produite lors du masquage de cahier de textes.
+
+eliot.textes.montre.message.succes=Le cahier de textes a été réactivé avec succès.
+eliot.textes.montres.message.succes=Les cahiers de textes ont été réactivés avec succès.
+eliot.textes.montre.message.erreur=Une erreur s'est produite lors de la réactivation de cahier de textes.
+
+eliot.textes.masque.liste.message.erreur=La liste des cahiers de textes masqués a échoué.
\ No newline at end of file
),
getAutorite(populationCahier.directeur)
)
+
cahierDeTextes.parentIncorporation = cahierClasse
+
}
private partageCahierAuGroupeDirection(PopulationTestEtablissement populationTestEtablissement,
package org.lilie.services.eliot.textes
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
import org.lilie.services.eliot.scolarite.Service
/**
+++ /dev/null
-/*
- * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
- * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
- *
- * Lilie is free software. You can redistribute it and/or modify since
- * you respect the terms of either (at least one of the both license) :
- * - under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- * - the CeCILL-C as published by CeCILL-C; either version 1 of the
- * License, or any later version
- *
- * There are special exceptions to the terms and conditions of the
- * licenses as they are applied to this software. View the full text of
- * the exception in file LICENSE.txt in the directory of this software
- * distribution.
- *
- * Lilie is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * Licenses for more details.
- *
- * You should have received a copy of the GNU General Public License
- * and the CeCILL-C along with Lilie. If not, see :
- * <http://www.gnu.org/licenses/> and
- * <http://www.cecill.info/licences.fr.html>.
- */
-
-package org.lilie.services.eliot.textes
-
-import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.securite.AccessManager
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.annuaire.SecuriteSession
-
-/**
- * Service de gestion de l'incorporation de cahier de textes de service
- * de sous-groupes dans le cahier de texte de la division (classe) associée
- *
- * Définition des concepts:
- *
- * - l'EEM (Empreinte Enseignant Matière) d'un cahier : désigne le couple
- * <enseignant, matière>
- *
- * - Un cahier est compatible pour l'incorporation dans un cahier parent s'il
- * vérifie les conditions suivantes :
- * + Différent du cahierParent
- * + Pas incorporé ou incorporé dans le cahier parent
- * + N'incorpore aucun cahier
- * + EEM identique au cahier parent
- * + De la même année scolaire que le cahier parent
- * + Si le cahier est associé à une classe, ce doit être la même classe que
- * le cahier parent
- * + Si le cahier est associé à un groupe, ce doit être un sous-groupe
- * exclusif que la classe du cahier parent
- *
- * - Un cahier est incorporable dans un cahier parent si :
- * + Est vide (aucun chapitre et aucune activité)
- * + N'incorpore aucun cahier
- * + N'est pas déjà incorporé
- * + A la même EEM que le cahier parent
- * + Si le cahier est associé à une classe, ce doit être la même classe que
- * le cahier parent
- * + Si le cahier est associé à un groupe, ce doit être un sous-groupe
- * exclusif que la classe du cahier parent
- *
- * @author jtra
- * @author jbui
- */
-class CahierIncorporationService {
-
- LocalStructureEnseignementService localStructureEnseignementService
-
- /**
- * @param cahierParent un cahier d'une division (classe)
- * @return les informations d'incorporations pour cahierParent (les cahiers
- * incorporés, les cahiers incorporables et les cahiers non-incorporables car
- * non vides)
- */
- List<CahierIncorporationInfo> getFilsCompatiblesIncorporationInfo(SecuriteSession securiteSession,
- CahierDeTextes cahierParent)
- throws AutorisationException {
-
- verifieSecuriteSessionEstProprietaire(
- securiteSession,
- cahierParent,
- "Accés au cahier de textes $cahierParent non autorisé."
- )
-
- List<CahierDeTextes> listeFilsCompatibles =
- findCahiersCompatiblesPourIncorporationDans(
- cahierParent
- )
-
- return listeFilsCompatibles.collect { CahierDeTextes cahierFilsCompatible ->
-
- getCahierIncorporationInfo(
- securiteSession,
- cahierParent,
- cahierFilsCompatible
- )
- }
- }
-
- /**
- * Retourne les informations d'incorporation d'un cahier
- * @param cahier : le cahier parent
- * @return un CahierIncorporationInfo
- */
- private CahierIncorporationInfo getCahierIncorporationInfo(SecuriteSession securiteSession,
- CahierDeTextes cahierParent,
- CahierDeTextes cahier) {
-
- if (cahier.parentIncorporation && cahier.parentIncorporation != cahierParent) {
- throw new IllegalStateException(
- "Le cahier $cahier est incorporé dans un autre cahier que " +
- "le parent fournit ($cahierParent)"
- )
- }
- // TOREFACT : provisoir : à reprendre pour utiliser que la fonction
- // : nomAffichage afin d'uniformiser le nom de cahier de textes
- // affiché dans toutes les pages de l'application
- String modalite = cahier.service?.modaliteCours?.libelleCourt ?: cahier.service?.modaliteCours?.libelleLong
-
- String nomAffichage = cahier.nomAffichage(
- (Autorite) securiteSession.defaultAutorite) + ' - ' + modalite
-
- return new CahierIncorporationInfo(
- [
- id: cahier.id,
- idParent: cahierParent.id,
- estVide: cahier.estVide(),
- estIncorpore: (cahier.parentIncorporation == cahierParent),
- nomAffichage: nomAffichage
- ]
- )
- }
-
- /**
- * Retourne la liste des cahiers qui peuvent être parent pour l'incorporation
- * du cahier passé en argument
- * Critères :
- * - Différent de cahierFils
- * - N'est pas incorporé
- * - Est associé à
- * @param cahierFils le cahier à tester
- * @return la liste des cahiers qui peuvent être parent pour l'incorporation
- * du cahier passé en argument
- */
- protected List<CahierDeTextes> findCahiersParentsIncorporationCompatibles(CahierDeTextes cahierFils) {
-
- if (!hasPreconditionsIncorporation(cahierFils)) {
- return []
- }
-
- def crit = CahierDeTextes.createCriteria()
- List<CahierDeTextes> listeCahiers = crit.list {
- and {
-
- // Vérifie que le cahier est différent de cahierFils
- ne('id', cahierFils.id)
-
- // Vérifie que le cahier n'est pas incorporé
- isNull('parentIncorporation')
-
- service {
- eq("matiere", cahierFils.service.matiere)
- structureEnseignement {
- eq("type", StructureEnseignement.TYPE_CLASSE)
- eq("anneeScolaire", cahierFils.service.anneeScolaire)
- }
- or {
- eq('structureEnseignement', cahierFils.service.structureEnseignement)
- structureEnseignement {
- groupes {
- eq('id', cahierFils.service.structureEnseignement.id)
- }
- }
- }
- }
-
- // Vérifie que le cahier a le même propriétaire que cahierFils
- item {
- autorisations {
- eq("proprietaire", true)
- eq("autorite", cahierFils.proprietaire)
- }
- }
- }
- }
-
- return listeCahiers
- }
-
- /**
- * Teste si un cahier vérifie les conditions nécessaires pour pouvoir être
- * incorporé
- * Critères :
- * - Ne pas être déjà incorporé
- * - N'incorpore aucun cahier
- * - Etre vide
- * - Ne pas être associé à un groupe associé à plusieurs classes
- * Remarque : un cahier qui vérifie les préconditions d'incorporations n'est
- * pas nécessairement incorporable car il n'existe pas forcément de parent
- * compatible pour ce cahier
- * @param cahier le cahier à tester
- * @return <code>true</code> si la cahier rempli les conditions pour être
- * incorporable, <code>false</code> sinon
- */
- boolean hasPreconditionsIncorporation(CahierDeTextes cahier) {
- // Si le cahier est déjà incorporé
- if (cahier.parentIncorporation) {
- return false
- }
-
- // Si le cahier incorpore d'autres cahiers
- if (cahier.cahiersIncorpores) {
- return false
- }
-
- // Si le cahier est non vide
- if (!cahier.estVide()) {
- return false
- }
-
- // Si le cahier n'est pas de service
- if (!cahier.service) {
- return false
- }
-
- // Si le cahier est associé à un groupe associé à plusieurs classes
- if (cahier.service.structureEnseignement.type == StructureEnseignement.TYPE_GROUPE) {
- if (cahier.service.structureEnseignement.classes?.size() != 1) {
- return false
- }
- }
-
- return true
- }
-
- /**
- * Retourne les cahiers compatibles pour une incorporation dans cahierParent
- * Critères :
- * - Différent de cahierParent
- * - Pas incorporé ou incorporé dans cahierParent
- * - N'incorpore aucun cahier
- * - EEM identique à cahierParent
- * - Année scolaire identique à cahierParent
- * - Si cahier de type classe, classe identique à cahierParent
- * - Si cahier de type groupe, le groupe est un sous-groupe exclusif de la
- * classe de cahierParent
- *
- * @param cahierParent
- * @return une liste de cahiers potentiellement incorporables
- */
- protected List<CahierDeTextes> findCahiersCompatiblesPourIncorporationDans(CahierDeTextes cahierParent) {
- if (cahierParent.service?.structureEnseignement?.type !=
- StructureEnseignement.TYPE_CLASSE) {
- throw new IllegalArgumentException(
- "Le cahier de textes $cahierParent " +
- "n'est pas associé à une structure d'enseignement de type 'classe'."
- )
- }
-
- def crit = CahierDeTextes.createCriteria()
- List<CahierDeTextes> listeCahiers = crit.list {
- and {
- // Vérifie que le cahier et cahierParent sont différents
- ne('id', cahierParent.id)
-
- // Vérifie que le cahier n'est pas déjà incorporé, ou est incorporé dans
- // cahierParent
- or {
- isNull('parentIncorporation')
- eq('parentIncorporation', cahierParent)
- }
-
- // Vérifie que le cahier n'incorpore aucun cahier
- isEmpty('cahiersIncorpores')
-
- service {
- eq("matiere", cahierParent.service.matiere)
- structureEnseignement {
- eq("anneeScolaire", cahierParent.service.anneeScolaire)
- }
- // Vérifie que le cahier est le cahier de la classe de cahierParent ou
- // d'un sous-groupe exclusif de la classe de cahier parent
- or {
- eq("structureEnseignement", cahierParent.service.structureEnseignement)
- structureEnseignement {
- and {
- eq('type', StructureEnseignement.TYPE_GROUPE)
- classes {
- eq('id', cahierParent.service.structureEnseignement.id)
- }
- sizeEq('classes', 1)
- }
- }
- }
- }
-
- // Vérifie que le cahier a le même propriétaire que cahier parent
- item {
- autorisations {
- eq("proprietaire", true)
- eq("autorite", cahierParent.proprietaire)
- }
- }
- }
- }
-
- return listeCahiers
- }
-
- /**
- * Incorpore un cahier dans son cahier parent
- * @param cahierAIncorporer le cahier à incorporer
- * @param cahierParent le cahier parent
- * @throws IllegalArgumentException si cahierAIncorporer et cahierParent sont
- * incompatibles
- */
- void incorporeCahierDans(SecuriteSession securiteSession,
- CahierDeTextes cahierAIncorporer,
- CahierDeTextes cahierParent
- )
- throws IllegalArgumentException, AutorisationException {
-
- verifieSecuriteSessionEstProprietaire(
- securiteSession,
- cahierParent,
- "Tentative d'incorporation du cahier $cahierAIncorporer par un " +
- "utilisateur non propriétaire."
- )
-
- if (!estIncorporableDans(cahierAIncorporer, cahierParent)) {
- throw new IllegalArgumentException(
- "Le cahier $cahierAIncorporer n'est pas incorporable " +
- "dans $cahierParent."
- )
- }
-
- internalIncorporeCahierDans(cahierAIncorporer, cahierParent)
- }
-
- /**
- * Incorpore un cahier dans cahierParent
- * Important ! La compatibilité de cahierParent et cahierAIncorporer n'est pas
- * vérifée
- * @param cahierAIncorporer le cahier à incorporer
- * @param cahierParent le cahier parent
- */
- private void internalIncorporeCahierDans(CahierDeTextes cahierAIncorporer,
- CahierDeTextes cahierParent) {
- cahierParent.addToCahiersIncorpores(cahierAIncorporer)
- cahierParent.save()
- }
-
- /**
- * Désincorpore un cahiers
- * @param cahier le cahier à désincorporer
- */
- void desincorporeCahier(SecuriteSession securiteSession,
- CahierDeTextes cahier) {
-
- verifieSecuriteSessionEstProprietaire(
- securiteSession,
- cahier,
- "Tentative de désincorporation du cahier $cahier par un " +
- "utilisateur non propriétaire."
- )
-
- if (!cahier.parentIncorporation) {
- return // le cahier n'est pas incorporé
- }
-
- cahier.parentIncorporation.removeFromCahiersIncorpores(
- cahier
- )
- }
-
- /**
- * Teste si un cahier est incorporé
- * @param cahier un cahier de textes
- * @return <code>true</code> si cahier est incorporé, <code>false</code> sinon
- */
- boolean estIncorpore(CahierDeTextes cahier) {
- return (cahier.parentIncorporation as Boolean)
- }
-
- /**
- * Teste si un cahier est incorporable dans cahierParent
- * Critères :
- * - Est vide (aucun chapitre et aucune activité)
- * - N'incorpore aucun cahier
- * - N'est pas déjà incorporé
- * - A la même EEM que le cahier parent
- * - Si le cahier est associé à une classe, ce doit être la même classe que
- * le cahier parent
- * - Si le cahier est associé à un groupe, ce doit être un sous-groupe
- * exclusif que la classe du cahier parent
- *
- * @param cahier un cahier de textes
- * @param cahierParent un cahier de textes
- * @return <code>true</code> si cahier est incorporable dans cahierParent,
- * <code>false</code> sinon
- */
- boolean estIncorporableDans(CahierDeTextes cahier, CahierDeTextes cahierParent) {
-
- if (!cahier.estVide()) {
- log.debug ' cahier vide'
- return false
- }
-
- if (cahier.cahiersIncorpores?.size() > 0) {
- log.debug 'a des cahiers incorporés'
- return false
- }
-
- if (cahier.id == cahierParent.id) {
- log.debug 'identique au père'
- return false
- }
-
- if (cahier.parentIncorporation) {
- log.debug 'déjà incorporé'
- return false
- }
-
- if (!cahier.service ||
- !cahierParent.service ||
- cahier.service.matiere != cahierParent.service.matiere) {
- log.debug 'Pas la même matière, pas de service (ni père , ni cahier)'
- return false
- }
-
- if (cahier.getProprietaire().id != cahierParent.getProprietaire().id) {
- 'Pas le même propriétaire'
- return false
- }
-
- if (cahierParent.service.structureEnseignement.type !=
- StructureEnseignement.TYPE_CLASSE) {
- 'Le parent n est pas un cdt de classe'
- return false
- }
-
- if (cahier.service.structureEnseignement.type == StructureEnseignement.TYPE_CLASSE) {
- boolean memeClasse = (
- cahier.service.structureEnseignement.id ==
- cahierParent.service.structureEnseignement.id
- )
- if (!memeClasse) {
- log.debug 'Pas la même classe'
- }
- return memeClasse
- }
- else {
-
- if (localStructureEnseignementService.isSousGroupeExclusivementDe(
- cahier.service.structureEnseignement,
- cahierParent.service.structureEnseignement
- )
- ) {
- return true
- }
-
- }
- log.debug 'dernier cas'
- return false
- }
-
-
- /**
- * Vérifie que la securiteSession est propriétaire du cahier
- * @param securiteSession la session de sécurité de l'utilisateur Eliot
- * @param cahier le cahier accédé
- * @param messageErreur le message d'erreur à transmettre dans l'exception
- * le cas échéant
- * @throws AutorisationException si la securiteSession n'est pas propriétaire
- * du cahier
- */
- private void verifieSecuriteSessionEstProprietaire(SecuriteSession securiteSession,
- CahierDeTextes cahier,
- String messageErreur)
- throws AutorisationException {
- AccessManager am = new AccessManager(cahier.item, securiteSession)
-
- if (!am.sessionEstProprietaireItem()) {
- throw new AutorisationException(messageErreur)
- }
- }
-}
package org.lilie.services.eliot.textes
import org.lilie.services.eliot.textes.arbre.DossierInfoAffichage
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
/**
* Représente le lien entre un cdt et un dossier
String hql = """from CahierDeTextes cdt
where cdt.service.structureEnseignement = :struct
and cdt.parentIncorporation is null
+ and cdt.isMasque = false
and exists (
from Autorisation aut
where aut.item = cdt.item
String hql = """select count(*) from CahierDeTextes cdt
where cdt.service.structureEnseignement = :struct
and cdt.parentIncorporation is null
+ and cdt.isMasque = false
and exists (
from Autorisation aut
where aut.item = cdt.item
import org.lilie.services.eliot.forum.EtatDiscussion
import org.lilie.services.eliot.forum.TypeModeration
import org.lilie.services.eliot.textes.TypeActivite
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
import org.lilie.services.eliot.textes.arbre.DossierInfoAffichage
import org.lilie.services.eliot.textes.DossierRempli
import org.lilie.services.eliot.textes.activite.initialisation.ActiviteMaison
import org.lilie.services.eliot.textes.activite.formulaire.ActiviteFormulaireCommand
import org.lilie.services.eliot.temps.DateUtil
-import java.text.SimpleDateFormat
+
import org.lilie.services.eliot.textes.activite.initialisation.ActiviteDate
import org.lilie.services.eliot.applications.textes.ActiviteMarshallerService
import org.lilie.services.eliot.textes.Activite
class TextesActiviteMarshallerService {
ActiviteMarshallerService activiteMarshallerService
- Map marshallCreationActiviteMaison(ActiviteFormulaireCommand command, ActiviteMaison activiteMaison, Locale locale) {
+ public Map marshallCreationActiviteMaison(ActiviteFormulaireCommand command, ActiviteMaison activiteMaison, Locale locale) {
Map result = marshallInfosGenerales(command)
result += marshallCreationActiviteMaison(activiteMaison, locale)
return result
}
- Map marshallCreationActiviteMaison(ActiviteMaison activiteMaison, Locale locale) {
+ public Map marshallCreationActiviteMaison(ActiviteMaison activiteMaison, Locale locale) {
return [
typeActiviteId: activiteMaison.type?.id,
dateDonneeLe: DateUtil.formateDateToJS(activiteMaison.donneeLe),
]
}
- Map marshallCreationActiviteClasse(ActiviteFormulaireCommand command, ActiviteClasse activiteClasse, Locale locale) {
+ public Map marshallCreationActiviteClasse(ActiviteFormulaireCommand command, ActiviteClasse activiteClasse, Locale locale) {
Map result = marshallInfosGenerales(command)
result.typeActiviteId = activiteClasse.type?.id
return result
}
- Map marshallActiviteDate(ActiviteDate activiteDate, Locale locale) {
+ public Map marshallActiviteDate(ActiviteDate activiteDate, Locale locale) {
return [
jour: DateUtil.formateDateToJS(activiteDate.date),
evenementId: activiteDate.evenement ? activiteDate.evenement.id : '-1',
]
}
- List marshallActivitesAdjacentes(List<Activite> activiteAdjacentess) {
+ public List marshallActivitesAdjacentes(List<Activite> activiteAdjacentess) {
return activiteAdjacentess.collect {it.resume}
}
- private Map marshallInfosGenerales(ActiviteFormulaireCommand command) {
- return [
- cahierDeTextesId: command.cahierDeTextesId,
- chapitreId: command.chapitreId ?: -1,
- discussion: [
- etatCode: EtatDiscussion.CODE_FERME,
- moderationCode: TypeModeration.CODE_NVEAUX_MESSAGES_MASQUES
- ],
- documentsModele: [donnees: []]
- ]
- }
/**
* Retourne la liste des états de discussion dans l'ordre
* @return
return result
}
- /**
- * Retourne les infos pour un état
- * @param code
- * @return
- */
- private Map getEtatDiscussionInfoForCode(String code, List<EtatDiscussion> etats) {
- EtatDiscussion etat = etats.find {it.code == code}
- return [code: etat.code, libelle: etat.libelle]
- }
-
/**
* @return La liste des types de modérations sous la forme de maps [code: libelle:]
*/
- List<Map> marshallAllTypeModeration(List<TypeModeration> allTypeModeration) {
+ public List<Map> marshallAllTypeModeration(List<TypeModeration> allTypeModeration) {
List<Map> result = []
result << getTypeModerationInfoForCode(
TypeModeration.CODE_NVEAUX_MESSAGES_MASQUES,
return 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,
- List<TypeModeration> allTypeModeration) {
- TypeModeration type = allTypeModeration.find {it.code == code}
- return [code: type.code, libelle: type.libelle]
- }
-
/**
* Retourne la liste des chapitres sous la forme d'une liste de maps
* @param command
* @return
*/
- List marshallChapitreListePlate(Collection chapitreListePlate) {
+ public List marshallChapitreListePlate(Collection chapitreListePlate) {
List chapitreInfos = chapitreListePlate.collect {Map item ->
[
* Retourne la liste des types d'activités sous forme de maps
* @return
*/
- List marshallAllTypeActivite(List<TypeActivite> types) {
+ public List marshallAllTypeActivite(List<TypeActivite> types) {
return types.sort {it.libelle}.collect {
[
}
}
- List marshallAllDossierRempli(List<DossierRempli> allDossierRempli) {
+ public List marshallAllDossierRempli(List<DossierRempli> allDossierRempli) {
List allCahierParDossier = []
allDossierRempli.each {
return allCahierParDossier
}
+ private Map marshallInfosGenerales(ActiviteFormulaireCommand command) {
+ return [
+ cahierDeTextesId: command.cahierDeTextesId,
+ chapitreId: command.chapitreId ?: -1,
+ discussion: [
+ etatCode: EtatDiscussion.CODE_FERME,
+ moderationCode: TypeModeration.CODE_NVEAUX_MESSAGES_MASQUES
+ ],
+ documentsModele: [donnees: []]
+ ]
+ }
+
+ /**
+ * @param code
+ * @param allTypeModeration
+ * @return une Map décrivant le type de modération dont le code est passé
+ */
+ private Map getTypeModerationInfoForCode(String code,
+ List<TypeModeration> allTypeModeration) {
+ TypeModeration type = allTypeModeration.find {it.code == code}
+ return [code: type.code, libelle: type.libelle]
+ }
+
+ /**
+ * Retourne les infos pour un état
+ * @param code
+ * @return
+ */
+ private Map getEtatDiscussionInfoForCode(String code, List<EtatDiscussion> etats) {
+ EtatDiscussion etat = etats.find {it.code == code}
+ return [code: etat.code, libelle: etat.libelle]
+ }
+
+
}
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.textes.Dossier
-import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.arbre.dossier.MesCahiersPrives
import org.lilie.services.eliot.textes.arbre.dossier.CahiersDeClassePartage
import org.lilie.services.eliot.textes.arbre.dossier.MesCahiersDeClasse
import org.lilie.services.eliot.etat.arbre.Noeud
import org.lilie.services.eliot.textes.DossierRempli
import org.lilie.services.eliot.etat.arbre.Chemin
-import org.lilie.services.eliot.securite.impl.Autorisation
-import org.lilie.services.eliot.ItemService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.securite.Permission
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.textes.RelCahierActeur
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.scolarite.personne.enseignant.EnseignantAnnuaireService
import org.lilie.services.eliot.textes.ActeurAllCahierPersonnalise
-import org.lilie.services.eliot.textes.cahierdetextes.DossierInfo
-import org.lilie.services.eliot.securite.impl.Item
-import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheCriteres
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnaliseService
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
/**
* Permet de récupérer la structure arborescente décrivant les cahiers de
//TOREFACT : 0016328: Convertir les méthodes de rendu JSON de l'arbre dossier/cdt en converter
class ArbreService implements ApplicationContextAware {
+ CahierDeTextesPersonnaliseService cahierDeTextesPersonnaliseService
+
static transactional = true
public static final Long ID_DOSSIER_ARCHIVES_PARENT = -2000
) {
List<CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise =
- getAllCahierDeTextesPersonnalise(
- securiteSession,
- seulementModifiable
- )
-
- List<DossierRempli> allCahierByDossier = []
-
- allCahierByDossier += getDossierMesCahierPrive(
- locale,
- allCahierDeTextesPersonnalise,
- masquerDossierVide
- )
-
- if (
- (securiteSession.hasFonctionIn(
- [
- FonctionEnum.ENSEIGNANT
- ])
- )
- ||
- enseignantAnnuaireService.wasEnseignant(
- securiteSession
- )
- ) {
- allCahierByDossier += getDossierMesCahierDeClasse(
- locale,
- allCahierDeTextesPersonnalise,
- false
- )
- }
-
- allCahierByDossier += getDossierCahiersClassePartage(
- locale,
- allCahierDeTextesPersonnalise,
- masquerDossierVide
- )
-
- allCahierByDossier += getDossierCahiersPrivesPartages(
- locale,
- allCahierDeTextesPersonnalise,
- masquerDossierVide
- )
-
- allCahierByDossier += getAllDossierArchive(
- allCahierDeTextesPersonnalise,
- locale,
- masquerDossierVide
- )
-
- allCahierByDossier += getAllDossierUtilisateur(
- securiteSession,
- allCahierDeTextesPersonnalise,
- masquerDossierVide
- )
-
- return allCahierByDossier
- }
-
- /**
- * Récupère la structure complète de l'arbre des dossiers/cahiers de textes
- * Pour chaque dossier(NoeudArbreDossier) on a une liste de cahiers
- * de textes associée.
- * @param securiteSession : pour une session donnée
- * @param locale : pour une localisation donnée
- * @param seulementModifiable : on peut demander uniquement les cahiers de
- * textes modifiables.
- * @param dossierInfo dossier dans lequel on veut chercher les cahiers
- * @return
- */
- public List<CahierDeTextesPersonnalise> findAllCahierParDossier(SecuriteSession securiteSession,
- DossierInfo dossierInfo,
- Locale locale = null,
- boolean seulementModifiable = false,
- boolean masquerDossierVide = false) {
-
- List<CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise =
- getAllCahierDeTextesPersonnalise(
+ cahierDeTextesPersonnaliseService.findAllCahierDeTextesVisibles(
securiteSession,
seulementModifiable
)
- switch (dossierInfo.typeDossier) {
- case DossierTypeEnum.MES_CAHIERS_PRIVES:
- return extractAllMesCahierPrive(
- allCahierDeTextesPersonnalise
- )
- case DossierTypeEnum.MES_CAHIERS_DE_CLASSE:
- return extractAllMesCahierClasse(
- allCahierDeTextesPersonnalise
- )
- case DossierTypeEnum.CAHIERS_DE_CLASSE_PARTAGE:
- return extractAllCahierClassePartage(
- allCahierDeTextesPersonnalise
- )
- case DossierTypeEnum.CAHIERS_PRIVE_PARTAGE:
- return extractAllCahierPrivePartage(
- allCahierDeTextesPersonnalise
- )
- case DossierTypeEnum.ARCHIVE:
-
-
- return extractAllCahierDansDossierArchive(
- allCahierDeTextesPersonnalise
- )
- default:
- throw new IllegalArgumentException(
- "Dossier de type ${dossierInfo.typeDossier} ne devrait pas " +
- "etre comme un parametre de recherche")
-
- }
-
-
List<DossierRempli> allCahierByDossier = []
allCahierByDossier += getDossierMesCahierPrive(
return allCahierByDossier
}
- /**
- * Requete pour recuperer les cahiers de textes personalises
- * @param champsPrechargements champs a pre-charger
- * @param avecCahiersArchives
- * @return
- */
- private String getHqlAllCahier(CahierDeTextesRechercheCriteres criteres) {
- String hql = """
- select cdt, aut, dossier
- from RelDossierAutorisationCahier rel
- left join rel.dossier as dossier with dossier.proprietaire.id = :defaultAutoriteId
- right join rel.autorisation as aut,
- CahierDeTextes cdt
- left join fetch cdt.service as s
- left join fetch s.structureEnseignement as se
- left join fetch se.etablissement
- left join fetch cdt.anneeScolaire as annee
- where aut.autorite in (:allAutorite) and
- aut.item.type = :typeCdt and
- cdt.item = aut.item and
- cdt.parentIncorporation is null
- """
- if (criteres) {
- if (!criteres.avecCahiersArchives) {
- hql += " and (annee is null OR annee = :anneeScolaire)"
- }
- if (criteres.matiere) {
- hql += " and s.matiere = :matiere"
- }
- if (criteres.structure) {
- hql += " and se = :structureEnseignement"
- }
- if (criteres.estVise != null) {
- hql += " and cdt.estVise = :estVise"
- }
- }
-
- return hql
- }
-
- /**
- * Prepare les parametres pour la requete HQL de la recherche des cahiers
- * @param securiteSession
- * @param criteres
- * @return
- */
- Map getHqlAllCahierParams(SecuriteSession securiteSession,
- CahierDeTextesRechercheCriteres criteres) {
- Map hqlParams = [
- defaultAutoriteId: securiteSession.defaultAutorite.id,
- allAutorite: securiteSession.autorites,
- typeCdt: ItemService.ITEM_TYPE_CDT
- ]
- if (criteres) {
- if (!criteres.avecCahiersArchives) {
- hqlParams.anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
- }
- if (criteres.matiere) {
- hqlParams.matiere = criteres.matiere
- }
- if (criteres.structure) {
- hqlParams.structureEnseignement = criteres.structure
- }
- if (criteres.estVise != null) {
- hqlParams.estVise = criteres.estVise
- }
- }
- return hqlParams
- }
-
- /**
- *
- * @param securiteSession
- * @param seulementModifiable
- * @param criteres criteres de recherche qui peuvent servir a l'otimisation de la requete
- * @return
- */
- List<CahierDeTextesPersonnalise> getAllCahierDeTextesPersonnalise(SecuriteSession securiteSession,
- boolean seulementModifiable,
- CahierDeTextesRechercheCriteres criteres = null) {
-
- def allCahierDeTextesPersonnaliseData = CahierDeTextes.executeQuery(
- getHqlAllCahier(criteres),
- getHqlAllCahierParams(securiteSession, criteres)
- ).collect {
- [
- cahierDeTextes: it[0],
- autorisation: it[1],
- dossier: it[2],
- nomAlias: ''
- ]
- }
-
- if (!allCahierDeTextesPersonnaliseData) {
- return []
- }
-
- def allCahierNomAlias = [:]
- List<RelCahierActeur> allRelCahierActeur =
- RelCahierActeur.executeQuery("""
- from RelCahierActeur rel
- where rel.acteur = :autorite
- AND rel.cahierDeTextes in (:allCahierDeTextes)
-""",
- [
- autorite: securiteSession.defaultAutorite,
- allCahierDeTextes: allCahierDeTextesPersonnaliseData*.cahierDeTextes
- ]
- )
-
- allRelCahierActeur.each {
- RelCahierActeur relCahierActeur ->
- allCahierNomAlias[relCahierActeur.cahierDeTextes] = relCahierActeur.aliasNom
- }
-
- List<CahierDeTextesPersonnalise> cahiersPersonalises = extractAllCahierDeTextesPersonnalise(
- allCahierDeTextesPersonnaliseData,
- allCahierNomAlias,
- seulementModifiable
- )
-
- ajouteInfoProprietaires(cahiersPersonalises)
- ajouteInfoPartage(securiteSession, cahiersPersonalises)
-
- return cahiersPersonalises
- }
-
- /**
- * Renseigne les proprietaires de cahiers.
- * PI: Cahiers archives ont ENT comme le proprietaire, qui n'est pas une personne.
- * Du coup leur proprietaire n'est pas renseigne.
- * @param cdtPersonalises
- */
- private void ajouteInfoProprietaires(List<CahierDeTextesPersonnalise> cdtPersonalises) {
- List<Item> items = cdtPersonalises*.cahierDeTextes*.item
-
- if (items.isEmpty()) {
- return
- }
-
- def itemInfos = Item.executeQuery("""
- select
- item, pers
- from
- Item item
- left join item.autorisations aut,
- Personne pers
- where
- aut.proprietaire = true and
- pers.autorite = aut.autorite and
- item in (:items)
- """,
- [items: items]
- )
-
- Map<Long, Personne> itemMap = [:]
- itemInfos.each {
- Long itemId = it[0].id
- Personne personne = it[1]
- itemMap.put(itemId, personne)
- }
-
- cdtPersonalises.each { CahierDeTextesPersonnalise cdtPerso ->
- cdtPerso.proprietaire = itemMap.get(cdtPerso.cahierDeTextes.item.id)
- }
-
- }
-
- private void ajouteInfoPartage(SecuriteSession securiteSession,
- List<CahierDeTextesPersonnalise> allCahierPersonalise) {
- List<Item> items = allCahierPersonalise*.cahierDeTextes*.item
-
- if (items.isEmpty()) {
- return
- }
-
- def allItemIdPartage = Item.executeQuery("""
- select
- item.id
- from
- Item item
- inner join item.autorisations aut
- where
- aut.autorite <> :defaultAutorite and item in (:items)
- """,
- [
- items: items,
- defaultAutorite: securiteSession.defaultAutorite
- ]
- )
-
- allCahierPersonalise.each { CahierDeTextesPersonnalise cdtPerso ->
- if(cdtPerso.cahierDeTextes.item.id in allItemIdPartage) {
- cdtPerso.partage = true
- }
- }
- }
-
- private List<CahierDeTextesPersonnalise> extractAllCahierDeTextesPersonnalise(def allCahierDeTextesPersonnaliseData,
- def allCahierNomAlias,
- boolean seulementModifiable) {
-
-
- Map<CahierDeTextes, CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise = [:]
- allCahierDeTextesPersonnaliseData.each { def cahierDeTextesPersonnaliseData ->
-
- CahierDeTextes cahierDeTextes =
- cahierDeTextesPersonnaliseData.cahierDeTextes
-
- cahierDeTextesPersonnaliseData.aliasNom = allCahierNomAlias[cahierDeTextes]
-
- CahierDeTextesPersonnalise cahierDeTextesPersonnalise =
- allCahierDeTextesPersonnalise[cahierDeTextes]
-
- Autorisation autorisation = cahierDeTextesPersonnaliseData.autorisation
- Dossier dossier = cahierDeTextesPersonnaliseData.dossier
-
- if (seulementModifiable) {
-
- boolean peutModifier =
- (autorisation.valeurPermissions & Permission.PEUT_MODIFIER_CONTENU) == Permission.PEUT_MODIFIER_CONTENU
-
- if (!autorisation.proprietaire && !peutModifier) {
- return
- }
- }
-
- if (cahierDeTextesPersonnalise) {
- cahierDeTextesPersonnalise.allAutorisation << autorisation
-
- if (dossier && !cahierDeTextesPersonnalise.dossier) {
- cahierDeTextesPersonnalise.dossier = dossier
- }
-
- }
- else {
- allCahierDeTextesPersonnalise.put(
- cahierDeTextes,
- new CahierDeTextesPersonnalise(
- cahierDeTextes: cahierDeTextes,
- allAutorisation: [autorisation],
- dossier: dossier,
- aliasNom: cahierDeTextesPersonnaliseData.aliasNom
- )
- )
- }
- }
-
- return allCahierDeTextesPersonnalise.values() as List
- }
public List<DossierInfoAffichage> findAllDossier(SecuriteSession securiteSession,
Locale locale = null) {
* Rend un arbre de cahier de textes complet à partir d'une liste de noeuds ouverts
* @return
*/
- List<DossierRempli> getArbreCdtDatas(SecuriteSession securiteSession,
+ public List<DossierRempli> getArbreCdtDatas(SecuriteSession securiteSession,
ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
EtatArbre etatArbre,
Locale locale) {
CahierDeTextesRechercheCriteres criteres = null) {
List<CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise =
- getAllCahierDeTextesPersonnalise(
+ cahierDeTextesPersonnaliseService.findAllCahierDeTextesVisibles(
securiteSession,
false,
criteres
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.securite.AutorisationException
+import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
+import org.lilie.services.eliot.scolarite.etablissement.EtablissementService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.textes.ActeurAllCahierPersonnalise
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.textes.CahierDeTextesType
+import org.codehaus.groovy.grails.commons.ConfigurationHolder
+import org.lilie.services.eliot.textes.TextesCahierDeTextesService
+
+/**
+ * Gestion de droits liés aux cahiers de textes
+ * @author othe
+ */
+class CahierDeTextesDroitsService {
+
+ CiteScolaireService citeScolaireService
+ EtablissementService etablissementService
+ TextesCahierDeTextesService textesCahierDeTextesService
+
+ /**
+ * Vérifie le droit de consultation des cahiers de textes sur l'établissement
+ * @param securiteSession
+ * @param etablissement
+ */
+ public void verifieAutorisationConsultationEtablissement(SecuriteSession securiteSession,
+ Etablissement etablissement) {
+
+ if (!securiteSession.hasFonctionIn([FonctionEnum.DIRECTION], etablissement.id)) {
+
+ // Cherche l'ensemble des établissements des cités scolaires
+ // dont la personne est directeur
+ List<Etablissement> etabsDePersonne =
+ citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
+ etablissementService.findAllEtablissementsForPersonneDIR(
+ securiteSession.getPersonne()
+ )
+ )
+
+ if (!etabsDePersonne.contains(etablissement)) {
+ throw new AutorisationException(
+ "L'utilisateur [${securiteSession.getPersonne()}] " +
+ "n'a pas droit de consulter l'information sur " +
+ "l'établissement [$etablissement]"
+ )
+ }
+ }
+ }
+
+ /**
+ * Indique si l'utilisateur courant a le droit de créer des cahiers de textes
+ * @param securiteSession
+ * @return
+ */
+ public boolean isCreationCahierDeTextes(SecuriteSession securiteSession) {
+ !(
+ securiteSession?.hasFonctionIn(
+ [
+ FonctionEnum.PERS_REL_ELEVE,
+ FonctionEnum.INVITE
+ ]
+ )
+ )
+ }
+
+ /**
+ * 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) {
+ Calendar aujourdHui = Calendar.instance
+
+ boolean activerPresentationParTemps = false
+
+ if (
+ textesCahierDeTextesService.findAllCdtServiceByJour(
+ securiteSession,
+ acteurAllCahierPersonnalise,
+ aujourdHui).size() > 0
+ ) {
+ activerPresentationParTemps = true
+ }
+ return activerPresentationParTemps
+ }
+
+ /**
+ * indique si l'utilisateur a le droit à la vue par emploi du temps
+ * @param securiteSession
+ * @return
+ */
+ public boolean hasUtilisateurDroitPresentationEmploiDuTemps(SecuriteSession securiteSession) {
+ boolean ajouterPresentationParTemps =
+ ConfigurationHolder.config.eliot.textes.affichage.presentationCdt.emploiDuTemps &&
+ securiteSession.hasFonctionIn([FonctionEnum.ENSEIGNANT])
+ ajouterPresentationParTemps
+ }
+
+
+ public Boolean peutModifier(SecuriteSession securiteSession, CahierDeTextes cdt) {
+
+ AccessManager accessManager = getAccessManager(
+ securiteSession,
+ cdt)
+
+ if (!accessManager.peutModifierLeContenu()) {
+ return false
+ }
+
+ return true
+ }
+
+ public Boolean peutSupprimer(SecuriteSession securiteSession, CahierDeTextes cahier) {
+
+ AccessManager accessManager = getAccessManager(
+ securiteSession,
+ cahier
+ )
+
+ if (cahier.getType() == CahierDeTextesType.CAHIER_DE_SERVICE ||
+ cahier.getType() == CahierDeTextesType.CAHIER_PRIVE_VISE
+ ) {
+ return false
+ } else {
+ if (!accessManager.peutSupprimer()) {
+ return false
+ }
+ }
+
+ return true
+ }
+
+ public void verifierAccesConsultation(SecuriteSession securiteSession, CahierDeTextes cdt) {
+ // Vérifier les droits de consultation
+ AccessManager accessManager = new AccessManager(
+ cdt.item,
+ securiteSession
+ )
+
+ if (!accessManager.peutConsulterLeContenu()) {
+ throw AutorisationException.consultationContenuException()
+ }
+
+ }
+
+ public void verifierAccesModification(SecuriteSession securiteSession, CahierDeTextes cdt) {
+ // Vérifier les droits de consultation
+ AccessManager accessManager = new AccessManager(
+ cdt.item,
+ securiteSession
+ )
+
+ if (!accessManager.peutModifierLeContenu()) {
+ throw AutorisationException.modificationContenuException()
+ }
+
+ }
+
+ private AccessManager getAccessManager(SecuriteSession securiteSession, CahierDeTextes cdt) {
+ return new AccessManager(
+ cdt.item,
+ securiteSession
+ )
+ }
+
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.textes.ActeurAllCahierPersonnalise
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
+import org.lilie.services.eliot.textes.TextesCahierDeTextesSessionService
+
+/**
+ * Permet de récupérer des informations concernant les cahiers de textes et les emploi du temps.
+ * @author othe
+ */
+class CahierDeTextesEmploiDuTempsService {
+
+ TextesCahierDeTextesSessionService textesCahierDeTextesSessionService
+
+ /**
+ * Liste d'évènements relatives aux à une liste de cahiers de textes
+ * @param securiteSession
+ * @param acteurAllCahierPersonnalise
+ * @param date
+ * @return
+ */
+ public List<RelCahierEvenement> listeCdtParEmploiDuTemps(SecuriteSession securiteSession,
+ ActeurAllCahierPersonnalise acteurAllCahierPersonnalise,
+ Date date) {
+ Calendar dateJour = Calendar.getInstance()
+ dateJour.setTime(
+ date
+ )
+
+ Collection<RelCahierEvenement> cdtsEvntsInfo =
+ textesCahierDeTextesSessionService.findAllCdtServiceByJour(
+ securiteSession,
+ acteurAllCahierPersonnalise,
+ dateJour
+ )
+ return cdtsEvntsInfo
+
+ }
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.applications.textes.CahierDeTextesInfo
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.textes.TextesChapitreService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.textes.Visa
+import org.lilie.services.eliot.textes.visa.VisaService
+import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheInfo
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.CodeComparator
+import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
+import java.text.SimpleDateFormat
+import org.lilie.services.eliot.textes.NodeUtils
+import org.lilie.services.eliot.textes.arbre.CahierDeTextesArbreService
+import org.codehaus.groovy.grails.commons.ApplicationHolder
+import org.springframework.context.MessageSource
+import org.springframework.beans.factory.BeanCreationException
+import org.lilie.services.eliot.DateConstantes
+
+/**
+ * Service de marshalling pour les cahiers de textes
+ * @author othe
+ */
+class CahierDeTextesMarshallerService {
+
+ TextesChapitreService textesChapitreService
+ VisaService visaService
+ CahierFusionService cahierFusionService
+ LocalPersonneService localPersonneService
+ CahierDeTextesArbreService cahierDeTextesArbreService
+ CahierDeTextesDroitsService cahierDeTextesDroitsService
+
+ private static final CodeComparator comparateurLogique = new CodeComparator()
+
+ private static final SimpleDateFormat df = new SimpleDateFormat(
+ "HH'h'mm",
+ Locale.FRANCE
+ )
+
+ private static final SimpleDateFormat sdf = new SimpleDateFormat(
+ DateConstantes.DD_MM_YYYY,
+ Locale.FRANCE
+ )
+
+ /**
+ * Prepare les donnes de model pour l'apercu de cahier
+ * @param cdt
+ * @return
+ */
+ public Map marshallApercu(SecuriteSession securiteSession, CahierDeTextes cdt) {
+
+ Collection chapitresEtActivites =
+ textesChapitreService.getChapitresEtActivitesListePlate(
+ cdt,
+ securiteSession,
+ true
+ )
+
+ boolean estProprietaire = cdt.getProprietaire().idExterne ==
+ securiteSession.getDefaultAutorite().idExterne
+
+ Personne prof = Personne.findByAutorite(cdt.getProprietaire())
+
+ return [
+ cdtInfo: new CahierDeTextesInfo(
+ nomAffichage: cdt.nomAffichage(
+ (Autorite) securiteSession.defaultAutorite
+ ),
+ description: cdt.description?.encodeAsHTML(),
+ estPrive: cdt.estCahierPriveViseOuNonVise(),
+ structureEnseignementCode: cdt.service?.structureEnseignement?.code,
+ matiereLibelle: cdt.service?.matiere?.libelleLong?.encodeAsHTML()
+ ),
+ chapitresEtActivites: chapitresEtActivites,
+ estProprietaire: estProprietaire,
+ professeur: prof
+ ]
+ }
+
+ /**
+ * Prépare des données du modèle pour le visa
+ * @param peutAfficherVisas
+ * @param cdt
+ */
+ public Map marshallVisa(SecuriteSession securiteSession, boolean peutAfficherVisas, CahierDeTextes cdt) {
+
+ Map resultat = [
+ render: peutAfficherVisas,
+ renderTo: 'listeVisa',
+ visas: []
+ ]
+
+ if (peutAfficherVisas) {
+
+ List<Visa> visas = visaService.findAllVisaByCahierDeTextes(
+ securiteSession,
+ cdt
+ )
+
+ resultat.visas = visas.collect { Visa visa ->
+ [
+ id: visa.id,
+ date: sdf.format(visa.dateVisee),
+ auteur: visa.auteur?.nomAffichage(),
+ commentaire: visa.commentaire?.encodeAsHTML()
+ ]
+ }
+
+ }
+
+ return resultat
+ }
+
+ /**
+ * Marshalling des droits de lecture/écriture du cahier de textes
+ * @param cahierDeTextes
+ * @return
+ */
+ public Map marsallAccesDroitEtPermissions(SecuriteSession securiteSession, CahierDeTextes cahierDeTextes) {
+
+ AccessManager accessManager = new AccessManager(
+ cahierDeTextes.item,
+ securiteSession
+ )
+
+ boolean disableEdit = !(
+ accessManager.peutModifierLesPermissions() &&
+ !securiteSession.defaultAutorite.aUnAccesRetreint()
+ )
+
+ boolean disableDroitsEtPermissions = !accessManager.peutConsulterLesPermissions()
+
+ return [
+ 'disableEdit': disableEdit,
+ 'disableDroitsEtPermissions': disableDroitsEtPermissions
+ ]
+
+ }
+
+ /**
+ *
+ * @param securiteSession
+ * @param cahierDeTextes
+ * @return
+ */
+ public Map marshallCahierDeTextesFusionnes(SecuriteSession securiteSession, CahierDeTextes cahierDeTextes) {
+ List nomAffichageCahiersIncorpores = []
+
+ cahierDeTextes.cahiersIncorpores.each { CahierDeTextes cdtIncorpore ->
+ // TOREFACT : provisoir : à reprendre pour utiliser que la fonction
+ // : nomAffichage afin d'uniformiser le nom de cahier de textes
+ // affiché dans toutes les pages de l'application
+ String modalite = cdtIncorpore.service?.modaliteCours?.libelleCourt ?: cdtIncorpore.service?.modaliteCours?.libelleLong
+ String nomAffichage = cdtIncorpore.nomAffichage(
+ securiteSession.getDefaultAutorite()) + ' - ' + modalite
+
+ nomAffichageCahiersIncorpores.add(nomAffichage)
+ }
+
+ return [
+ nomAffichageCahiersIncorpores: nomAffichageCahiersIncorpores.sort()
+ ]
+
+ }
+
+ /**
+ * Permet de sérialiser les informations de fusion d'un cahier de textes
+ * @param securiteSession
+ * @param cdt
+ * @return
+ */
+ public Map marshallFusionCahierInfo(SecuriteSession securiteSession, CahierDeTextes cdt) {
+
+ List<CahierFusionInfo> cahiersFilsIncorporationInfo =
+ cahierFusionService.getFilsCompatiblesFusionInfo(
+ securiteSession,
+ cdt
+ )
+ List initialCdtsIncorpores = []
+
+ cdt.cahiersIncorpores.each {
+ initialCdtsIncorpores.add(it.id)
+ }
+
+ cahiersFilsIncorporationInfo.sort { CahierFusionInfo cdtInfo ->
+ cdtInfo.nomAffichage
+ }
+
+ return [
+ cahiersFilsIncorporationInfo: cahiersFilsIncorporationInfo,
+ initialCdtsIncorpores: initialCdtsIncorpores
+ ]
+
+ }
+
+ /**
+ * Marshalling de liste d'informations concernant un cahier de textes
+ * @param cdtsInfo
+ * @param locale
+ * @return
+ */
+ public Map marshall(List<CahierDeTextesRechercheInfo> cdtsInfo, Locale locale = null) {
+
+ Map resultat = [:]
+
+ Boolean contientCdtVide = false
+ List<Map> cahiers = []
+
+ cdtsInfo?.each { CahierDeTextesRechercheInfo cdtInfo ->
+
+ String cdtNom = cdtInfo.cdtNom
+ // Nom de cdt archive
+ if (cdtInfo.estCahierArchive) {
+ cdtNom = message("eliot.textes.dossier.archive.nom", [
+ cdtNom,
+ cdtInfo.anneeDebut,
+ cdtInfo.anneeFin
+ ],
+ locale)
+ }
+ // Nom de cdt avec un nom personalise
+ if (cdtInfo.nomAlias) {
+ cdtNom = "${cdtInfo.nomAlias} ($cdtNom)"
+ }
+
+ if (cdtInfo.estVide && cdtInfo.estCahierDeClasse) {
+ contientCdtVide = true
+ }
+
+ cahiers << [
+ id: cdtInfo.cdtId,
+ nom: cdtNom,
+ enseignant: localPersonneService.getNomAffichage(
+ cdtInfo.proprietaireNom,
+ cdtInfo.proprietairePrenom
+ ),
+ structure: cdtInfo.structureCode,
+ matiere: cdtInfo.matierreLibelleLong,
+ nbAct: cdtInfo.nbrActivitePubliees ?: 0,
+ dateSaisie: cdtInfo.activiteDateModification ?: null,
+ dateDernierVisa: cdtInfo.dateDernierVisa ?: null,
+ estCahierArchive: cdtInfo.estCahierArchive,
+ estVide: cdtInfo.estVide,
+ estCdtClasse: cdtInfo.estCahierDeClasse
+ ]
+ }
+
+ cahiers.sort {a, b ->
+ comparateurLogique.compare(
+ a.nom.toUpperCase(),
+ b.nom.toUpperCase()
+ )
+ }
+
+ resultat['cahiers'] = cahiers
+ resultat['contientCdtVide'] = contientCdtVide
+
+ return resultat
+ }
+
+ /**
+ *
+ * @param securiteSession
+ * @param acteurAllCahierPersonnalise
+ * @param date
+ * @return
+ */
+ public List mashallListeCdtParEmploiDuTemps(SecuriteSession securiteSession,
+ List<RelCahierEvenement> cdtsEvntsInfo) {
+ List resultats = []
+ cdtsEvntsInfo.each { RelCahierEvenement cdtEvntInfo ->
+ CahierDeTextes cahier = cdtEvntInfo.cahierDeTextes
+
+ Boolean peutSupprimerLeCdt = cahierDeTextesDroitsService.peutSupprimer(
+ securiteSession,
+ cahier
+ )
+
+ Boolean peutModifierLeContenuDuCdt = cahierDeTextesDroitsService.peutModifier(
+ securiteSession,
+ cahier
+ )
+
+ String nomAffichage = nomAffichage(
+ securiteSession,
+ cdtEvntInfo,
+ cahier)
+
+ // Si le cdt est incorporé, le cdt père est celui qui porte les activités
+ Long identifiantCdt = cahier.parentIncorporation ?
+ cahier.parentIncorporation.id :
+ cahier.id
+
+ resultats << [
+ id: NodeUtils.addPrefixeNodeCdtParTemps(
+ identifiantCdt,
+ cdtEvntInfo.evenement.id
+ ),
+ text: nomAffichage,
+ titreCahier: cahier.nom,
+ leaf: false,
+ children: [],
+ expanded: true,
+ expandable: false,
+ iconCls: cahierDeTextesArbreService.getIconeCdt(
+ securiteSession,
+ cahier),
+ peutSupprimerLeCdt: peutSupprimerLeCdt,
+ peutModifierLeContenuDuCdt: peutModifierLeContenuDuCdt
+ ]
+ }
+ return resultats
+ }
+
+ /**
+ * Permet de déterminer le nom d'affichage du cahiers de textes combiné à un évènement d'emploi du temps
+ * @param securiteSession
+ * @param cdtEvntInfo
+ * @param cahier
+ * @return
+ */
+ private String nomAffichage(SecuriteSession securiteSession, RelCahierEvenement cdtEvntInfo, CahierDeTextes cahier) {
+
+ String creneauDebut = df.format(cdtEvntInfo.evenement.dateHeureDebut)
+ String creneauFin = df.format(cdtEvntInfo.evenement.dateHeureFin)
+ String creneau = '(' + creneauDebut + ' - ' + creneauFin + ')'
+ String nomAffichage = creneau + " " + cahier.nomAffichage(
+ (Autorite)securiteSession.getDefaultAutorite(),
+ false
+ )
+ nomAffichage
+ }
+
+ public Map marshallInfoProprietaire(CahierDeTextes cahierDeTextes, Autorite proprietaire, Boolean isProprietaire) {
+ String nomProprietaire
+ String cdtInfoSuppression = ""
+
+ if (proprietaire?.type == Autorite.TYPE_ELIOT) {
+ nomProprietaire = Autorite.ENT
+ }
+ else {
+ nomProprietaire = localPersonneService.getNomAffichage(
+ cahierDeTextes.proprietaire
+ )
+ }
+
+ if (cahierDeTextes.isEnCoursDeSuppression() &&
+ !isProprietaire
+ ) {
+ nomProprietaire += " " + message( "eliot.textes.compteEnCoursSupp")
+ cdtInfoSuppression = message( "eliot.textes.cdtInfoSuppression")
+ }
+
+ ['nomProprietaire': nomProprietaire?.encodeAsHTML(),
+ cdtInfoSuppression: cdtInfoSuppression?.encodeAsHTML()]
+
+ }
+
+
+ /**
+ * Gestion i18n
+ * @param code
+ * @param args
+ * @param locale
+ * @return
+ */
+ private String message(String code, Object[] args = [], Locale locale = null) {
+ def ctx = ApplicationHolder.getApplication().getMainContext()
+ MessageSource messageSource = (MessageSource) ctx.getBean("messageSource")
+ if (messageSource == null) {
+ throw new BeanCreationException("Pas de bean de gestion i18n")
+ }
+ return messageSource.getMessage(code, args, locale)
+ }
+
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnaliseService
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.applications.textes.recherche.TextesIndexationService
+
+/**
+ * Gestion des cahiers de textes masqués
+ * @author othe
+ */
+class CahierDeTextesMasqueService {
+
+ CahierDeTextesPersonnaliseService cahierDeTextesPersonnaliseService
+ TextesIndexationService textesIndexationService
+
+ /**
+ * Liste des cahiers de textes masqués
+ * @param securiteSession
+ * @return
+ */
+ public List<CahierDeTextes> findAllCahierMasque(SecuriteSession securiteSession) {
+
+ List<CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise =
+ cahierDeTextesPersonnaliseService.findAllCahierDeTextesMasque(
+ securiteSession,
+ false)
+
+ allCahierDeTextesPersonnalise.collect {it.cahierDeTextes}
+
+ }
+
+/**
+ * Indique qu'il existe au moins un cahier de textes masqué dans la session courante.
+ * @param securiteSession
+ * @return
+ */
+ public Boolean hasCahierDeTextesMasque(SecuriteSession securiteSession) {
+ findAllCahierMasque(securiteSession).size() != 0
+ }
+
+ /**
+ * Masque le cahier de textes
+ * @param cahierDeTextes
+ */
+ public void masque(List<CahierDeTextes> cahierDeTextes) {
+
+ cahierDeTextes.each {
+
+ if (it.estVide()) {
+ it.estMasque = true
+ it.save(flush: true, failOnError: true)
+
+ if (textesIndexationService.indexationActivee()) {
+ if (!textesIndexationService.supprimerCahierDeTextes(it)) {
+ log.error "La suppression de l'indexation SOLR est en erreur."
+ }
+ }
+ }
+
+ }
+
+ }
+
+ /**
+ * Montre le cahier de textes masqué
+ * @param cahierDeTextes
+ */
+ public void montre(SecuriteSession securiteSession, List<CahierDeTextes> cahierDeTextes) {
+
+ cahierDeTextes.each {
+ it.estMasque = false
+ it.save(flush: true, failOnError: true)
+
+ if (textesIndexationService.indexationActivee()) {
+ if (!textesIndexationService.indexerCahierDeTextes(securiteSession, it, false)) {
+ log.error "L'indexation SOLR est en erreur."
+ }
+ }
+
+ }
+
+ }
+
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.textes.arbre.DossierTypeEnum
+
+/**
+ * Service utilitaire dont le but est d'aider à parser les requetes en provenance des actions de controlleur
+ * @author othe
+ */
+class CahierDeTextesRequestParserService {
+
+ /**
+ * 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
+ String etablissementIdStr = params.etablissementId
+ if (etablissementIdStr == null) {
+ throw new IllegalArgumentException("etablissementId n'est pas spécifié")
+ }
+ Long etablissementId = Long.parseLong(etablissementIdStr)
+ Etablissement etablissement = Etablissement.get(etablissementId)
+ if (!etablissement) {
+ throw new IllegalArgumentException(
+ "Etablissement [$etablissementId] n'existe pas"
+ )
+ }
+
+ return etablissement
+
+ }
+
+ /**
+ *
+ * @param params
+ * @return
+ */
+ public StructureEnseignement parseStructureEnseignement(Map params) {
+
+ StructureEnseignement resultat = null
+
+ Long structureId = params.structureId ? Long.parseLong(params.structureId) : null
+
+ if (structureId != null) {
+ resultat = StructureEnseignement.get(structureId)
+ if (!resultat) {
+ throw new IllegalArgumentException(
+ "Structure d'enseignement [$structureId] n'existe pas"
+ )
+ }
+ }
+
+ return resultat
+
+ }
+
+ /**
+ *
+ * @param params
+ * @return
+ */
+ public Personne parseEnseignant(Map params) {
+ Personne enseignant = null
+ Long enseignantId = params.enseignantId ? Long.parseLong(params.enseignantId) : null
+
+ if (enseignantId != null) {
+ enseignant = Personne.get(enseignantId)
+ if (!enseignant) {
+ throw new IllegalArgumentException(
+ "Personne [$enseignantId] n'existe pas"
+ )
+ }
+ }
+ return enseignant
+ }
+
+ /**
+ *
+ * @param params
+ * @return
+ */
+ public Matiere parseMatiere(Map params) {
+
+ Matiere matiere = null
+
+ Long matiereId = params.matiereId ? Long.parseLong(params.matiereId) : null
+
+ if (matiereId != null) {
+ matiere = Matiere.get(matiereId)
+ if (!matiere) {
+ throw new IllegalArgumentException(
+ "Matière [$matiereId] n'existe pas"
+ )
+ }
+ }
+ return matiere
+ }
+
+ /**
+ *
+ * @param params
+ * @return
+ */
+ public DossierInfo parseDossierInfo(Map params) {
+
+ Long dossierId = params.dossierId ? Long.parseLong(params.dossierId.substring(1)) : null
+
+ DossierInfo dossierInfo = null
+
+ if (dossierId != null) {
+ dossierInfo = new DossierInfo(dossierId)
+ if (dossierInfo.typeDossier == DossierTypeEnum.UTILISATEUR &&
+ dossierInfo.dossier == null) {
+ throw new IllegalArgumentException(
+ "Dossier utilisateur [id: $dossierId] n'existe pas"
+ )
+ }
+ }
+
+ return dossierInfo
+ }
+
+}
-package org.lilie.services.eliot.textes
+package org.lilie.services.eliot.textes.cahierdetextes
/**
* Information sur un cahier nécessaire pour les opérations d'incorporation
* @author jtra
* @author bahj
*/
-class CahierIncorporationInfo {
+class CahierFusionInfo {
// L'id du cahier décrit par cet objet
Long id
// L'id du parent compatible
Long idParent
- // Décrit si le cahier est vide
- boolean estVide
-
// Décrit si le cahier est incorporé dans le parent compatible
boolean estIncorpore
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+
+
+package org.lilie.services.eliot.textes.cahierdetextes
+
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.securite.AutorisationException
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.Autorisation
+import org.lilie.services.eliot.applications.textes.recherche.TextesIndexationService
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.textes.Chapitre
+import org.lilie.services.eliot.textes.Activite
+import org.lilie.services.eliot.textes.CahierDeTextesType
+
+/**
+ * Service de gestion de la fusion de cahier de textes
+ * (la notion de fusion remplace l'ancienne notion d'incorporation)
+ *
+ * @author jtra
+ * @author jbui
+ * @author othe
+ */
+class CahierFusionService {
+
+ TextesIndexationService textesIndexationService
+
+ /**
+ * @param cahierParent un cahier d'une division (classe)
+ * @return les informations de fusion pour cahierParent
+ */
+ List<CahierFusionInfo> getFilsCompatiblesFusionInfo(SecuriteSession securiteSession,
+ CahierDeTextes cahierParent)
+ throws AutorisationException {
+
+ if (!estProprietaire(securiteSession, cahierParent)) {
+ return []
+ }
+
+ List<CahierDeTextes> listeFilsCompatibles =
+ findCahiersCompatiblesPourFusionDans(
+ cahierParent
+ )
+
+ return listeFilsCompatibles.collect { CahierDeTextes cahierFilsCompatible ->
+
+ getCahierFusionInfo(
+ securiteSession,
+ cahierParent,
+ cahierFilsCompatible
+ )
+ }
+ }
+
+ /**
+ * Retourne les informations de fusion d'un cahier
+ * @param cahier : le cahier parent
+ * @return un CahierFusionInfo
+ */
+ private CahierFusionInfo getCahierFusionInfo(SecuriteSession securiteSession,
+ CahierDeTextes cahierParent,
+ CahierDeTextes cahier) {
+
+ if (cahier.parentIncorporation && cahier.parentIncorporation != cahierParent) {
+ throw new IllegalStateException(
+ "Le cahier $cahier est incorporé dans un autre cahier que " +
+ "le parent fournit ($cahierParent)"
+ )
+ }
+ // TOREFACT : provisoir : à reprendre pour utiliser que la fonction
+ // : nomAffichage afin d'uniformiser le nom de cahier de textes
+ // affiché dans toutes les pages de l'application
+ String modalite = cahier.service?.modaliteCours?.libelleCourt ?: cahier.service?.modaliteCours?.libelleLong
+
+ String nomAffichage = cahier.nomAffichage(
+ (Autorite) securiteSession.defaultAutorite) + ' - ' + modalite
+
+ return new CahierFusionInfo(
+ [
+ id: cahier.id,
+ idParent: cahierParent.id,
+ estIncorpore: (cahier.parentIncorporation == cahierParent),
+ nomAffichage: nomAffichage
+ ]
+ )
+ }
+
+ /**
+ * Teste si un cahier vérifie les conditions nécessaires pour pouvoir être
+ * incorporé
+ * Critères :
+ * - Ne pas être déjà incorporé
+ * - N'incorpore aucun cahier
+ * - Ne pas être associé à un groupe associé à plusieurs classes
+ * @param cahier le cahier à tester
+ * @return <code>true</code> si la cahier rempli les conditions pour être
+ * fusionnable, <code>false</code> sinon
+ */
+ boolean hasPreconditionsFusionne(CahierDeTextes cahier) {
+
+ if (cahier.estFusionne) {
+ return false
+ }
+
+ if (cahier.estMasque) {
+ return false
+ }
+
+ return true
+ }
+
+ /**
+ * Retourne les cahiers compatibles pour une fusion dans cahierParent
+ *
+ * @param cahierParent
+ * @return une liste de cahiers potentiellement fusionnables
+ */
+ private List<CahierDeTextes> findCahiersCompatiblesPourFusionDans(CahierDeTextes cahierParent) {
+ if (cahierParent.service?.structureEnseignement?.type !=
+ StructureEnseignement.TYPE_CLASSE) {
+ throw new IllegalArgumentException(
+ "Le cahier de textes $cahierParent " +
+ "n'est pas associé à une structure d'enseignement de type 'classe'."
+ )
+ }
+
+ def crit = CahierDeTextes.createCriteria()
+ List<CahierDeTextes> listeCahiers = crit.list {
+ and {
+ // Vérifie que le cahier et cahierParent sont différents
+ ne('id', cahierParent.id)
+
+ // Vérifie que le cahier n'est pas un cahier de textes maitre
+ or {
+ isNull('parentIncorporation')
+ eq('parentIncorporation', cahierParent)
+ }
+
+ // Vérifie que le cahier n'incorpore aucun cahier
+ isEmpty('cahiersIncorpores')
+
+ service {
+ structureEnseignement {
+ eq("anneeScolaire", cahierParent.service.anneeScolaire)
+ }
+ }
+
+ eq("estMasque", false)
+
+ // Vérifie que le cahier a le même propriétaire que cahier parent
+ item {
+ autorisations {
+ eq("proprietaire", true)
+ eq("autorite", cahierParent.proprietaire)
+ }
+ }
+ }
+ }
+
+ return listeCahiers
+ }
+
+ /**
+ * Fusionne un cahier dans son cahier parent
+ * @param cahierAFusionner le cahier à fusionner
+ * @param cahierParent le cahier parent
+ * @throws IllegalArgumentException si cahierAFusionner et cahierParent sont
+ * incompatibles
+ */
+ public void fusionneCahierDans(SecuriteSession securiteSession,
+ CahierDeTextes cahierAFusionner,
+ CahierDeTextes cahierParent
+ )
+ throws IllegalArgumentException, AutorisationException {
+
+ verifieSecuriteSessionEstProprietaire(
+ securiteSession,
+ cahierParent,
+ "Tentative d'incorporation du cahier $cahierAFusionner par un " +
+ "utilisateur non propriétaire."
+ )
+
+ if (!estFusionnableDans(cahierAFusionner, cahierParent)) {
+ throw new IllegalArgumentException(
+ "Le cahier $cahierAFusionner n'est pas incorporable " +
+ "dans $cahierParent."
+ )
+ }
+
+ internalFusionneCahierDans(cahierAFusionner, cahierParent)
+
+ reindexe(securiteSession, cahierAFusionner)
+ reindexe(securiteSession, cahierParent)
+
+ }
+
+ /**
+ * Fusionne un cahier dans cahierParent
+ * Important ! La compatibilité de cahierParent et cahierAFusionner n'est pas
+ * vérifée
+ * @param cahierAFusionner le cahier à incorporer
+ * @param cahierParent le cahier parent
+ */
+ private void internalFusionneCahierDans(CahierDeTextes cahierAFusionner,
+ CahierDeTextes cahierParent) {
+ deplaceChapitreActivite(cahierAFusionner, cahierParent)
+ copieDroitsCahierDeTextes(cahierAFusionner, cahierParent)
+
+ cahierParent.addToCahiersIncorpores(cahierAFusionner)
+ cahierParent.estFusionne = true
+ cahierParent.save(flush: true, failOnError: true)
+
+ cahierAFusionner.estFusionne = true
+ cahierAFusionner.save(flush: true, failOnError: true)
+
+ }
+
+ /**
+ * Réindexe le cahier de textes
+ * @param securiteSession
+ * @param cahierDeTextes
+ */
+ private void reindexe(SecuriteSession securiteSession, CahierDeTextes cahierDeTextes) {
+
+ if (!textesIndexationService.indexationActivee()) {
+ return
+ }
+
+ log.debug "Reindexe cahier de textes : " + cahierDeTextes.toString()
+
+ if (textesIndexationService.indexerCahierDeTextes(
+ securiteSession,
+ cahierDeTextes,
+ true
+ )) {
+ textesIndexationService.reindexerCahierDeTextesDroits(
+ securiteSession,
+ cahierDeTextes,
+ []
+ )
+ } else {
+ log.error "Le service d'indexation a échoué pour le cahier de textes " + cahierDeTextes.toString()
+ }
+
+ }
+
+ /**
+ * 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) {
+
+ Long max = findMaxOrdreCahierDeTextes(cible)
+
+ List<Chapitre> allChapitre = Chapitre.findAllByCahierDeTextes(source)
+
+ List<Activite> allActivite = Activite.findAllByCahierDeTextes(source)
+
+ allChapitre.each {
+ Chapitre chapitre ->
+
+ chapitre.ordre += max
+ chapitre.cahierDeTextes = cible
+
+ chapitre.save(flush: true, failOnError: true)
+ }
+
+ allActivite.each {
+ Activite activite ->
+
+ activite.ordre += max
+ activite.cahierDeTextes = cible
+
+ activite.save(flush: true, failOnError: true)
+ }
+
+
+ }
+
+ /**
+ * 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 =
+ (Long) Chapitre.executeQuery("select max(ordre) from Chapitre c where c.cahierDeTextes=:cdt", ['cdt': cible])[0]
+
+ maxChapitreOrdre = maxChapitreOrdre ? maxChapitreOrdre : 0
+
+ Long maxActiviteOrdre =
+ (Long) Activite.executeQuery("select max(ordre) from Activite a where a.cahierDeTextes=:cdt", ['cdt': cible])[0]
+
+ maxActiviteOrdre = maxActiviteOrdre ? maxActiviteOrdre : 0
+
+ return 1 + Math.max(maxChapitreOrdre, maxActiviteOrdre)
+
+ }
+
+ /**
+ * Copie des droits du cahier de textes source vers les droits du cdt cible
+ * Tiens compte des droits existant et les augmente en fonction des droits
+ * sources.
+ * @param source
+ * @param cible
+ */
+ private void copieDroitsCahierDeTextes(CahierDeTextes source, CahierDeTextes cible) {
+
+ List<Autorisation> allAutorisation = Autorisation.findAllByItem(source.item)
+
+ allAutorisation.each {Autorisation autorisation ->
+
+ Autorisation autorisationCible = Autorisation.findByItemAndAutorite(cible.item, autorisation.autorite)
+
+ if (autorisationCible) {
+
+ autorisationCible.valeurPermissionsExpliciteDefaut |= autorisation.valeurPermissionsExpliciteDefaut
+ autorisationCible.valeurPermissionsExplicite |= autorisation.valeurPermissionsExplicite
+ autorisationCible.proprietaire = autorisation.proprietaire
+ autorisationCible.autorisationHeritee = autorisation.autorisationHeritee
+
+ }
+ else {
+ autorisationCible = new Autorisation(
+ item: cible.item,
+ autorite: autorisation.autorite,
+ valeurPermissionsExpliciteDefaut: autorisation.valeurPermissionsExpliciteDefaut,
+ valeurPermissionsExplicite: autorisation.valeurPermissionsExplicite,
+ proprietaire: autorisation.proprietaire,
+ autorisationHeritee: autorisation.autorisationHeritee
+ )
+ }
+
+ autorisationCible.save(flush: true, failOnError: true)
+
+ }
+
+ }
+
+ /**
+ * Désincorpore un cahiers
+ * @param cahier le cahier à désincorporer
+ */
+ void detacheCahier(SecuriteSession securiteSession,
+ CahierDeTextes cahier) {
+
+ verifieSecuriteSessionEstProprietaire(
+ securiteSession,
+ cahier,
+ "Tentative de détachement du cahier $cahier par un " +
+ "utilisateur non propriétaire."
+ )
+
+ if (!cahier.parentIncorporation || !cahier.estFusionne) {
+ return // le cahier n'est pas fusionné
+ }
+
+ CahierDeTextes parent = cahier.parentIncorporation
+
+ parent.removeFromCahiersIncorpores(
+ cahier
+ )
+
+ cahier.estFusionne = false
+ cahier.save(flush: true, failOnError: true)
+
+ if (parent.cahiersIncorpores.size() == 0) {
+ parent.estFusionne = false
+ parent.save(flush: true, failOnError: true)
+ }
+
+ }
+
+ /**
+ * Teste si un cahier est fusionnable dans cahierParent
+ * Critères :
+ * - N'est pas cahier maitre
+ * - N'est pas déjà fusionné
+ * - N'est pas masqué
+ *
+ * @param cahier un cahier de textes
+ * @param cahierParent un cahier de textes
+ * @return <code>true</code> si cahier est incorporable dans cahierParent,
+ * <code>false</code> sinon
+ */
+ private boolean estFusionnableDans(CahierDeTextes cahier, CahierDeTextes cahierParent) {
+
+ if (cahier.cahiersIncorpores?.size() > 0) {
+ log.debug 'a des cahiers fusionné'
+ return false
+ }
+
+ if (cahier.id == cahierParent.id) {
+ log.debug 'identique au père'
+ return false
+ }
+
+ if (cahier.parentIncorporation) {
+ log.debug 'a un parent de fusion'
+ return false
+ }
+
+ if (cahier.estFusionne) {
+ log.debug 'est déjà fusionné'
+ return false
+ }
+
+ if (cahier.estMasque) {
+ log.debug 'est masqué'
+ return false
+ }
+
+ if (cahier.getProprietaire().id != cahierParent.getProprietaire().id) {
+ log.debug 'Pas le même propriétaire'
+ return false
+ }
+
+ if (cahier.getType()==CahierDeTextesType.CAHIER_PRIVE_NON_VISE||
+ cahier.getType()==CahierDeTextesType.CAHIER_PRIVE_VISE){
+ log.debug "cahier privé non fusionnable"
+ return false
+ }
+
+ if (cahierParent?.service?.structureEnseignement?.type !=
+ StructureEnseignement.TYPE_CLASSE) {
+ log.debug "Le parent n'est pas un cdt de classe"
+ return false
+ }
+
+ return true
+ }
+
+ /**
+ * Vérifie que la securiteSession est propriétaire du cahier
+ * @param securiteSession la session de sécurité de l'utilisateur Eliot
+ * @param cahier le cahier accédé
+ * @param messageErreur le message d'erreur à transmettre dans l'exception
+ * le cas échéant
+ * @throws AutorisationException si la securiteSession n'est pas propriétaire
+ * du cahier
+ */
+ private void verifieSecuriteSessionEstProprietaire(SecuriteSession securiteSession,
+ CahierDeTextes cahier,
+ String messageErreur)
+ throws AutorisationException {
+
+ if (!estProprietaire(securiteSession, cahier)) {
+ throw new AutorisationException(messageErreur)
+ }
+ }
+
+ /**
+ * Indique si l'utilisateur associé à la session est propriétaire du cahier
+ * @param securiteSession
+ * @param cahier
+ * @return
+ */
+ private Boolean estProprietaire(SecuriteSession securiteSession,
+ CahierDeTextes cahier) {
+ AccessManager am = new AccessManager(cahier.item, securiteSession)
+
+ if (am.sessionEstProprietaireItem()) {
+ return true
+ }
+
+ return false
+
+ }
+
+}
+++ /dev/null
-/*
- * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
- * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
- *
- * Lilie is free software. You can redistribute it and/or modify since
- * you respect the terms of either (at least one of the both license) :
- * - under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- * - the CeCILL-C as published by CeCILL-C; either version 1 of the
- * License, or any later version
- *
- * There are special exceptions to the terms and conditions of the
- * licenses as they are applied to this software. View the full text of
- * the exception in file LICENSE.txt in the directory of this software
- * distribution.
- *
- * Lilie is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * Licenses for more details.
- *
- * You should have received a copy of the GNU General Public License
- * and the CeCILL-C along with Lilie. If not, see :
- * <http://www.gnu.org/licenses/> and
- * <http://www.cecill.info/licences.fr.html>.
- */
-
-package org.lilie.services.eliot.textes.droits
-
-import org.lilie.services.eliot.securite.AccessManager
-import org.lilie.services.eliot.textes.CahierDeTextes
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.textes.CahierDeTextesType
-
-/**
- * Permet de connaitre les droits associé à la session sur un cahier de texte
- */
-class ActionPossibleService {
-
- public Boolean peutModifier(SecuriteSession securiteSession, CahierDeTextes cdt) {
-
- AccessManager accessManager = getAccessManager(
- securiteSession,
- cdt)
-
- if (!accessManager.peutModifierLeContenu()) {
- return false
- }
-
- return true
- }
-
- public Boolean peutSupprimer(SecuriteSession securiteSession, CahierDeTextes cahier) {
-
- AccessManager accessManager = getAccessManager(
- securiteSession,
- cahier
- )
-
- if (cahier.getType() == CahierDeTextesType.CAHIER_DE_SERVICE ||
- cahier.getType() == CahierDeTextesType.CAHIER_PRIVE_VISE
- ) {
- return false
- } else {
- if (!accessManager.peutSupprimer()) {
- return false
- }
- }
-
- return true
- }
-
- public void verifierAccesConsultation(SecuriteSession securiteSession, CahierDeTextes cdt) {
- // Vérifier les droits de consultation
- AccessManager accessManager = new AccessManager(
- cdt.item,
- securiteSession
- )
-
- if (!accessManager.peutConsulterLeContenu()) {
- throw AutorisationException.consultationContenuException()
- }
-
- }
-
- public void verifierAccesModification(SecuriteSession securiteSession, CahierDeTextes cdt) {
- // Vérifier les droits de consultation
- AccessManager accessManager = new AccessManager(
- cdt.item,
- securiteSession
- )
-
- if (!accessManager.peutModifierLeContenu()) {
- throw AutorisationException.modificationContenuException()
- }
-
- }
-
- private AccessManager getAccessManager(SecuriteSession securiteSession, CahierDeTextes cdt) {
- return new AccessManager(
- cdt.item,
- securiteSession
- )
- }
-
-}
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.textes.etat.arbre.EtatArbreDossierCahierTextes
import org.lilie.services.eliot.textes.DossierRempli
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
import org.lilie.services.eliot.textes.arbre.dossier.MesCahiersDeClasse
import org.lilie.services.eliot.textes.arbre.dossier.CahiersDeClassePartage
import org.lilie.services.eliot.textes.arbre.activites.ActiviteArbreService
import org.lilie.services.eliot.demon.DemandeTraitementService
import org.lilie.services.eliot.demon.DemandeTraitementStatut
import org.lilie.services.eliot.demon.impl.DefaultTraitementType
-import org.lilie.services.eliot.textes.droits.ActionPossibleService
import org.lilie.services.eliot.textes.impression.requetage.CahierDeTextesImpressionService
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.AccessManager
-
+import org.lilie.services.eliot.textes.cahierdetextes.CahierDeTextesDroitsService
class TextesImpressionDiffereeService {
static transactional = false
DemandeTraitementService demandeTraitementService
- ActionPossibleService actionPossibleService
CahierDeTextesImpressionService cahierDeTextesImpressionService
- LocalPersonneService localPersonneService
-
+ CahierDeTextesDroitsService cahierDeTextesDroitsService
void traiteAllDemande() {
List<CahierDeTextes> cdts) {
cdts.each {CahierDeTextes cdt ->
- actionPossibleService.verifierAccesConsultation(securiteSession, cdt)
+ cahierDeTextesDroitsService.verifierAccesConsultation(securiteSession, cdt)
}
}
import org.lilie.services.eliot.textes.DroitsService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.textes.page.Page
-
import org.lilie.services.eliot.menu.MenuItemInfo
import org.lilie.services.eliot.fonctionnalites.TextesFonctionnalite
import org.lilie.services.eliot.textes.page.GroupePage
* @param securiteSession la session de sécurité Eliot de l'utilisateur
* @return
*/
- MenuInfo getMenuInfo(SecuriteSession securiteSession,
+ public MenuInfo getMenuInfo(SecuriteSession securiteSession,
Page pageCourante) {
Matiere matiere
Boolean estVise
Boolean avecCahiersArchives
+ Boolean estVide
}
Boolean estCahierArchive = false
String anneeDebut = null
String anneeFin = null
+ Boolean estVide = false
+ Boolean estCahierDeClasse = false
CahierDeTextesRechercheInfo(Long cdtId,
String cdtNom,
package org.lilie.services.eliot.textes.recherchecahierdetextes
-import org.lilie.services.eliot.textes.arbre.CahierDeTextesPersonnalise
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnalise
import org.lilie.services.eliot.textes.cahierdetextes.DossierInfo
import org.lilie.services.eliot.annuaire.GroupeInfo
import org.lilie.services.eliot.textes.arbre.DossierTypeEnum
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.textes.Visa
import org.lilie.services.eliot.textes.Activite
+import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnaliseService
+import org.lilie.services.eliot.annuaire.DistantGroupeSessionService
/**
* Recherche des cahiers de textes
static transactional = true
ArbreService arbreService
-
+ CahierDeTextesPersonnaliseService cahierDeTextesPersonnaliseService
+ DistantGroupeSessionService distantGroupeSessionService
/**
* Récupère l'ensemble de cahier de textes qui vérifient les critères de la recherche
Boolean estVise,
Boolean avecCahiersArchives,
DossierInfo dossierInfo,
- GroupeInfo infoGroupeDirection
+ Boolean estVide
) {
+ GroupeInfo infoGroupeDirection =
+ (GroupeInfo) distantGroupeSessionService.getGroupeInfoDeDirection(
+ etablissement
+ )
+
+
CahierDeTextesRechercheCriteres criteresRecherche = new CahierDeTextesRechercheCriteres(
- etablissement: etablissement,
- structure: structure,
- enseignant: enseignant,
- matiere: matiere,
- estVise: estVise,
- avecCahiersArchives: avecCahiersArchives
+ etablissement: etablissement,
+ structure: structure,
+ enseignant: enseignant,
+ matiere: matiere,
+ estVise: estVise,
+ estVide: estVide,
+ avecCahiersArchives: avecCahiersArchives
)
List<CahierDeTextesRechercheInfo> cdtResultats = rechercheCahiers(
- securiteSession,
- criteresRecherche,
- dossierInfo,
- infoGroupeDirection
+ securiteSession,
+ criteresRecherche,
+ dossierInfo,
+ infoGroupeDirection
)
List visaResultats = findDernierVisaInfoByCahiers(cdtResultats*.cdtId)
* @return
*/
private List<CahierDeTextesRechercheInfo> rechercheCahiers(SecuriteSession securiteSession,
- CahierDeTextesRechercheCriteres criteresRecherche,
- DossierInfo dossierInfo,
- GroupeInfo infoGroupeDirection) {
+ CahierDeTextesRechercheCriteres criteresRecherche,
+ DossierInfo dossierInfo,
+ GroupeInfo infoGroupeDirection) {
List<CahierDeTextesPersonnalise> cdtPersonalises
if (dossierInfo == null) {
// on ne filtre pas par dossier
cdtPersonalises =
- arbreService.getAllCahierDeTextesPersonnalise(
- securiteSession,
- false,
- criteresRecherche
+ cahierDeTextesPersonnaliseService.findAllCahierDeTextesVisibles(
+ securiteSession,
+ false,
+ criteresRecherche
)
+
} else {
// on filtre par dossier
cdtPersonalises =
arbreService.findAllCahierDeTextePersonnaliseForDossierId(
- securiteSession,
- dossierInfo.id.toString(),
- criteresRecherche
+ securiteSession,
+ dossierInfo.id.toString(),
+ criteresRecherche
)
}
// Filtre suivant fait la filtrage par Etablissement et Enseignant qui ont
// un traitement special qui ne peut pas etre fait dans la base
cdtPersonalises = filtreCahiersPersonalises(
- cdtPersonalises,
- criteresRecherche,
- dossierInfo,
- infoGroupeDirection
+ cdtPersonalises,
+ criteresRecherche,
+ dossierInfo,
+ infoGroupeDirection
)
return convertsCdtPersonalises(cdtPersonalises)
return cahierDeTextesPersonnalises.findAll {
CahierDeTextes cdt = it.cahierDeTextes
+ log.debug "Filtre cdt : "+cdt.toString()
+
+ if (!cdt.estVisible()) {
+ return false
+ }
+
if (cdt.estCahierPriveViseOuNonVise()) {
return cahierPriveCorrespond(it, criteres, infoGroupeDirection)
}
return cahierClasseCorrespond(it, criteres)
}
- log.warn("Cahier $cdt n'a pas un type connu. "+
- "Il ne sera pas dans les resultats de recherche.")
+ log.warn("Cahier $cdt n'a pas un type connu. " +
+ "Il ne sera pas dans les resultats de recherche.")
return false
}
}
// Mes cahiers prives, Cahiers prives partages
if (dossierInfo.typeDossier == DossierTypeEnum.MES_CAHIERS_PRIVES ||
- dossierInfo.typeDossier == DossierTypeEnum.CAHIERS_PRIVE_PARTAGE) {
+ dossierInfo.typeDossier == DossierTypeEnum.CAHIERS_PRIVE_PARTAGE) {
// si un matiere ou une structure est choisie, les cahiers prives ne remontent pas
if (criteres.matiere != null || criteres.structure != null) {
return []
// si un matiere, une structure ou un enseignant est choisi,
// les cahiers archives ne remontent pas
if (criteres.matiere != null ||
- criteres.structure != null ||
- criteres.enseignant != null) {
+ criteres.structure != null ||
+ criteres.enseignant != null) {
return []
}
return cahierClasseCorrespond(it, criteres)
}
- log.warn("Cahier $cdt n'a pas un type connu. "+
- "Il ne sera pas dans les resultats de recherche.")
+ log.warn("Cahier $cdt n'a pas un type connu. " +
+ "Il ne sera pas dans les resultats de recherche.")
return false
}
}
throw new IllegalStateException(
- "Recherche n'est pas implemente pour le type dossier ${dossierInfo.typeDossier}")
+ "Recherche n'est pas implemente pour le type dossier ${dossierInfo.typeDossier}")
}
/**
* @return
*/
private Boolean cahierPriveCorrespond(CahierDeTextesPersonnalise cdtPersonalise,
- CahierDeTextesRechercheCriteres criteres,
- GroupeInfo infoGroupeDirection) {
+ CahierDeTextesRechercheCriteres criteres,
+ GroupeInfo infoGroupeDirection) {
if (criteres.matiere != null || criteres.structure != null) {
return false
}
return (criteres.etablissement ?
estEtabPareil(cdtPersonalise, criteres.etablissement, infoGroupeDirection) : true) &&
- (criteres.enseignant ? cdtPersonalise.proprietaire == criteres.enseignant : true)
+ (criteres.enseignant ? cdtPersonalise.proprietaire == criteres.enseignant : true)
}
/**
* @return
*/
private Boolean cahierArchiveCorrespond(CahierDeTextesPersonnalise cdtPersonalise,
- CahierDeTextesRechercheCriteres criteres,
- GroupeInfo infoGroupeDirection) {
+ CahierDeTextesRechercheCriteres criteres,
+ GroupeInfo infoGroupeDirection) {
if (criteres.matiere != null || criteres.structure != null || criteres.enseignant != null) {
return false
}
- return criteres.etablissement ?
+ return criteres.etablissement ?
estEtabPareil(cdtPersonalise, criteres.etablissement, infoGroupeDirection) :
true
}
* @return
*/
private Boolean cahierClasseCorrespond(CahierDeTextesPersonnalise cdtPersonalise,
- CahierDeTextesRechercheCriteres criteres) {
+ CahierDeTextesRechercheCriteres criteres) {
CahierDeTextes cdt = cdtPersonalise.cahierDeTextes
Service service = cdt.service
return (criteres.etablissement ? service.structureEnseignement.etablissement == criteres.etablissement : true) &&
- (criteres.enseignant ?
- service.enseignements.find { it.enseignant.id == criteres.enseignant.autorite.id } != null : true)
+ (criteres.enseignant ?
+ service.enseignements.find { it.enseignant.id == criteres.enseignant.autorite.id } != null : true)
}
/**
return (cahierDeTextesPersonnalise.allAutorisation.find {
it.autorite().idExterne == infoGroupeDirection.groupeId.toString() &&
- it.autorite().type == Autorite.TYPE_GROUPE
+ it.autorite().type == Autorite.TYPE_GROUPE
} != null)
}
Personne proprioCdt = cdt.proprietairePersonne
CahierDeTextesRechercheInfo cdtInfo = new CahierDeTextesRechercheInfo(
- cdt.id,
- cdt.nom,
- service?.structureEnseignement?.code,
- service?.matiere?.libelleLong,
- proprioCdt?.nom,
- proprioCdt?.prenom,
- it.aliasNom
+ cdt.id,
+ cdt.nom,
+ service?.structureEnseignement?.code,
+ service?.matiere?.libelleLong,
+ proprioCdt?.nom,
+ proprioCdt?.prenom,
+ it.aliasNom
)
+ cdtInfo.estVide = cdt.estVide()
+ cdtInfo.estCahierDeClasse = cdt.estCahierDeService()
+
if (cdt.estCahierArchive()) {
cdtInfo.estCahierArchive = true
cdtInfo.anneeDebut = cdt.anneeScolaire.extraitAnneeDebut()
}
-
/**
* Récupère des informations sur le dernier visa de cahier de textes
* @param idsCdt : liste des identifiants de cahier de textes
* <http://www.cecill.info/licences.fr.html>.
*/
-package org.lilie.services.eliot.textes.arbre
+
+
+package org.lilie.services.eliot.textes.requetage
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.Dossier
import org.lilie.services.eliot.securite.Autorite
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.textes.CahierDeTextesType
+import org.lilie.services.eliot.textes.arbre.CahierDeTextesArbreService
/**
* Cahier de textes tel qu'il est vu par 1 utilisateur
public String toString() {
- return (cahierDeTextes?.nom) + (proprietaire!=null ? (" @ " + proprietaire.prenom + " " + proprietaire.nom) : '')
+ return (cahierDeTextes?.nom) +
+ (proprietaire != null ? (" @ " + proprietaire.prenom + " " + proprietaire.nom) : '') +
+ " " +
+ (cahierDeTextes?.parentIncorporation) +
+ ", " +
+ cahierDeTextes?.estFusionne +
+ ", " +
+ cahierDeTextes?.estMasque+
+ ", " +
+ cahierDeTextes?.estVide()
}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes.requetage
+
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.securite.impl.Autorisation
+import org.lilie.services.eliot.textes.Dossier
+import org.lilie.services.eliot.securite.Permission
+import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheCriteres
+import org.lilie.services.eliot.textes.RelCahierActeur
+import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.ItemService
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+
+/**
+ * Manipule des cahiers de textes personnalisé. Permet de contextualiser des cahiers de textes par rapport
+ * à un utilisateur d'une session
+ * @author othe
+ */
+class CahierDeTextesPersonnaliseService {
+
+ AnneeScolaireService anneeScolaireService
+
+ /**
+ * Recherche la liste des cahiers de textes personnalisés correspondant à la session
+ * @param securiteSession
+ * @param seulementModifiable
+ * @param criteres
+ * @return
+ */
+ public List<CahierDeTextesPersonnalise> getAllCahierDeTextesPersonnalise(SecuriteSession securiteSession,
+ boolean seulementModifiable,
+ CahierDeTextesRechercheCriteres criteres = null) {
+
+ def allCahierDeTextesPersonnaliseData = CahierDeTextes.executeQuery(
+ getHqlAllCahier(criteres),
+ getHqlAllCahierParams(securiteSession, criteres)
+ ).collect {
+ [
+ cahierDeTextes: it[0],
+ autorisation: it[1],
+ dossier: it[2],
+ nomAlias: ''
+ ]
+ }
+
+ if (!allCahierDeTextesPersonnaliseData) {
+ return []
+ }
+
+ allCahierDeTextesPersonnaliseData = filtreCahierDeTextesVide(criteres, allCahierDeTextesPersonnaliseData)
+
+ if (!allCahierDeTextesPersonnaliseData) {
+ return []
+ }
+
+
+ def allCahierNomAlias = [:]
+ List<RelCahierActeur> allRelCahierActeur =
+ RelCahierActeur.executeQuery("""
+ from RelCahierActeur rel
+ where rel.acteur = :autorite
+ AND rel.cahierDeTextes in (:allCahierDeTextes)
+""",
+ [
+ autorite: securiteSession.defaultAutorite,
+ allCahierDeTextes: allCahierDeTextesPersonnaliseData*.cahierDeTextes
+ ]
+ )
+
+ allRelCahierActeur.each {
+ RelCahierActeur relCahierActeur ->
+ allCahierNomAlias[relCahierActeur.cahierDeTextes] = relCahierActeur.aliasNom
+ }
+
+ List<CahierDeTextesPersonnalise> cahiersPersonalises = extractAllCahierDeTextesPersonnalise(
+ allCahierDeTextesPersonnaliseData,
+ allCahierNomAlias,
+ seulementModifiable
+ )
+
+ ajouteInfoProprietaires(cahiersPersonalises)
+ ajouteInfoPartage(securiteSession, cahiersPersonalises)
+
+ return cahiersPersonalises
+ }
+
+ /**
+ * filtre la liste par rapport au critère cahier de textes vide ou pas vide
+ * @param criteres
+ * @param allCahierDeTextesPersonnaliseData
+ * @return
+ */
+ private List<CahierDeTextesPersonnalise> filtreCahierDeTextesVide(CahierDeTextesRechercheCriteres criteres,
+ List<CahierDeTextesPersonnalise> allCahierDeTextesPersonnaliseData) {
+
+ log.debug "Recherche cahiers de textes vide, criteres.estVide=${criteres?.estVide}"
+
+ if (criteres?.estVide != null) {
+
+ def allCahierPersonnaliseVide = []
+
+ if (criteres.estVide) {
+
+ log.debug "Recherche cahiers de textes vide."
+
+ allCahierDeTextesPersonnaliseData.each {
+
+ if (it.cahierDeTextes.estVide()) {
+ allCahierPersonnaliseVide << it
+ }
+
+ }
+
+ } else {
+
+ log.debug "Recherche cahiers de textes non vide."
+
+ allCahierDeTextesPersonnaliseData.each {
+
+ if (!(it.cahierDeTextes.estVide())) {
+ allCahierPersonnaliseVide << it
+ }
+
+ }
+
+ }
+
+ allCahierDeTextesPersonnaliseData = allCahierPersonnaliseVide
+
+ }
+ allCahierDeTextesPersonnaliseData
+ }
+
+ /**
+ * Recherche la liste des cahiers de textes personnalisés visibles (non masqué) correspondant à la session
+ * @param securiteSession
+ * @param seulementModifiable
+ * @param criteres
+ * @return
+ */
+ public List<CahierDeTextesPersonnalise> findAllCahierDeTextesVisibles(SecuriteSession securiteSession,
+ boolean seulementModifiable,
+ CahierDeTextesRechercheCriteres criteres = null) {
+
+ List<CahierDeTextesPersonnalise> allCahierDeTextes = getAllCahierDeTextesPersonnalise(
+ securiteSession,
+ seulementModifiable,
+ criteres)
+
+ return filtreAllCahierDeTextesVisibles(allCahierDeTextes)
+ }
+
+ /**
+ * Recherche la liste des cahiers de textes personnalisés masqués correspondant à la session
+ * @param securiteSession
+ * @param seulementModifiable
+ * @param criteres
+ * @return
+ */
+ public List<CahierDeTextesPersonnalise> findAllCahierDeTextesMasque(SecuriteSession securiteSession,
+ boolean seulementModifiable,
+ CahierDeTextesRechercheCriteres criteres = null) {
+
+ List<CahierDeTextesPersonnalise> allCahierDeTextes = getAllCahierDeTextesPersonnalise(
+ securiteSession,
+ seulementModifiable,
+ criteres)
+
+ return filtreAllCahierDeTextesMasques(securiteSession, allCahierDeTextes)
+ }
+
+ /**
+ * Permet de récupérer la liste des cdt visibles
+ * @param allCahierDeTextes
+ * @return
+ */
+ private List<CahierDeTextesPersonnalise> filtreAllCahierDeTextesVisibles(List<CahierDeTextesPersonnalise> allCahierDeTextes) {
+
+ List<CahierDeTextesPersonnalise> resultat = []
+
+ allCahierDeTextes.each { CahierDeTextesPersonnalise cahierDeTextesPersonnalise ->
+
+ if (cahierDeTextesPersonnalise.cahierDeTextes.estVisible()) {
+ log.debug cahierDeTextesPersonnalise.toString() + " : ## cahier visible"
+ resultat << cahierDeTextesPersonnalise
+ } else {
+ log.debug cahierDeTextesPersonnalise.toString() + " : ** cahier non visible"
+ }
+
+ }
+
+ return resultat
+ }
+
+ /**
+ * Permet de récupérer la liste des cdt masqués
+ * @param allCahierDeTextes
+ * @return
+ */
+ private List<CahierDeTextesPersonnalise> filtreAllCahierDeTextesMasques(SecuriteSession securiteSession,
+ List<CahierDeTextesPersonnalise> allCahierDeTextes) {
+
+ List<CahierDeTextesPersonnalise> resultat = []
+
+ allCahierDeTextes.each { CahierDeTextesPersonnalise cahierDeTextesPersonnalise ->
+
+ if (cahierDeTextesPersonnalise.cahierDeTextes.estVisible()) {
+ log.debug cahierDeTextesPersonnalise.toString() + " : ** cahier non masqué"
+ } else {
+ log.debug cahierDeTextesPersonnalise.toString() + " : ## cahier masqué"
+ resultat << cahierDeTextesPersonnalise
+ }
+
+ }
+
+ return resultat
+ }
+
+
+ private List<CahierDeTextesPersonnalise> extractAllCahierDeTextesPersonnalise(def allCahierDeTextesPersonnaliseData,
+ def allCahierNomAlias,
+ boolean seulementModifiable) {
+
+
+ Map<CahierDeTextes, CahierDeTextesPersonnalise> allCahierDeTextesPersonnalise = [:]
+ allCahierDeTextesPersonnaliseData.each { def cahierDeTextesPersonnaliseData ->
+
+ CahierDeTextes cahierDeTextes =
+ cahierDeTextesPersonnaliseData.cahierDeTextes
+
+ cahierDeTextesPersonnaliseData.aliasNom = allCahierNomAlias[cahierDeTextes]
+
+ CahierDeTextesPersonnalise cahierDeTextesPersonnalise =
+ allCahierDeTextesPersonnalise[cahierDeTextes]
+
+ Autorisation autorisation = cahierDeTextesPersonnaliseData.autorisation
+ Dossier dossier = cahierDeTextesPersonnaliseData.dossier
+
+ if (seulementModifiable) {
+
+ boolean peutModifier =
+ (autorisation.valeurPermissions & Permission.PEUT_MODIFIER_CONTENU) == Permission.PEUT_MODIFIER_CONTENU
+
+ if (!autorisation.proprietaire && !peutModifier) {
+ return
+ }
+ }
+
+ if (cahierDeTextesPersonnalise) {
+ cahierDeTextesPersonnalise.allAutorisation << autorisation
+
+ if (dossier && !cahierDeTextesPersonnalise.dossier) {
+ cahierDeTextesPersonnalise.dossier = dossier
+ }
+
+ }
+ else {
+ allCahierDeTextesPersonnalise.put(
+ cahierDeTextes,
+ new CahierDeTextesPersonnalise(
+ cahierDeTextes: cahierDeTextes,
+ allAutorisation: [autorisation],
+ dossier: dossier,
+ aliasNom: cahierDeTextesPersonnaliseData.aliasNom
+ )
+ )
+ }
+ }
+
+ return allCahierDeTextesPersonnalise.values() as List
+ }
+
+ /**
+ * Renseigne les proprietaires de cahiers.
+ * PI: Cahiers archives ont ENT comme le proprietaire, qui n'est pas une personne.
+ * Du coup leur proprietaire n'est pas renseigne.
+ * @param cdtPersonalises
+ */
+ private void ajouteInfoProprietaires(List<CahierDeTextesPersonnalise> cdtPersonalises) {
+ List<Item> items = cdtPersonalises*.cahierDeTextes*.item
+
+ if (items.isEmpty()) {
+ return
+ }
+
+ def itemInfos = Item.executeQuery("""
+ select
+ item, pers
+ from
+ Item item
+ left join item.autorisations aut,
+ Personne pers
+ where
+ aut.proprietaire = true and
+ pers.autorite = aut.autorite and
+ item in (:items)
+ """,
+ [items: items]
+ )
+
+ Map<Long, Personne> itemMap = [:]
+ itemInfos.each {
+ Long itemId = it[0].id
+ Personne personne = it[1]
+ itemMap.put(itemId, personne)
+ }
+
+ cdtPersonalises.each { CahierDeTextesPersonnalise cdtPerso ->
+ cdtPerso.proprietaire = itemMap.get(cdtPerso.cahierDeTextes.item.id)
+ }
+
+ }
+
+ private void ajouteInfoPartage(SecuriteSession securiteSession,
+ List<CahierDeTextesPersonnalise> allCahierPersonalise) {
+ List<Item> items = allCahierPersonalise*.cahierDeTextes*.item
+
+ if (items.isEmpty()) {
+ return
+ }
+
+ def allItemIdPartage = Item.executeQuery("""
+ select
+ item.id
+ from
+ Item item
+ inner join item.autorisations aut
+ where
+ aut.autorite <> :defaultAutorite and item in (:items)
+ """,
+ [
+ items: items,
+ defaultAutorite: securiteSession.defaultAutorite
+ ]
+ )
+
+ allCahierPersonalise.each { CahierDeTextesPersonnalise cdtPerso ->
+ if (cdtPerso.cahierDeTextes.item.id in allItemIdPartage) {
+ cdtPerso.partage = true
+ }
+ }
+ }
+
+ /**
+ * Requete pour recuperer les cahiers de textes personalises
+ * @param champsPrechargements champs a pre-charger
+ * @param avecCahiersArchives
+ * @return
+ */
+ private String getHqlAllCahier(CahierDeTextesRechercheCriteres criteres) {
+ String hql = """
+ select cdt, aut, dossier
+ from RelDossierAutorisationCahier rel
+ left join rel.dossier as dossier with dossier.proprietaire.id = :defaultAutoriteId
+ right join rel.autorisation as aut,
+ CahierDeTextes cdt
+ left join fetch cdt.service as s
+ left join fetch s.structureEnseignement as se
+ left join fetch se.etablissement
+ left join fetch cdt.anneeScolaire as annee
+ where aut.autorite in (:allAutorite) and
+ aut.item.type = :typeCdt and
+ cdt.item = aut.item and
+ cdt.parentIncorporation is null
+ """
+ if (criteres) {
+ if (!criteres.avecCahiersArchives) {
+ hql += " and (annee is null OR annee = :anneeScolaire)"
+ }
+ if (criteres.matiere) {
+ hql += " and s.matiere = :matiere"
+ }
+ if (criteres.structure) {
+ hql += " and se = :structureEnseignement"
+ }
+ if (criteres.estVise != null) {
+ hql += " and cdt.estVise = :estVise"
+ }
+ }
+
+ return hql
+ }
+
+ /**
+ * Prepare les parametres pour la requete HQL de la recherche des cahiers
+ * @param securiteSession
+ * @param criteres
+ * @return
+ */
+ private Map getHqlAllCahierParams(SecuriteSession securiteSession,
+ CahierDeTextesRechercheCriteres criteres) {
+ Map hqlParams = [
+ defaultAutoriteId: securiteSession.defaultAutorite.id,
+ allAutorite: securiteSession.autorites,
+ typeCdt: ItemService.ITEM_TYPE_CDT
+ ]
+ if (criteres) {
+
+ if (!criteres.avecCahiersArchives) {
+ hqlParams.anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
+ }
+ if (criteres.matiere) {
+ hqlParams.matiere = criteres.matiere
+ }
+ if (criteres.structure) {
+ hqlParams.structureEnseignement = criteres.structure
+ }
+ if (criteres.estVise != null) {
+ hqlParams.estVise = criteres.estVise
+ }
+ }
+ return hqlParams
+ }
+
+
+}
CahierDeTextes cahierDeTextes,
boolean visibleSeulement = true) {
- log.info "Demande information pour : " + cahierDeTextes.nom + " " +
+ log.debug "Demande information pour : " + cahierDeTextes.nom + " " +
cahierDeTextes.id
ChapitreActiviteParCahier chapitreActiviteParCahier =
forced_root_block : 'p'
});
- var init = true; // initialise l'editeur tinymce
+ var init = true; // initialise l'editeur tinymce
<g:if test='${isCahierDeService}'>
init = false;
</g:if>
</script>
<script type="text/javascript">
-
+ var arrayCdtAIncorporer;
+ var arrayCdtADetacher;
$(document).ready(function() {
+ arrayCdtAIncorporer = [];
+ arrayCdtADetacher = [];
$('#divProgression2').hide();
+ $('#cahiersFusionnables').hide();
});
function supprimerFichierProgress(valeur) {
$('#divProgression2').show();
$('#divNomFichier').hide();
}
+
+ function afficherCahiersFusionnables() {
+ $('#cahiersFusionnables').show();
+ }
+
+ function fusionnerCahier() {
+
+ idCahier = parseInt($("#cahiersFusionnables option:selected").val());
+ idCahierInt = parseInt(idCahier);
+ nomCahier = $("#cahiersFusionnables option:selected").text();
+
+ if (idCahier != ""){
+ $('#cahiersFusionnables').hide();
+
+ // ajouter le cahier dans la grille
+ $('#tableCahiersFusionnes').show();
+ $('#tableCahiersFusionnes').append(
+ '<div class="rowCahiersFusionnes" id="' + idCahier + '">' +
+ '<div class="cellCahierFusionne">' +
+ nomCahier +
+ '</div>' +
+ '<div class="cellBouton">' +
+ '<a href="#" onclick="detacherCahier(' + idCahier + ');">' +
+ '<img src="${resource(dir: 'images', file: 'delete.gif')}" title="Détacher le cahier"/>' +
+ '</a>' +
+ '</div>' +
+ '</div>');
+
+ // le supprimer des cdtsADetacher s'il y est
+ if ($.inArray(idCahierInt, arrayCdtADetacher) != -1){
+ arrayCdtADetacher.remove(idCahierInt);
+ $('#cdtsADetacher').val(arrayCdtADetacher);
+ }
+
+ // l'ajouter aux cdtsAIncorporer s'il n'était pas déjà incorporé au départ
+ var initialCdtsIncorpores = JSON.parse($('#initialCdtsIncorpores').val());
+ if ($.inArray(idCahier, initialCdtsIncorpores) == -1){
+ arrayCdtAIncorporer.push(idCahierInt);
+ $('#cdtsAIncorporer').val(arrayCdtAIncorporer);
+ }
+
+ // le rendre non fusionnable
+ $("#cahiersFusionnables option:selected").hide();
+ $("#cahiersFusionnables").val('');
+ }
+ }
+
+ function detacherCahier(idCahier, nomAffichage){
+
+ idCahierInt = parseInt(idCahier);
+
+ // supprimer le cahier de la grille
+ $('#'+idCahier+'').remove();
+
+ // le supprimer des cdtsAIncorporer s'il y est
+ if ($.inArray(idCahierInt, arrayCdtAIncorporer) != -1){
+ arrayCdtAIncorporer.remove(idCahierInt);
+ $('#cdtsAIncorporer').val(arrayCdtAIncorporer);
+ }
+
+ // l'ajouter aux cdtsADetacher s'il était incorporé au départ
+ var initialCdtsIncorpores = JSON.parse($('#initialCdtsIncorpores').val());
+ if ($.inArray(idCahier, initialCdtsIncorpores) != -1){
+ arrayCdtADetacher.push(idCahierInt);
+ $('#cdtsADetacher').val(arrayCdtADetacher);
+ }
+
+ // le rendre fusionnable
+ var cahierDetache = $('#cahiersFusionnables option[value="'+idCahier+'"]');
+ var options = $('#cahiersFusionnables').attr('options');
+ var isCahierExisteDansSelect = false;
+ for (var i = 0; i < options.length; ++i){
+ if (options[i].value == idCahier){
+ isCahierExisteDansSelect = true;
+ }
+ };
+ if (isCahierExisteDansSelect) {
+ cahierDetache.show();
+ } else {
+ options[options.length] = new Option(nomAffichage, idCahier, true, true);
+ }
+ $("#cahiersFusionnables").val('');
+
+ $('#lienAjouter').removeClass('desactive');
+ }
</script>
<div class="portal-form_line clear">
<span class="red">*</span> <em>indique une information obligatoire</em>
- </div>
+</div>
<g:if test="${modeEdition}">
<div class="portal-form_line">
- <g:if test="${isCahierDeService}">
- <label for="nom">Nom :</label>
- <span id="nom">${cdtCmd.nom}</span>
- </g:if>
- <g:else>
+ %{--<g:if test="${isCahierDeService}">--}%
+ %{--<label for="nom">Nom :</label>--}%
+ %{--<span id="nom">${cdtCmd.nom}</span>--}%
+ %{--</g:if>--}%
+ %{--<g:else>--}%
<label for="nom">Nom <span class="red">*</span> :</label>
<g:textField name="nom" value="${cdtCmd.nom.decodeHTML()}" size="40" id="nom" maxlength="255"/>
- </g:else>
+ %{--</g:else>--}%
</div>
<div class="portal-form_line marge-droite-reduite">
<div class="portal-form_line">
+
<g:if test="${isCahierDeService && isCahierDeClasse && cahiersFilsIncorporationInfo?.size > 0}">
+
<label for="incorporation">Rattachement de cahiers de textes :</label>
<g:hiddenField name="initialCdtsIncorpores" value="${initialCdtsIncorpores}"/>
- <ul>
+ <g:hiddenField name="cahiersFilsIncorporationInfo" value="${cahiersFilsIncorporationInfo}"/>
+ <g:hiddenField name="cdtsAIncorporer" value=""/>
+ <g:hiddenField name="cdtsADetacher" value=""/>
+
+ <div id="contenuRattachement">
+
+ %{--grille de cahiers incorporés/fusionnés--}%
+ <g:set var="hasCahiersIncorpores" value="false"/>
+ <g:set var="activation" value="desactive"/>
+
<g:each var="cahierFilsIncorporationInfo" in="${cahiersFilsIncorporationInfo}">
- %{--Non Incorporable : grisé + désactivé--}%
- <g:if test="${!cahierFilsIncorporationInfo.estVide}">
- <li>
- <div class="cdtNonIncorporable">
- <input
- type="checkbox"
- name="cdtFils"
- value="${cahierFilsIncorporationInfo.id}"
- disabled/>
- <span id="${cahierFilsIncorporationInfo.id}" title="${message(
- code: 'cdt.non.incorporable.toolTips',
- args: [cdtCmd.nom])}">${cahierFilsIncorporationInfo.nomAffichage} (cahier non vide, rattachement impossible)</span>
- </div>
- </li>
+ <g:if test="${cahierFilsIncorporationInfo.estIncorpore}">
+ <g:set var="hasCahiersIncorpores" value="true"/>
</g:if>
- %{--Incorporable : coché / non coché--}%
<g:else>
- %{--incorporé : coché--}%
+ <g:set var="activation" value=""/>
+ </g:else>
+ </g:each>
+
+ <div id="tableCahiersFusionnes">
+ <div id="rowTitreCahiersFusionnes">Cahier de textes</div>
+ <g:each var="cahierFilsIncorporationInfo" in="${cahiersFilsIncorporationInfo}">
<g:if test="${cahierFilsIncorporationInfo.estIncorpore}">
- <li>
- <div class="cdtIncorporable">
- <input
- type="checkbox"
- name="cdtFilsIncorpores"
- value="${cahierFilsIncorporationInfo.id}"
- checked
- style ="cursor: pointer;"/>
- <span id="${cahierFilsIncorporationInfo.id}">${cahierFilsIncorporationInfo.nomAffichage}</span>
+ <div class="rowCahiersFusionnes" id="${cahierFilsIncorporationInfo.id}">
+ <div class="cellCahierFusionne">
+ ${cahierFilsIncorporationInfo.nomAffichage}
</div>
- </li>
- </g:if>
- %{--non incorporé : pas coché--}%
- <g:else>
- <li>
- <div class="cdtIncorporable">
- <input
- type="checkbox"
- name="cdtFilsIncorpores"
- value="${cahierFilsIncorporationInfo.id}"
- style ="cursor: pointer;"/>
- <span id="${cahierFilsIncorporationInfo.id}">${cahierFilsIncorporationInfo.nomAffichage}</span>
+ <div class="cellBouton">
+ <a href="#" onclick="detacherCahier(${cahierFilsIncorporationInfo.id}, '${cahierFilsIncorporationInfo.nomAffichage}');">
+ <img src="${resource(dir: 'images', file: 'delete.gif')}" title="Détacher le cahier"/>
+ </a>
</div>
- </li>
- </g:else>
- </g:else>
- </g:each>
- </ul>
+ </div>
+ </g:if>
+ </g:each>
+ </div>
+
+ <g:if test="${hasCahiersIncorpores == 'true'}">
+ <script>
+ $('#tableCahiersFusionnes').show();
+ </script>
+ </g:if>
+ <g:else>
+ <script>
+ $('#tableCahiersFusionnes').hide();
+ </script>
+ </g:else>
+
+ <a href="#" onclick="afficherCahiersFusionnables();" class="lienAjouter ${activation}" id="lienAjouter">
+ <img src="${resource(dir: 'images', file: 'add16x16.gif')}"/>
+ Ajouter un cahier de textes
+ </a>
+
+ <g:select id="cahiersFusionnables"
+ from="${cahiersFilsIncorporationInfo.findAll{!it.estIncorpore}}"
+ optionKey="id"
+ optionValue="nomAffichage"
+ noSelection="['':'- Cahier de textes -']"
+ onChange="fusionnerCahier()"/>
+
+ </div>
+
</g:if>
</div>
<eliotjs:varJson name="etatArbreActivite" value="${etatArbreActivite}"/>
<eliotjs:varBoolean name="isAcceesRestreint" value="${isAcceesRestreint}"/>
+ <eliotjs:varBoolean name="contientCdtMasque" value="${contientCdtMasque}"/>
+ <eliotjs:varBoolean name="isDirectionOuADML" value="${isDirectionOuADML}"/>
+
+ <eliotjs:ns name="libelle">
+ <eliotjs:varI18n name="popupAfficherCahiersMasques" code="eliot.textes.libelle.popupAfficherCahiersMasques" encoded="true" />
+ </eliotjs:ns>
+
+ <eliotjs:ns name="url">
+ <eliotjs:varLink name="getCahiersMasques" controller="cahierDeTextesMasque" action="liste"/>
+ <eliotjs:varLink name="afficherCahiersMasques" controller="cahierDeTextesMasque" action="montre"/>
+ </eliotjs:ns>
+
+ <eliotjs:ns name="button">
+ <eliotjs:varI18n name="boutonAfficher" code="eliot.textes.button.boutonAfficher" encoded="true" />
+ <eliotjs:varI18n name="boutonAnnuler" code="eliot.textes.button.boutonAnnuler" encoded="true" />
+ </eliotjs:ns>
<eliotjs:ns name="message">
<eliotjs:varI18n name="suppressionEnCours" code="textes.loading.suppression" encoded="true"/>
eliot.textes.recherche.Modele.url.getDatasScolarite = '${createLink(action: 'chargeListes', controller: 'cahierDeTextes')}';
eliot.textes.recherche.Modele.url.rechercher = '${createLink(action: 'rechercher', controller: 'cahierDeTextes')}';
eliot.textes.recherche.Modele.url.impressionIndex = '${createLink(action: 'index', controller: 'suiviImpression')}';
+eliot.textes.recherche.Modele.url.masquer = '${createLink(action: 'masque', controller: 'cahierDeTextesMasque')}';
eliot.textes.Constantes.urlActiviteLister = '${createLink(action: 'lister', controller: 'listerActivite')}';
eliot.textes.Constantes.urlCahierDeTextesProprietes = '${createLink(action: 'proprietes', controller: 'cahierDeTextes')}';
eliot.textes.recherche.Modele.libelle.tous = '${g.message(code: 'eliot.textes.recherche.libelle.tous')}';
eliot.textes.recherche.Modele.libelle.non = '${g.message(code: 'eliot.textes.recherche.libelle.non')}' ;
eliot.textes.recherche.Modele.libelle.oui = '${g.message(code: 'eliot.textes.recherche.libelle.oui')}';
+eliot.textes.recherche.Modele.libelle.vide = '${g.message(code: 'eliot.textes.recherche.libelle.vide')}';
eliot.textes.recherche.Modele.message.rechercheEnCours = '${g.message(code: 'eliot.textes.recherche.message.rechercheEnCours')}';
+eliot.textes.recherche.Modele.message.popupMasquageInfo = '${g.message(code: 'eliot.textes.recherche.message.popupMasquageInfo')}';
eliot.textes.recherche.Modele.message.ajoutDemandeImpressionSucces = "<g:message code='eliot.textes.impression.ajout.succes'/>";
eliot.textes.recherche.Modele.message.ajoutDemandeImpressionErreur = "<g:message code='eliot.textes.impression.ajout.erreur'/>";
+eliot.textes.recherche.Modele.message.erreurInconnue = "<g:message code='eliot.textes.masque.message.erreur'/>";
eliot.textes.recherche.Modele.data.dataScolarite = ${dataScolarite}
eliot.textes.recherche.Modele.libelle.visaCahierTextes = "<g:message code='eliot.textes.libelle.visa.visaCahierTextes'/>";
eliot.textes.recherche.Modele.libelle.viser = "<g:message code='eliot.textes.libelle.visa.viser'/>";
eliot.textes.recherche.Modele.libelle.viserPlusieursCahiers = "<g:message code='eliot.textes.libelle.visa.viserPlusieursCahiers'/>";
+eliot.textes.recherche.Modele.libelle.masquerCahiers = "<g:message code='eliot.textes.recherche.libelle.masquerCahiers'/>";
eliot.textes.recherche.Modele.libelle.contenu = "<g:message code='eliot.textes.libelle.visa.contenu'/>";
eliot.textes.recherche.Modele.icon.recherche = '${resource(dir: 'images', file: 'properties.gif')}';
+eliot.textes.recherche.Modele.button.boutonMasquer = '${g.message(code: 'eliot.textes.recherche.button.boutonMasquer')}';
+eliot.textes.recherche.Modele.button.boutonAnnuler = '${g.message(code: 'eliot.textes.button.boutonAnnuler')}';
+
eliot.textes.Modele.etatArbreCdtDossier = ${etatArbreCdtDossier};
eliot.textes.Modele.etatArbreCdtEdt = ${etatArbreCdtEdt};
eliot.textes.Modele.etatArbreActivite = ${etatArbreActivite};
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes
+
+import org.lilie.services.eliot.textes.cahierdetextes.CahierDeTextesMarshallerService
+import org.lilie.services.eliot.test.InitDonneesCommunesTestTextesService
+import org.lilie.services.eliot.test.PopulationTestActeur
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.textes.visa.VisaService
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.textes.cahierdetextes.CahierFusionService
+import org.lilie.services.eliot.textes.cahierdetextes.CahierFusionInfo
+import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheInfo
+import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
+import org.lilie.services.eliot.temps.Evenement
+
+class CahierDeTextesMarshallerServiceTests extends GroovyTestCase {
+
+ CahierDeTextesMarshallerService cahierDeTextesMarshallerService
+ VisaService visaService
+ CahierFusionService cahierFusionService
+
+ InitDonneesCommunesTestTextesService initDonneesCommunesTestTextesService
+
+ SecuriteSession securiteSessionDirecteur
+ SecuriteSession securiteSession
+ Activite activite
+ CahierDeTextes cahierDeTextes
+ CahierDeTextes cahierAFusionner
+ Autorite autorite
+
+
+ protected void setUp() {
+ init()
+ super.setUp()
+
+ }
+
+ protected void tearDown() {
+ super.tearDown()
+ }
+
+ void init(){
+
+ securiteSessionDirecteur = (SecuriteSession)initDonneesCommunesTestTextesService.
+ getActeur(PopulationTestActeur.DIRECTION_1).securiteSession
+
+ securiteSession = (SecuriteSession)initDonneesCommunesTestTextesService.
+ getActeur(PopulationTestActeur.ENSEIGNANT_1).securiteSession
+ autorite =
+ initDonneesCommunesTestTextesService.getAutorite(PopulationTestActeur.ENSEIGNANT_1)
+ /* Crée le cahier de français pour la 2nde2 et lui rattache une activité */
+ activite =
+ initDonneesCommunesTestTextesService.getActiviteClasseCdtFrancais2NDE2()
+ cahierDeTextes = activite.cahierDeTextes
+
+ cahierAFusionner =
+ initDonneesCommunesTestTextesService.getCahierDeTextesServiceMath2NDE2()
+
+ }
+
+ void testMarshallApercu(){
+
+ Map result =
+ cahierDeTextesMarshallerService.marshallApercu(securiteSession, cahierDeTextes)
+
+ assertTrue("La personne loguée est le propriétaire du cahier de textes", result.estProprietaire)
+
+ assertNotNull("Le cahier de textes devrait avoir un propriétaire correspondant à un objet de type Personne",
+ result.professeur)
+
+ assertEquals("Le cahier de textes contient une activité", 1, result.chapitresEtActivites.size())
+ assertEquals("Le cahier de textes contient une activité dont le titre est 'activite'",
+ 'activite',
+ result.chapitresEtActivites[0].element.titre)
+ assertEquals("Le cahier de textes contient une activité dont la description est 'description activite classe'",
+ 'description activite classe',
+ result.chapitresEtActivites[0].element.description)
+
+ assertNotNull("La map retournée devrait contenir un objet de type CahierDeTextesInfo",
+ result.cdtInfo)
+ assertEquals(cahierDeTextes.nomAffichage((Autorite) securiteSession.defaultAutorite),
+ result.cdtInfo.nomAffichage)
+ assertEquals(cahierDeTextes.description?.encodeAsHTML(),
+ result.cdtInfo.description)
+ assertEquals(cahierDeTextes.estCahierPriveViseOuNonVise(),
+ result.cdtInfo.estPrive)
+ assertEquals(cahierDeTextes.service?.structureEnseignement?.code,
+ result.cdtInfo.structureEnseignementCode)
+ assertEquals(cahierDeTextes.service?.matiere?.libelleLong?.encodeAsHTML(),
+ result.cdtInfo.matiereLibelle)
+
+ }
+
+ void testMarshallVisa(){
+
+ boolean peutAfficherVisa = true
+ creeVisa()
+
+ Map result =
+ cahierDeTextesMarshallerService.marshallVisa(securiteSession, peutAfficherVisa, cahierDeTextes)
+
+ assertEquals("La valeur de l'objet 'render' devrait être à ${peutAfficherVisa}",
+ peutAfficherVisa,
+ result.render)
+
+ assertEquals("La valeur de l'objet 'renderTo' devrait être à 'listeVisa'",
+ 'listeVisa',
+ result.renderTo)
+
+ assertTrue("Le cahier de textes détient un visa", result.visas.size() == 1)
+ assertTrue("L'auteur du visa est Rougier Claire", 'Rougier Claire'.equals(result.visas[0].auteur))
+ assertTrue("Le commentaire du visa est 'commentaire'", 'commentaire'.equals(result.visas[0].commentaire))
+
+ }
+
+ private void creeVisa(){
+
+ visaService.creeVisa(securiteSessionDirecteur, cahierDeTextes, "commentaire")
+
+ }
+
+ void testMarsallAccesDroitEtPermissions(){
+
+ Map result =
+ cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession, cahierDeTextes)
+
+ assertFalse("La map retournée doit contenir un objet 'disableEdit' dont la valeur est false",
+ result.disableEdit)
+ assertFalse("La map retournée doit contenir un objet 'disableDroitsEtPermissions' dont la valeur est false",
+ result.disableDroitsEtPermissions)
+
+ }
+
+ void testMarshallCahierDeTextesFusionnes(){
+
+ cahierFusionService.fusionneCahierDans(securiteSession, cahierAFusionner, cahierDeTextes)
+
+ Map result =
+ cahierDeTextesMarshallerService.marshallCahierDeTextesFusionnes(securiteSession, cahierDeTextes)
+
+ assertTrue("""La map retournée doit contenir la liste 'nomAffichageCahiersIncorpores'
+ contenant une valeur""", result.nomAffichageCahiersIncorpores.size() == 1)
+ assertEquals("""La valeur de la liste 'nomAffichageCahiersIncorpores' doit être
+ ${cahierAFusionner.nom} - ${cahierAFusionner.service.modaliteCours.libelleCourt}""",
+ "${cahierAFusionner.nom} - ${cahierAFusionner.service.modaliteCours.libelleCourt}",
+ result.nomAffichageCahiersIncorpores[0])
+
+ }
+
+ void testMarshallFusionCahierInfo(){
+
+ cahierFusionService.fusionneCahierDans(securiteSession, cahierAFusionner, cahierDeTextes)
+
+ Map result = cahierDeTextesMarshallerService.marshallFusionCahierInfo(securiteSession, cahierDeTextes)
+
+ assertTrue("Le cahier de textes contient un cahier fusionné",
+ result.initialCdtsIncorpores.size() == 1)
+
+ boolean isCahierAFusionnerDansCahiersFusionnables = false
+ result.cahiersFilsIncorporationInfo.each{ CahierFusionInfo cahierFusionInfo ->
+ if(cahierFusionInfo.id == cahierAFusionner.id){
+ isCahierAFusionnerDansCahiersFusionnables = true
+ }
+ }
+
+ assertTrue("""La map retournée doit contenir la liste 'cahiersFilsIncorporationInfo'
+ contenant le cahier fusionnable d'id ${cahierAFusionner.id}""",
+ isCahierAFusionnerDansCahiersFusionnables)
+
+ }
+
+ void testMarshallInfoProprietaire(){
+
+ Map result =
+ cahierDeTextesMarshallerService.marshallInfoProprietaire(cahierDeTextes, autorite, true)
+
+ assertEquals("Le nom du propriétaire doit être Chazal Sylvie",
+ "Chazal Sylvie",
+ result.nomProprietaire)
+ assertEquals("La map retournée doit contenir l'élément 'cdtInfoSuppression' dont la valeur doit être vide",
+ "",
+ result.cdtInfoSuppression)
+
+ }
+
+ void testMarshall(){
+
+ Long cdtId = 1
+ String cdtNom = 'nom'
+ String structureCode= '2NDE2'
+ String matierreLibelleLong = 'FRANCAIS'
+ String proprietaireNom = 'dupont'
+ String proprietairePrenom = 'paul'
+ String nomAlias = 'n'
+
+ Calendar calendar = Calendar.getInstance()
+ calendar.set(2013, 0, 1)
+ Date date = calendar.getTime()
+
+ List<CahierDeTextesRechercheInfo> cahiersRechercheInfoList =
+ getCahiersRechercheInfoList(
+ cdtId,
+ cdtNom,
+ structureCode,
+ matierreLibelleLong,
+ proprietaireNom,
+ proprietairePrenom,
+ nomAlias,
+ date
+ )
+
+ Map result = cahierDeTextesMarshallerService.marshall(cahiersRechercheInfoList)
+
+ assertEquals("L'id du cahier n'est pas correct",
+ cdtId,
+ result.cahiers[0].id)
+ assertEquals("Le nom du cahier n'est pas correct",
+ nomAlias + ' (' + cdtNom + ')',
+ result.cahiers[0].nom)
+ assertEquals("Le nom d'affichage de l'enseignant propriétaire du caheir n'est pas correct",
+ proprietaireNom + ' ' + proprietairePrenom,
+ result.cahiers[0].enseignant)
+ assertEquals("Le code de la structure d'enseignement du cahier n'est pas correcte",
+ structureCode,
+ result.cahiers[0].structure)
+ assertEquals("Le libellé de la matière du cahier n'est pas correct",
+ matierreLibelleLong,
+ result.cahiers[0].matiere)
+ assertEquals("Le nombre d'activités du cahier n'est pas correct",
+ 0,
+ result.cahiers[0].nbAct)
+ assertNull("La date de saisie du cahier n'est pas correcte",
+ result.cahiers[0].dateSaisie)
+ assertEquals("La date du dernier visa n'est pas correcte",
+ date,
+ result.cahiers[0].dateDernierVisa)
+ assertFalse("Le cahier n'est pas un cahier d'archive",
+ result.cahiers[0].estCahierArchive)
+ assertTrue("La cahier est vide",
+ result.cahiers[0].estVide)
+ assertTrue("Le cahier est un cahier de classe",
+ result.cahiers[0].estCdtClasse)
+
+ }
+
+ private List<CahierDeTextesRechercheInfo> getCahiersRechercheInfoList(Long cdtId,
+ String cdtNom,
+ String structureCode,
+ String matierreLibelleLong,
+ String proprietaireNom,
+ String proprietairePrenom,
+ String nomAlias,
+ Date date){
+
+ List<CahierDeTextesRechercheInfo> cahiersRechercheInfoList = []
+
+ CahierDeTextesRechercheInfo cahierDeTextesRechercheInfo =
+ new CahierDeTextesRechercheInfo(
+ cdtId,
+ cdtNom,
+ structureCode,
+ matierreLibelleLong,
+ proprietaireNom,
+ proprietairePrenom,
+ nomAlias
+ )
+
+ cahierDeTextesRechercheInfo.estCahierArchive = false
+ cahierDeTextesRechercheInfo.estVide = true
+ cahierDeTextesRechercheInfo.nbrActivitePubliees = 0
+ cahierDeTextesRechercheInfo.estCahierDeClasse = true
+ cahierDeTextesRechercheInfo.activiteDateModification = null
+ cahierDeTextesRechercheInfo.dateDernierVisa = date
+
+ cahiersRechercheInfoList << cahierDeTextesRechercheInfo
+
+ return cahiersRechercheInfoList
+
+ }
+
+ void testMashallListeCdtParEmploiDuTemps(){
+
+ List<RelCahierEvenement> relCahierEvenementList = getRelCahierEvenementList()
+
+ List result =
+ cahierDeTextesMarshallerService.mashallListeCdtParEmploiDuTemps(securiteSession, relCahierEvenementList)
+
+ assertEquals("Le nom du cahier n'est pas correct",
+ cahierDeTextes.nom,
+ result[0].titreCahier)
+ assertFalse("L'objet 'leaf' devrait être à false",
+ result[0].leaf)
+ assertTrue("La liste 'children' devrait être vide",
+ result[0].children.size() == 0)
+ assertTrue("L'objet 'expanded' devrait être à true",
+ result[0].expanded)
+ assertFalse("L'objet 'expandable' devrait être à false",
+ result[0].expandable)
+ assertFalse("L'objet 'peutSupprimerLeCdt' devrait être à false",
+ result[0].peutSupprimerLeCdt)
+ assertTrue("L'objet 'peutModifierLeContenuDuCdt' devrait être à true",
+ result[0].peutModifierLeContenuDuCdt)
+
+ }
+
+ private List<RelCahierEvenement> getRelCahierEvenementList(){
+
+ List<RelCahierEvenement> relCahierEvenementList = []
+
+ Evenement evenement = new Evenement(
+ id: 1
+ )
+
+ RelCahierEvenement relCahierEvenement = new RelCahierEvenement(
+ cahierDeTextes: cahierDeTextes,
+ evenement: evenement
+ )
+
+ relCahierEvenementList << relCahierEvenement
+
+ return relCahierEvenementList
+
+ }
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+
+
+package org.lilie.services.eliot.textes
+
+import org.lilie.services.eliot.textes.cahierdetextes.CahierDeTextesMasqueService
+import org.lilie.services.eliot.test.InitDonneesCommunesTestTextesService
+import org.lilie.services.eliot.test.PopulationTestActeur
+import org.lilie.services.eliot.annuaire.SecuriteSession
+
+class CahierDeTextesMasqueServiceTests extends GroovyTestCase {
+
+ CahierDeTextesMasqueService cahierDeTextesMasqueService
+ InitDonneesCommunesTestTextesService initDonneesCommunesTestTextesService
+
+ protected void setUp() {
+ super.setUp()
+
+ }
+
+ protected void tearDown() {
+ super.tearDown()
+ }
+
+ void testMasquage() {
+
+ CahierDeTextes cdt1 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceMath2NDE2()
+ CahierDeTextes cdt2 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceFrancais2NDE2()
+
+ cahierDeTextesMasqueService.masque([cdt1, cdt2])
+
+ assertTrue("Le cahier de textes de math doit être masqué", cdt1.estMasque)
+ assertTrue("Le cahier de textes de français doit être masqué", cdt2.estMasque)
+
+ }
+
+
+ void testMontre() {
+
+ CahierDeTextes cdt1 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceMath2NDE2()
+ CahierDeTextes cdt2 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceFrancais2NDE2()
+
+ cahierDeTextesMasqueService.masque([cdt1, cdt2])
+
+ assertTrue("Le cahier de textes de math doit être masqué", cdt1.estMasque)
+ assertTrue("Le cahier de textes de français doit être masqué", cdt2.estMasque)
+
+ SecuriteSession securiteSession = (SecuriteSession) initDonneesCommunesTestTextesService.
+ getActeur(PopulationTestActeur.ENSEIGNANT_1).securiteSession
+
+ cahierDeTextesMasqueService.montre(securiteSession, [cdt1])
+
+ assertFalse("Le cahier de textes de math doit être visible", cdt1.estMasque)
+ assertTrue("Le cahier de textes de français doit être masqué", cdt2.estMasque)
+
+
+ }
+
+
+ void testListe() {
+ CahierDeTextes cdt1 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceMath2NDE2()
+ CahierDeTextes cdt2 = initDonneesCommunesTestTextesService.getCahierDeTextesServiceFrancais2NDE2()
+
+ cahierDeTextesMasqueService.masque([cdt1, cdt2])
+
+ SecuriteSession securiteSession = (SecuriteSession) initDonneesCommunesTestTextesService.
+ getActeur(PopulationTestActeur.ENSEIGNANT_1).securiteSession
+
+ List<CahierDeTextes> listecdt = cahierDeTextesMasqueService.findAllCahierMasque(securiteSession)
+
+ assertEquals("Enseignant1 doit pourvoir lister 2 cahier de textes masqués.", 2, listecdt.size())
+ }
+
+
+}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.textes
+
+import org.lilie.services.eliot.test.InitDonneesCommunesTestTextesService
+import org.lilie.services.eliot.test.PopulationTestActeur
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.scolarite.ServiceService
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
+import org.lilie.services.eliot.test.PopulationTestClasse
+import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.test.PopulationTestMatiere
+import org.lilie.services.eliot.scolarite.ModaliteCours
+import org.lilie.services.eliot.test.InitStructureEnseignementTestService
+import org.lilie.services.eliot.test.PopulationTestGroupe
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
+import org.lilie.services.eliot.scolarite.enseignement.EnseignementMisAjourRapport
+import org.lilie.services.eliot.applications.textes.ActiviteParams
+import org.lilie.services.eliot.textes.activite.TextesActiviteService
+import org.lilie.services.eliot.textes.cahierdetextes.CahierFusionService
+import org.lilie.services.eliot.securite.AutorisationException
+import org.lilie.services.eliot.applications.textes.DateActiviteInfo
+import org.lilie.services.eliot.securite.Autorite
+import org.lilie.services.eliot.LocalAutoriteService
+import org.lilie.services.eliot.scolarite.TypeActiviteService
+import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
+import org.lilie.services.eliot.scolarite.matiere.MatiereService
+
+/**
+ * Tests d'intégration de la classe CahierFusionService
+ * @author jtra
+ */
+class CahierFusionServiceIntegrationTests extends GroovyTestCase {
+
+ InitDonneesCommunesTestTextesService initDonneesCommunesTestTextesService
+ TextesCahierDeTextesService textesCahierDeTextesService
+ TextesActiviteService textesActiviteService
+ TextesChapitreService textesChapitreService
+ CahierFusionService cahierFusionService
+ ServiceService serviceService
+ DistantStructureEnseignementService distantStructureEnseignementService
+ MatiereService matiereService
+ InitStructureEnseignementTestService initStructureEnseignementTestService
+ LocalAutoriteService localAutoriteService
+ EnseignementService enseignementService
+ TypeActiviteService typeActiviteService
+
+ // Cahiers utilisés par les tests
+ private CahierDeTextes cahierServiceClasse1Enseignant1 = null
+ private CahierDeTextes cahierServiceClasse1Enseignant2 = null
+ private CahierDeTextes cahierServiceClasse1GroupeAEnseignant1 = null
+ private CahierDeTextes cahierServiceClasse1GroupeBEnseignant2 = null
+ private CahierDeTextes cahierServiceClasse1Enseignant1AutreModalite = null
+ private CahierDeTextes cahierServiceClasse2Enseignant1 = null
+ private CahierDeTextes cahierServiceClasse2GroupeAEnseignant1 = null
+ private CahierDeTextes cahierServiceGroupeClasses1Et2Enseignant1 = null
+ private CahierDeTextes cahierPrive = null
+ private Chapitre chapitre = null
+ private Activite activite = null
+
+ /**
+ * Initialisation du jeu de données utilisé par les tests (structures
+ * enseignements, services, enseignements, cahier de textes)
+ */
+ void setUp() {
+
+ // Initialisation des structures d'enseignement de test
+ initStructureEnseignementTestService.initialiseStructuresEnseignementDeTest()
+
+ // Récupération de la structure CLASSE_1
+ StructureEnseignement structureClasse1 =
+ initDonneesCommunesTestTextesService.getClasse(
+ PopulationTestClasse.HORS_ANNUAIRE_CLASSE_1
+ )
+
+ // Récupération de la structure CLASSE_1_GROUPE_A
+ StructureEnseignement structureClasse1GroupeA =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_A
+ )
+
+ // Récupération de la structure CLASSE_1_GROUPE_B
+ StructureEnseignement structureClasse1GroupeB =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_B
+ )
+
+ // Récupération de la structure CLASSE_2
+ StructureEnseignement structureClasse2 =
+ initDonneesCommunesTestTextesService.getClasse(
+ PopulationTestClasse.HORS_ANNUAIRE_CLASSE_2
+ )
+
+ // Récupération de la structure CLASSE_2_GROUPE_A
+ StructureEnseignement structureClasse2GroupeA =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_2_GROUPE_A
+ )
+
+ // Récupération de la structure GROUPE_CLASSES_1_ET_2
+ StructureEnseignement structureGroupeClasses1Et2 =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_GROUPE_CLASSES1_ET_2
+ )
+
+ // Récupération de la matière 1
+ Matiere matiere = initDonneesCommunesTestTextesService.getMatiere(
+ PopulationTestMatiere.MATH
+ )
+
+ // Récupération de la modalité par défaut
+ ModaliteCours modaliteCoursDefaut =
+ initDonneesCommunesTestTextesService.getModaliteTestCG()
+
+ // Récupération d'une autre modalité
+ ModaliteCours modaliteCoursAutre =
+ initDonneesCommunesTestTextesService.getModaliteTestTP()
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant2 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1_2
+ )
+
+ // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 1)
+ cahierServiceClasse1Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 2)
+ cahierServiceClasse1Enseignant2 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant2.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1_GROUPE_A (pour l'enseignant 1)
+ cahierServiceClasse1GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1GroupeA,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1_GROUPE_B (pour l'enseignant 2)
+ cahierServiceClasse1GroupeBEnseignant2 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1GroupeB,
+ (Autorite) securiteSessionEnseignant2.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1 autre modalité (pour l'enseignant 1)
+ cahierServiceClasse1Enseignant1AutreModalite = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursAutre
+ )
+
+ // Création du cahier de service de CLASSE_2
+ cahierServiceClasse2Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse2,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_2_GROUPE_A
+ cahierServiceClasse2GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse2GroupeA,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de GROUPE_CLASSES_1_ET_2
+ cahierServiceGroupeClasses1Et2Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureGroupeClasses1Et2,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création d'un cahier privé
+ cahierPrive = textesCahierDeTextesService.creerCahierDeTextesPrive(
+ securiteSessionEnseignant1,
+ 'cahier privé',
+ 'description',
+ null,
+ null,
+ null
+ )
+
+ DateActiviteInfo dateActiviteInfo = new DateActiviteInfo()
+ dateActiviteInfo.date = new Date()
+
+ Autorite autorite = localAutoriteService.getAutoriteActeurForIdExterne(
+ securiteSessionEnseignant1.getDefaultAutorite().getIdExterne()
+ )
+
+ TypeActivite typeActivite =
+ typeActiviteService.findByCodeAndCahier(TypeActiviteParDefaut.EXERCICE.code, cahierServiceClasse2GroupeAEnseignant1)
+
+
+ ActiviteParams activiteParams = new ActiviteParams(
+ dates: [dateActiviteInfo],
+ auteur: autorite,
+ cahierDeTextes: cahierServiceClasse2GroupeAEnseignant1,
+ titre: "Titre",
+ chapitreParent: null,
+ estPubliee: true,
+ estTerminee: true,
+ typeActivite: typeActivite,
+ contexteActivite: ContexteActivite.findByCode('MAI'),
+ codeMatiere: "codeMatiere",
+ objectif: "objectif",
+ annotationPrivee: "annotationPrivee",
+ description: "description"
+ )
+
+
+ activite = textesActiviteService.creeActivite(securiteSessionEnseignant1, activiteParams)
+
+ }
+
+
+
+ void testFusionPasProprietaire() {
+
+ SecuriteSession securiteSessionEnseignant2 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1_2
+ )
+ try {
+ cahierFusionService.fusionneCahierDans(
+ securiteSessionEnseignant2,
+ cahierServiceClasse2GroupeAEnseignant1,
+ cahierServiceClasse2Enseignant1
+
+ )
+ } catch (AutorisationException e) {
+
+ }
+
+ assert "On ne doit pas pouvoir fusionner des cahiers de textes dont on n'est pas propriétaire"
+ }
+
+ void testFusion() {
+
+ SecuriteSession securiteSessionEnseignant2 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ cahierFusionService.fusionneCahierDans(
+ securiteSessionEnseignant2,
+ cahierServiceClasse2GroupeAEnseignant1,
+ cahierServiceClasse2Enseignant1
+ )
+
+ List<Activite> act = Activite.findAllByCahierDeTextes(cahierServiceClasse2Enseignant1)
+
+ assertEquals "Le cahier de textes fusionné doit contenir une activité", act.size(), 1
+
+ Activite activiteFusion = act[0]
+
+ assertEquals """L'activité contenu dans le
+ cahier de textes doit être celle qui se trouvait dans le cahier de textes qui a été fusionné""",
+ activiteFusion.id,
+ activite.id
+
+
+ }
+
+ // il manque des candidats à la fusion dans les cahiers de textes passé en paramètre
+ void testFindCahiersIncorporablesPotentiels() {
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierFusionService.findCahiersCompatiblesPourFusionDans(
+ cahierServiceClasse1Enseignant2
+ ),
+ [
+ cahierServiceClasse1GroupeBEnseignant2
+ ]
+ )
+ )
+
+ try {
+ cahierFusionService.findCahiersCompatiblesPourFusionDans(
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ assertTrue(
+ "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+ try {
+ cahierFusionService.findCahiersCompatiblesPourFusionDans(
+ cahierServiceClasse1GroupeBEnseignant2
+ )
+ assertTrue(
+ "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+
+ try {
+ cahierFusionService.findCahiersCompatiblesPourFusionDans(
+ cahierPrive
+ )
+ assertTrue(
+ "Un cahier privé ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+ // TOTEST : Vérification après incorporations
+ }
+
+ void testEstIncorporableDans() {
+ assertFalse(
+ "Un cahier ne doit pas pouvoir être incorporé dans lui-même",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier de classe ne doit pouvoit être incorporé dans un " +
+ "cahier de groupe",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
+ "autre cahier de groupe",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1GroupeBEnseignant2
+ )
+ )
+
+ assertFalse(
+ "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
+ "autre cahier de groupe",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1GroupeBEnseignant2,
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ assertTrue(
+ "Le groupe 1 de la classe 1 doit pouvoir être incorporé dans " +
+ "la classe 1",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier privé n'est pas incorporable",
+ cahierFusionService.estFusionnableDans(
+ cahierPrive,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "On ne peut rien incorporer dans un cahier privé",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierPrive
+ )
+ )
+
+ assertFalse(
+ "On ne doit pas pouvoir incorporer des cahiers d'enseignants différents",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant2
+ )
+ )
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ // Incorpore CLASSE_1_GROUPE_A dans CLASSE_1
+ cahierFusionService.fusionneCahierDans(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ assertFalse(
+ "Un cahier incorporé ne doit plus être incorporable",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ // Ajout d'une activité dans le cahier CLASSE_2_GROUPE_A
+ textesActiviteService.creeActivite(
+ securiteSessionEnseignant1,
+ new ActiviteParams(
+ cahierDeTextes: cahierServiceClasse2GroupeAEnseignant1,
+ titre: 'titre',
+ description: 'description',
+ contexteActivite: ContexteActivite.findByCode(
+ ContexteActivite.CODE_CLASSE
+ ),
+ auteur: (Autorite) securiteSessionEnseignant1.defaultAutorite
+ )
+ )
+
+ assertFalse(
+ "Un cahier incorporant ne doit pas être incorporable",
+ cahierFusionService.estFusionnableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1AutreModalite
+ )
+ )
+
+ }
+
+ void testEstIncorpore() {
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ assertFalse(
+ "Initialement, le cahier ne doit pas être incorporé",
+ cahierServiceClasse1GroupeAEnseignant1.estFusionne
+ )
+
+ // Incorporation du cahier
+ cahierFusionService.fusionneCahierDans(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ assertTrue(
+ "Après incorporation, le cahier doit être incorporé",
+ cahierServiceClasse1GroupeAEnseignant1.estFusionne
+ )
+
+ // Désincorporation du cahier
+ cahierFusionService.detacheCahier(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ )
+
+ assertFalse(
+ "Après désincoporation, le cahier ne doit plus être incorporé",
+ cahierServiceClasse1GroupeAEnseignant1.estFusionne
+ )
+ }
+
+ /**
+ * Création d'un cahier de textes de service, et création du service et de
+ * l'enseignement associé si nécessaire
+ * @return le cahier de service créé
+ */
+ private CahierDeTextes creeCahierServiceEtDonneesScolarite(StructureEnseignement structureEnseignement,
+ Autorite enseignant,
+ Matiere matiere,
+ ModaliteCours modaliteCours) {
+ // Création du service
+ Service service = serviceService.insertUpdateService(
+ structureEnseignement, // Structure enseignement
+ matiere, // matière
+ modaliteCours, // modalite cours
+ 2, // nbHeures (non pertinent pour le test)
+ false
+ )
+
+ // Création de l'enseignement et de cahier de textes corresponadants
+ EnseignementMisAjourRapport enseignementMisAjourRapport =
+ enseignementService.insertUpdateEnseignement(
+ DefaultSecuriteSessionFactory.
+ getEliotTempsSecuriteSessionForCodePorteurENT(
+ structureEnseignement.etablissement.codePorteurENT
+ ),
+ service,
+ enseignant,
+ -1 // Non pertinent pour le test
+ )
+
+ return enseignementMisAjourRapport.cahierDeTextes
+ }
+
+ /**
+ * Teste si 2 collections de cahiers de textes sont identiques (i.e. elles
+ * contiennent les mêmes cahier de textes)
+ * @param c1 une collection de cahiers
+ * @param c2 une collection de cahiers
+ * @return <code>true</code> si les 2 collections sont identiques,
+ * <code>false</code> sinon
+ */
+ private boolean equalsCollectionCdt(Collection c1,
+ Collection c2) {
+ return c1.containsAll(c2) && c2.containsAll(c1)
+ }
+}
+++ /dev/null
-/*
- * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
- * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
- *
- * Lilie is free software. You can redistribute it and/or modify since
- * you respect the terms of either (at least one of the both license) :
- * - under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- * - the CeCILL-C as published by CeCILL-C; either version 1 of the
- * License, or any later version
- *
- * There are special exceptions to the terms and conditions of the
- * licenses as they are applied to this software. View the full text of
- * the exception in file LICENSE.txt in the directory of this software
- * distribution.
- *
- * Lilie is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * Licenses for more details.
- *
- * You should have received a copy of the GNU General Public License
- * and the CeCILL-C along with Lilie. If not, see :
- * <http://www.gnu.org/licenses/> and
- * <http://www.cecill.info/licences.fr.html>.
- */
-
-
-
-package org.lilie.services.eliot.textes
-
-import org.lilie.services.eliot.test.InitDonneesCommunesTestTextesService
-import org.lilie.services.eliot.test.PopulationTestActeur
-import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.scolarite.ServiceService
-import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
-import org.lilie.services.eliot.test.PopulationTestClasse
-import org.lilie.services.eliot.scolarite.Matiere
-
-import org.lilie.services.eliot.test.PopulationTestMatiere
-import org.lilie.services.eliot.scolarite.ModaliteCours
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.test.InitStructureEnseignementTestService
-import org.lilie.services.eliot.test.PopulationTestGroupe
-
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
-import org.lilie.services.eliot.scolarite.enseignement.EnseignementMisAjourRapport
-import org.lilie.services.eliot.applications.textes.ActiviteParams
-import org.lilie.services.eliot.applications.textes.CreeChapitreInfo
-import org.lilie.services.eliot.textes.activite.TextesActiviteService
-
-/**
- * Tests d'intégration de la classe CahierIncorporationService
- * @author jtra
- */
-class CahierIncorporationServiceIntegrationTests extends GroovyTestCase {
-
- InitDonneesCommunesTestTextesService initDonneesCommunesTestTextesService
- TextesCahierDeTextesService textesCahierDeTextesService
- TextesActiviteService textesActiviteService
- TextesChapitreService textesChapitreService
- CahierIncorporationService cahierIncorporationService
- ServiceService serviceService
- DistantStructureEnseignementService distantStructureEnseignementService
- org.lilie.services.eliot.scolarite.matiere.MatiereService matiereService
- InitStructureEnseignementTestService initStructureEnseignementTestService
- org.lilie.services.eliot.scolarite.enseignement.EnseignementService enseignementService
-
- // Cahiers utilisés par les tests
- CahierDeTextes cahierServiceClasse1Enseignant1 = null
- CahierDeTextes cahierServiceClasse1Enseignant2 = null
- CahierDeTextes cahierServiceClasse1GroupeAEnseignant1 = null
- CahierDeTextes cahierServiceClasse1GroupeBEnseignant2 = null
- CahierDeTextes cahierServiceClasse1Enseignant1AutreModalite = null
- CahierDeTextes cahierServiceClasse2Enseignant1 = null
- CahierDeTextes cahierServiceClasse2GroupeAEnseignant1 = null
- CahierDeTextes cahierServiceGroupeClasses1Et2Enseignant1 = null
- CahierDeTextes cahierPrive = null
-
- /**
- * Initialisation du jeu de données utilisé par les tests (structures
- * enseignements, services, enseignements, cahier de textes)
- */
- void setUp() {
-
- // Initialisation des structures d'enseignement de test
- initStructureEnseignementTestService.initialiseStructuresEnseignementDeTest()
-
- // Récupération de la structure CLASSE_1
- StructureEnseignement structureClasse1 =
- initDonneesCommunesTestTextesService.getClasse(
- PopulationTestClasse.HORS_ANNUAIRE_CLASSE_1
- )
-
- // Récupération de la structure CLASSE_1_GROUPE_A
- StructureEnseignement structureClasse1GroupeA =
- initDonneesCommunesTestTextesService.getGroupe(
- PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_A
- )
-
- // Récupération de la structure CLASSE_1_GROUPE_B
- StructureEnseignement structureClasse1GroupeB =
- initDonneesCommunesTestTextesService.getGroupe(
- PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_B
- )
-
- // Récupération de la structure CLASSE_2
- StructureEnseignement structureClasse2 =
- initDonneesCommunesTestTextesService.getClasse(
- PopulationTestClasse.HORS_ANNUAIRE_CLASSE_2
- )
-
- // Récupération de la structure CLASSE_2_GROUPE_A
- StructureEnseignement structureClasse2GroupeA =
- initDonneesCommunesTestTextesService.getGroupe(
- PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_2_GROUPE_A
- )
-
- // Récupération de la structure GROUPE_CLASSES_1_ET_2
- StructureEnseignement structureGroupeClasses1Et2 =
- initDonneesCommunesTestTextesService.getGroupe(
- PopulationTestGroupe.HORS_ANNUAIRE_GROUPE_CLASSES1_ET_2
- )
-
- // Récupération de la matière 1
- Matiere matiere = initDonneesCommunesTestTextesService.getMatiere(
- PopulationTestMatiere.MATH
- )
-
- // Récupération de la modalité par défaut
- ModaliteCours modaliteCoursDefaut =
- initDonneesCommunesTestTextesService.getModaliteTestCG()
-
- // Récupération d'une autre modalité
- ModaliteCours modaliteCoursAutre =
- initDonneesCommunesTestTextesService.getModaliteTestTP()
-
- // Récupération de la session de sécurité de l'enseignant 1
- SecuriteSession securiteSessionEnseignant1 =
- initDonneesCommunesTestTextesService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
- // Récupération de la session de sécurité de l'enseignant 1
- SecuriteSession securiteSessionEnseignant2 =
- initDonneesCommunesTestTextesService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1_2
- )
-
- // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 1)
- cahierServiceClasse1Enseignant1 = creeCahierServiceEtDonneesScolarite(
- structureClasse1,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 2)
- cahierServiceClasse1Enseignant2 = creeCahierServiceEtDonneesScolarite(
- structureClasse1,
- (Autorite) securiteSessionEnseignant2.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de CLASSE_1_GROUPE_A (pour l'enseignant 1)
- cahierServiceClasse1GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
- structureClasse1GroupeA,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de CLASSE_1_GROUPE_B (pour l'enseignant 2)
- cahierServiceClasse1GroupeBEnseignant2 = creeCahierServiceEtDonneesScolarite(
- structureClasse1GroupeB,
- (Autorite) securiteSessionEnseignant2.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de CLASSE_1 autre modalité (pour l'enseignant 1)
- cahierServiceClasse1Enseignant1AutreModalite = creeCahierServiceEtDonneesScolarite(
- structureClasse1,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursAutre
- )
-
- // Création du cahier de service de CLASSE_2
- cahierServiceClasse2Enseignant1 = creeCahierServiceEtDonneesScolarite(
- structureClasse2,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de CLASSE_2_GROUPE_A
- cahierServiceClasse2GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
- structureClasse2GroupeA,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création du cahier de service de GROUPE_CLASSES_1_ET_2
- cahierServiceGroupeClasses1Et2Enseignant1 = creeCahierServiceEtDonneesScolarite(
- structureGroupeClasses1Et2,
- (Autorite) securiteSessionEnseignant1.defaultAutorite,
- matiere,
- modaliteCoursDefaut
- )
-
- // Création d'un cahier privé
- cahierPrive = textesCahierDeTextesService.creerCahierDeTextesPrive(
- securiteSessionEnseignant1,
- 'cahier privé',
- 'description',
- null,
- null,
- null
- )
- }
-
- void testGetFilsCompatiblesIncorporationInfo() {
- // Récupération de la session de sécurité de l'enseignant 1
- SecuriteSession securiteSessionEnseignant1 =
- initDonneesCommunesTestTextesService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
- // Incorpore cahierServiceClasse1GroupeAEnseignant1 dans cahierServiceClasse1Enseignant1
- cahierIncorporationService.incorporeCahierDans(
- securiteSessionEnseignant1,
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
-
- // Ajoute un chapitre dans cahierServiceClasse1Enseignant1AutreModalite
- textesChapitreService.creeChapitre(
- securiteSessionEnseignant1,
- new CreeChapitreInfo(
- nom: 'chapitre',
- description: 'description',
- auteur: (Autorite) securiteSessionEnseignant1.defaultAutorite,
- cahierDeTextes: cahierServiceClasse1Enseignant1AutreModalite
- )
- )
-
- List<CahierIncorporationInfo> filsCompatiblesIncorporationInfo =
- cahierIncorporationService.getFilsCompatiblesIncorporationInfo(
- securiteSessionEnseignant1,
- cahierServiceClasse1Enseignant1
- )
-
- assertEquals(
- "Il doit y avoir 2 cahiers compatibles pour l'incorporation",
- 2,
- filsCompatiblesIncorporationInfo.size()
- )
-
- // Vérification des infos pour cahierServiceClasse1GroupeAEnseignant1
- CahierIncorporationInfo cahierIncorporeInfo =
- (CahierIncorporationInfo) filsCompatiblesIncorporationInfo.find {
- it.id == cahierServiceClasse1GroupeAEnseignant1.id
- }
- assertNotNull(cahierIncorporeInfo)
- assertEquals(cahierIncorporeInfo.idParent, cahierServiceClasse1Enseignant1.id)
- assertTrue(cahierIncorporeInfo.estVide)
- assertTrue(cahierIncorporeInfo.estIncorpore)
-
- // Vérification des infos pour cahierServiceClasse1Enseignant1AutreModalite
- CahierIncorporationInfo cahierNonVideInfo =
- (CahierIncorporationInfo) filsCompatiblesIncorporationInfo.find {
- it.id == cahierServiceClasse1Enseignant1AutreModalite.id
- }
-
- assertNotNull(cahierNonVideInfo)
- assertEquals(cahierNonVideInfo.idParent, cahierServiceClasse1Enseignant1.id)
- assertFalse(cahierNonVideInfo.estVide)
- assertFalse(cahierNonVideInfo.estIncorpore)
- }
-
- void testFindCahiersParentsIncorporationCompatibles() {
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse1Enseignant1
- ),
- [
- cahierServiceClasse1Enseignant1AutreModalite
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse1Enseignant2
- ),
- []
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse1GroupeAEnseignant1
- ),
- [
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1Enseignant1AutreModalite
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse1GroupeBEnseignant2
- ),
- [
- cahierServiceClasse1Enseignant2
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse1Enseignant1AutreModalite
- ),
- [
- cahierServiceClasse1Enseignant1
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse2Enseignant1
- ),
- []
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceClasse2GroupeAEnseignant1
- ),
- [
- cahierServiceClasse2Enseignant1
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierServiceGroupeClasses1Et2Enseignant1
- ),
- []
- )
- )
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
- cahierPrive
- ),
- []
- )
- )
-
- // TOTEST: Vérifier après incorporations
- }
-
- void testFindCahiersIncorporablesPotentiels() {
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse1Enseignant1
- ),
- [
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1AutreModalite
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse1Enseignant2
- ),
- [
- cahierServiceClasse1GroupeBEnseignant2
- ]
- )
- )
-
- try {
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse1GroupeAEnseignant1
- )
- assertTrue(
- "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
- false
- )
- }
- catch (IllegalArgumentException e) {
- // Comportement attendu
- }
-
- try {
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse1GroupeBEnseignant2
- )
- assertTrue(
- "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
- false
- )
- }
- catch (IllegalArgumentException e) {
- // Comportement attendu
- }
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse1Enseignant1AutreModalite
- ),
- [
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1GroupeAEnseignant1
- ]
- )
- )
-
- assertTrue(
- equalsCollectionCdt(
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierServiceClasse2Enseignant1
- ),
- [
- cahierServiceClasse2GroupeAEnseignant1
- ]
- )
- )
-
- try {
- cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
- cahierPrive
- )
- assertTrue(
- "Un cahier privé ne peut pas incorporer d'autres cahiers",
- false
- )
- }
- catch (IllegalArgumentException e) {
- // Comportement attendu
- }
-
- // TOTEST : Vérification après incorporations
- }
-
- void testEstIncorporableDans() {
- assertFalse(
- "Un cahier ne doit pas pouvoir être incorporé dans lui-même",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1Enseignant1
- )
- )
-
- assertFalse(
- "Un cahier de classe ne doit pouvoit être incorporé dans un " +
- "cahier de groupe",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1GroupeAEnseignant1
- )
- )
-
- assertFalse(
- "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
- "autre cahier de groupe",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1GroupeBEnseignant2
- )
- )
-
- assertFalse(
- "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
- "autre cahier de groupe",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1GroupeBEnseignant2,
- cahierServiceClasse1GroupeAEnseignant1
- )
- )
-
- assertTrue(
- "Le groupe 1 de la classe 1 doit pouvoir être incorporé dans " +
- "la classe 1",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
- )
-
- assertFalse(
- "Un cahier privé n'est pas incorporable",
- cahierIncorporationService.estIncorporableDans(
- cahierPrive,
- cahierServiceClasse1Enseignant1
- )
- )
-
- assertFalse(
- "On ne peut rien incorporer dans un cahier privé",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierPrive
- )
- )
-
- assertTrue(
- "On doit pouvoir incorporer des cahiers de classe associés à la " +
- "même structure, au même enseignant, et qui diffère par leur " +
- "modalité cours",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1Enseignant1AutreModalite
- )
- )
-
- assertTrue(
- "On doit pouvoir incorporer des cahiers de classe associés à la " +
- "même structure, au même enseignant, et qui diffère par leur " +
- "modalité cours",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1AutreModalite,
- cahierServiceClasse1Enseignant1
- )
- )
-
- assertFalse(
- "On ne doit pas pouvoir incorporer des cahiers de classes différentes",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse2Enseignant1
- )
- )
-
- assertFalse(
- "On ne doit pas pouvoir incorporer des cahiers d'enseignants différents",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1Enseignant2
- )
- )
-
- assertFalse(
- "Le groupe CLASSE_2_GROUPE_A est incompatible pour l'incorporation " +
- "avec la classe CLASSE_1",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse2GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
- )
-
- assertFalse(
- "Un groupe associé à plusieurs classes ne peut pas être incorporé",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceGroupeClasses1Et2Enseignant1,
- cahierServiceClasse1Enseignant1
- )
- )
-
- // Récupération de la session de sécurité de l'enseignant 1
- SecuriteSession securiteSessionEnseignant1 =
- initDonneesCommunesTestTextesService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
- // Incorpore CLASSE_1_GROUPE_A dans CLASSE_1
- cahierIncorporationService.incorporeCahierDans(
- securiteSessionEnseignant1,
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
-
- assertFalse(
- "Un cahier incorporé ne doit plus être incorporable",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
- )
-
- // Ajout d'une activité dans le cahier CLASSE_2_GROUPE_A
- textesActiviteService.creeActivite(
- securiteSessionEnseignant1,
- new ActiviteParams(
- cahierDeTextes: cahierServiceClasse2GroupeAEnseignant1,
- titre: 'titre',
- description: 'description',
- contexteActivite: ContexteActivite.findByCode(
- ContexteActivite.CODE_CLASSE
- ),
- auteur: (Autorite) securiteSessionEnseignant1.defaultAutorite
- )
- )
-
- assertFalse(
- "Un cahier non-vide ne doit pas être incorporable",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse2GroupeAEnseignant1,
- cahierServiceClasse2Enseignant1
- )
- )
-
- assertFalse(
- "Un cahier incorporant ne doit pas être incorporable",
- cahierIncorporationService.estIncorporableDans(
- cahierServiceClasse1Enseignant1,
- cahierServiceClasse1Enseignant1AutreModalite
- )
- )
-
- // TOTEST : Vérifier que des cahiers d'années différentes ne peuvent pas être incorporés l'un dans l'autre
- }
-
- void testEstIncorpore() {
-
- // Récupération de la session de sécurité de l'enseignant 1
- SecuriteSession securiteSessionEnseignant1 =
- initDonneesCommunesTestTextesService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
- )
-
- assertFalse(
- "Initialement, le cahier ne doit pas être incorporé",
- cahierIncorporationService.estIncorpore(
- cahierServiceClasse1GroupeAEnseignant1
- )
- )
-
- // Incorporation du cahier
- cahierIncorporationService.incorporeCahierDans(
- securiteSessionEnseignant1,
- cahierServiceClasse1GroupeAEnseignant1,
- cahierServiceClasse1Enseignant1
- )
-
- assertTrue(
- "Après incorporation, le cahier doit être incorporé",
- cahierIncorporationService.estIncorpore(
- cahierServiceClasse1GroupeAEnseignant1
- )
- )
-
- // Désincorporation du cahier
- cahierIncorporationService.desincorporeCahier(
- securiteSessionEnseignant1,
- cahierServiceClasse1GroupeAEnseignant1,
- )
-
- assertFalse(
- "Après désincoporation, le cahier ne doit plus être incorporé",
- cahierIncorporationService.estIncorpore(
- cahierServiceClasse1GroupeAEnseignant1
- )
- )
- }
-
- void testLanceIncorporationAuto() {
- // A ecrire
- }
-
- /**
- * Création d'un cahier de textes de service, et création du service et de
- * l'enseignement associé si nécessaire
- * @return le cahier de service créé
- */
- private CahierDeTextes creeCahierServiceEtDonneesScolarite(StructureEnseignement structureEnseignement,
- Autorite enseignant,
- Matiere matiere,
- ModaliteCours modaliteCours) {
- // Création du service
- Service service = serviceService.insertUpdateService(
- structureEnseignement, // Structure enseignement
- matiere, // matière
- modaliteCours, // modalite cours
- 2, // nbHeures (non pertinent pour le test)
- false
- )
-
- // Création de l'enseignement et de cahier de textes corresponadants
- EnseignementMisAjourRapport enseignementMisAjourRapport =
- enseignementService.insertUpdateEnseignement(
- DefaultSecuriteSessionFactory.
- getEliotTempsSecuriteSessionForCodePorteurENT(
- structureEnseignement.etablissement.codePorteurENT
- ),
- service,
- enseignant,
- -1 // Non pertinent pour le test
- )
-
- return enseignementMisAjourRapport.cahierDeTextes
- }
-
- /**
- * Teste si 2 collections de cahiers de textes sont identiques (i.e. elles
- * contiennent les mêmes cahier de textes)
- * @param c1 une collection de cahiers
- * @param c2 une collection de cahiers
- * @return <code>true</code> si les 2 collections sont identiques,
- * <code>false</code> sinon
- */
- private boolean equalsCollectionCdt(Collection c1,
- Collection c2) {
- return c1.containsAll(c2) && c2.containsAll(c1)
- }
-}
import org.lilie.services.eliot.test.PopulationTestAnneeScolaire
import org.lilie.services.eliot.textes.Dossier
import org.lilie.services.eliot.test.PopulationTestClasse
+import org.lilie.services.eliot.textes.cahierdetextes.CahierDeTextesMasqueService
/**
* Tests de la recherche des cahiers de textes
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
DistantGroupeService distantGroupeService
InitAnneeScolaireTestService initAnneeScolaireTestService
+ CahierDeTextesMasqueService cahierDeTextesMasqueService
Etablissement etab1 // ETAB_10 Léonard de Vinci (pro)
Etablissement etab2 // ETAB_11 Léonard de Vinci (tech)
super.setUp()
personneDir = localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.DIRECTION_4)
+ PopulationTestActeur.DIRECTION_4)
securiteSessionDir =
textesInitDonneesCommunesTextesService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_4
+ PopulationTestActeur.DIRECTION_4
)
etab1 = localInitDonneesCommunesTestService.
structure4 = localInitDonneesCommunesTestService.
getStructureEnseignement(UTIL_SRC_ENS1_CLS4_MAT1_NON_VISE.structureEnseignement)
structure5 = localInitDonneesCommunesTestService.
- getStructureEnseignement(SRC_ENS1_CLS5_MAT1_INCORPORE.structureEnseignement)
+ getStructureEnseignement(SRC_ENS1_CLS5_MAT1_INCORPORE.structureEnseignement)
groupeEtab3 = localInitDonneesCommunesTestService.
- getStructureEnseignement(SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE.structureEnseignement)
+ getStructureEnseignement(SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE.structureEnseignement)
classeEtab3 = localInitDonneesCommunesTestService.
- getStructureEnseignement(PopulationTestClasse.CLASSE_1)
+ getStructureEnseignement(PopulationTestClasse.CLASSE_1)
etab3 = localInitDonneesCommunesTestService.
- getEtablissement(SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE.etablissement)
+ getEtablissement(SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE.etablissement)
securiteSessionDirEtab3 =
textesInitDonneesCommunesTextesService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
+ PopulationTestActeur.DIRECTION_1
)
dossierTous = null
dossierArchive = new DossierInfo(
initAnneeScolaireTestService.getAnneeScolaire(
PopulationTestAnneeScolaire.ANNEE_MOINS_1).
- extraitAnneeDebutInteger() * -1)
+ extraitAnneeDebutInteger() * -1)
Dossier dossierUtil = textesInitDonneesCommunesTextesService.
- getDossierForAutorite(personneDir.autorite)
+ getDossierForAutorite(personneDir.autorite)
dossierUtilisateur = new DossierInfo(dossierUtil.id)
infoGroupeDir1 = distantGroupeService.getGroupeInfoDeDirection(etab1)
- Vise
*/
-
- /**
- * Lance la recherche et verifie les resultats
- * @param criteria criteres de recherche
- * @param cahierAttendus cahiers prevus a etre trouve par la recherche
- * @param mapCahiers map de population des cahiers
- * @param securiteSession a definir si on veut utilise une securiteSession pas par defaut
- */
- private void verifieRecherche(Map criteria,
- List<PopulationTestCahierDeTextes> cahierAttendus,
- Map<PopulationTestCahierDeTextes, CahierDeTextes> mapCahiers,
- SecuriteSession securiteSession = null
- ) {
-
+ private List<CahierDeTextesRechercheInfo> recherche(Map criteria,
+ SecuriteSession securiteSession = null) {
if (securiteSession == null) {
securiteSession = securiteSessionDir
}
criteria.estVise,
criteria.inclureArchives,
criteria.dossier,
- getGroupeDirInfo(criteria.etablissement)
+ criteria.estVide
)
+ return cahiersTrouvesInfos
+ }
+
+ /**
+ * Lance la recherche et verifie les resultats
+ * @param criteria criteres de recherche
+ * @param cahierAttendus cahiers prevus a etre trouve par la recherche
+ * @param mapCahiers map de population des cahiers
+ * @param securiteSession a definir si on veut utilise une securiteSession pas par defaut
+ */
+ private void verifieRecherche(Map criteria,
+ List<PopulationTestCahierDeTextes> cahierAttendus,
+ Map<PopulationTestCahierDeTextes, CahierDeTextes> mapCahiers,
+ SecuriteSession securiteSession = null
+ ) {
+
+ // lance la recherche
+ List<CahierDeTextesRechercheInfo> cahiersTrouvesInfos = recherche(
+ criteria,
+ securiteSession)
// verifie resultats attendu
verifieResultats(cahiersTrouvesInfos, cahierAttendus, mapCahiers)
*/
void testRechercheClasseGroupe() {
Map<PopulationTestCahierDeTextes, CahierDeTextes> mapCahiers = [
- (SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE) :
- textesInitDonneesCommunesTextesService.getCahierDeTextes(
- SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE,
- securiteSessionDirEtab3
- )
+ (SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE):
+ textesInitDonneesCommunesTextesService.getCahierDeTextes(
+ SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE,
+ securiteSessionDirEtab3
+ )
]
// [Etab3, Tous, Inclure archives, Groupe1]
verifieRecherche([
- etablissement: etab3,
- dossier: dossierTous,
- inclureArchives: true,
- structure: groupeEtab3
+ etablissement: etab3,
+ dossier: dossierTous,
+ inclureArchives: true,
+ structure: groupeEtab3
], [
- SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE
+ SRC_ENS2_GROUPE1_MAT1_ETAB3_VISE
], mapCahiers, securiteSessionDirEtab3)
// [Etab3, Tous, Inclure archives, Classe1]
verifieRecherche([
- etablissement: etab3,
- dossier: dossierTous,
- inclureArchives: true,
- structure: classeEtab3
+ etablissement: etab3,
+ dossier: dossierTous,
+ inclureArchives: true,
+ structure: classeEtab3
], [], mapCahiers, securiteSessionDirEtab3)
}
], [
SRC_ENS1_CLS1_MAT1_ETAB2,
ARCH_PART_VISE // archive est partage avec le groupe de direction
- // etab1 et etab2 (c'est une site scolaire)
+ // etab1 et etab2 (c'est une site scolaire)
], mapCahiers)
// [Etab1, Mes cahiers prives]
verifieRecherche([
etablissement: etab1,
dossier: dossierCahiersClassePartages,
- inclureArchives: true
+ inclureArchives: true
], [
SRC_ENS1_CLS1_MAT2_ETAB1_VISE
], mapCahiers)
}
+ void testRechercheMasques1() {
+
+ println "testRechercheMasques1"
+
+ Map<PopulationTestCahierDeTextes, CahierDeTextes> mapCahiers =
+ initialiseSetCahiersMasques(true)
+
+ List<CahierDeTextesRechercheInfo> cahiersTrouvesInfos = recherche(
+ [
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: false
+ ]
+ )
+
+ println cahiersTrouvesInfos.size()
+
+ cahiersTrouvesInfos = recherche(
+ [
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: true
+ ]
+ )
+
+ println cahiersTrouvesInfos.size()
+
+ cahiersTrouvesInfos.each {
+ CahierDeTextesRechercheInfo cahierDeTextesRechercheInfo ->
+ CahierDeTextes cahierDeTextes = CahierDeTextes.get(cahierDeTextesRechercheInfo.cdtId)
+ cahierDeTextesMasqueService.masque([cahierDeTextes])
+ }
+
+ List<CahierDeTextesRechercheInfo> cahiersTrouvesUneFoisCaches = recherche(
+ [
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: false
+ ]
+ )
+
+ println cahiersTrouvesUneFoisCaches.size()
+
+
+
+ verifieRecherche([
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: false
+ ], [
+ ], mapCahiers)
+
+
+ }
+
+
+ void testRechercheMasques2() {
+
+ println "testRechercheMasques2"
+
+ Map<PopulationTestCahierDeTextes, CahierDeTextes> mapCahiers =
+ initialiseSetCahiersMasques(false)
+
+ List<CahierDeTextesRechercheInfo> cahiersTrouvesInfos = recherche(
+ [
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: false
+ ]
+ )
+
+ println cahiersTrouvesInfos.size()
+
+ cahiersTrouvesInfos = recherche(
+ [
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: true
+ ]
+ )
+
+ println cahiersTrouvesInfos.size()
+
+ cahiersTrouvesInfos.each {
+ CahierDeTextesRechercheInfo cahierDeTextesRechercheInfo ->
+ CahierDeTextes cahierDeTextes = CahierDeTextes.get(cahierDeTextesRechercheInfo.cdtId)
+ cahierDeTextesMasqueService.masque([cahierDeTextes])
+ }
+
+
+
+ verifieRecherche([
+ etablissement: etab1,
+ dossier: dossierTous,
+ inclureArchives: true,
+ estVise: false,
+ estVide: false
+ ], [
+ ], mapCahiers)
+
+
+ }
+
+
/**
* Test de recherche avec parametre: Visé
*/
]
}
+ private Map<PopulationTestCahierDeTextes, CahierDeTextes> initialiseSetCahiersMasques(boolean masque) {
+
+
+ CahierDeTextes cdtMasque = textesInitDonneesCommunesTextesService.getCahierDeTextes(
+ SRC_ENS1_CLS1_MAT1_ETAB1_VISE,
+ securiteSessionDir
+ )
+
+// if (masque) {
+// cahierDeTextesMasqueService.masque([cdtMasque])
+// }
+
+ return [
+ (SRC_ENS1_CLS1_MAT1_ETAB1_VISE):
+ cdtMasque,
+ (UTIL_SRC_ENS1_CLS3_MAT1_VISE):
+ textesInitDonneesCommunesTextesService.getCahierDeTextes(
+ UTIL_SRC_ENS1_CLS3_MAT1_VISE,
+ securiteSessionDir
+ )
+ ]
+
+ }
+
/**
* Initialisation des cahiers
* @return
]
}
+
}
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.demon.DemandeTraitementService
-import org.lilie.services.eliot.textes.droits.ActionPossibleService
import org.lilie.services.eliot.textes.impression.requetage.CahierDeTextesImpressionService
import org.lilie.services.eliot.demon.impl.DefaultTraitementType
import org.lilie.services.eliot.demon.impl.DefaultDemandeTraitement
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.demon.DemandeTraitement
import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.textes.cahierdetextes.CahierDeTextesDroitsService
/**
* @author bper
class TextesImpressionDiffereeSpec extends UnitSpec {
DemandeTraitementService demandeTraitementService
- ActionPossibleService actionPossibleService
+ CahierDeTextesDroitsService cahierDeTextesDroitsService
CahierDeTextesImpressionService cahierDeTextesImpressionService
TextesImpressionDiffereeService textesImpressionDiffereeService
def setup() {
demandeTraitementService = Mock()
- actionPossibleService = Mock()
+ cahierDeTextesDroitsService = Mock()
cahierDeTextesImpressionService = Mock()
mockLogging(TextesImpressionDiffereeService, false)
textesImpressionDiffereeService = new TextesImpressionDiffereeService(
demandeTraitementService: demandeTraitementService,
- actionPossibleService: actionPossibleService,
+ cahierDeTextesDroitsService: cahierDeTextesDroitsService,
cahierDeTextesImpressionService: cahierDeTextesImpressionService
)
mockDomain(CahierDeTextes, ids.collect {new CahierDeTextes(id:it, nom: "CDT_$id")})
- actionPossibleService.verifierAccesConsultation(securiteSession,_)
+ cahierDeTextesDroitsService.verifierAccesConsultation(securiteSession,_)
TextesImpressionParam param = new TextesImpressionParam(
dateDebut: dateDebut,
mockDomain(CahierDeTextes, null)
- actionPossibleService.verifierAccesConsultation(securiteSession,_) >> {}
+ cahierDeTextesDroitsService.verifierAccesConsultation(securiteSession,_) >> {}
TextesImpressionParam param = new TextesImpressionParam(
dateDebut: dateDebut,
mockDomain(CahierDeTextes, ids.collect {new CahierDeTextes(id: it)})
- actionPossibleService.verifierAccesConsultation(securiteSession,_) >> {_, cdt ->
+ cahierDeTextesDroitsService.verifierAccesConsultation(securiteSession,_) >> {_, cdt ->
if (cdt.id == cdtNonAutoriseId) {
throw AutorisationException.consultationContenuException()
}
.ext-gecko .x-form-text, .ext-ie8 .x-form-text, .ext-ie7 .x-form-text, .ext-ie9 .x-form-text {
padding-bottom: 0;
}
+
+#tableCahiersFusionnes {
+ display: table;
+ width: 450px;
+ border: 1px solid #ccc;
+ padding: 4px;
+ margin-bottom: 10px;
+}
+
+#rowTitreCahiersFusionnes {
+ display: table-row;
+ font-weight: bold;
+}
+
+.rowCahiersFusionnes {
+ display: table-row;
+}
+
+.cellCahierFusionne {
+ display: table-cell;
+ width: 100%;
+}
+
+.cellBouton {
+ display: table-cell;
+ width : 20px;
+}
+
+.desactive {
+ pointer-events: none;
+ cursor: default;
+ color: #A0A0A0;
+}
+
+#contenuRattachement {
+ float:left;
+ padding-bottom:10px;
+}
+
+#cahiersFusionnables {
+ width: 254px;
+ margin-left: 20px;
+}
eliot.textes.ArbreCdt = Ext.extend(Ext.util.Observable, {
- constructor:function (config) {
- var loader = new Ext.tree.TreeLoader(
- {
- dataUrl:config.dataUrl,
- baseParams:config.baseParams
- });
-
- var atn;
- if (config.etatArbre.length > 0) {
- atn = new Ext.tree.AsyncTreeNode({
- id:config.rootId,
- draggable:false,
- children:config.etatArbre,
- loader:loader
- });
- }
- else {
- atn = new Ext.tree.AsyncTreeNode({
- id:config.rootId,
- draggable:false,
- loader:loader
- });
- }
-
- var configTreePanel = {
- id:config.identifiant,
- contextMenu:config.contextMenu,
- loader:loader,
- rootVisible:false,
- border:false,
- useArrows:true,
- animate:true,
- enableDD:true,
- autoScroll:true,
- // Evite une bizarerie lors des drag drop
- hlDrop:false,
-
- dropConfig:{
- appendOnly:true // on ne veut pas deposer les noeuds entre/dessus/dessous les autres
- },
-
- root:atn,
-
- plugins:[new Ext.ux.state.StateTreePanel()],
- listeners:{
- load:{
- fn:function (node) {
- this.selectTreeNodeCdt(node, config.cdtSelectionne);
- },
- scope:this
- }
- }
- };
-
- this.treePanel = new Ext.tree.TreePanel(configTreePanel);
- this.observeTree();
-
- this.observeMenuContextuel();
-
- // On trie l'arbre des cahiers par ordre alphabétique
- new Ext.tree.TreeSorter(this.treePanel, {
- folderSort:true,
- dir:'asc',
- sortType:function (node) {
- if (node.id.charAt(0) == 'd') {
- if (node.attributes.ordre == null) {
- return parseInt('10000', 10);
- } else {
- return parseInt(node.attributes.ordre, 10);
- }
- }
- else {
- return 'Z' + node.text.toUpperCase();
- }
- }
- });
- // Ajout des évènements perso
- this.selectionCahierEvent = 'selectionCahierEvent';
- this.selectionDossierEvent = 'selectionDossierEvent';
- this.importDansCahierEvent = 'importDansCahierEvent';
- this.contextMenuEvent = 'contextMenuEvent';
- this.proprietesEvent = 'proprietesEvent';
- this.addEvents(this.selectionCahierEvent,
- this.selectionDossierEvent,
- this.importDansCahierEvent,
- this.contextMenuEvent,
- this.proprietesEvent
- );
-
- this.listeners = config.listeners;
- },
-
- /**
- * Enregistrement des listeners des évènements de l'arbre
- */
- observeTree:function () {
- this.treePanel.addListener({
- contextmenu:{
- fn:function (node, event) {
- // Menu contextuel désactivé pour l'instant
- /*this.contextMenuEventAction(node, event);
- this.noeudArbreSelectionne = node;*/
- },
- scope:this
- }
+ constructor:function (config) {
+ var loader = new Ext.tree.TreeLoader(
+ {
+ dataUrl:config.dataUrl,
+ baseParams:config.baseParams
});
- this.treePanel.addListener({
- startdrag:{
- fn:function (tree, node, event) {
- this.dragAction(tree, node, event);
- },
- scope:this
- }
- });
- this.treePanel.addListener({
- movenode:{
- fn:function (tree, node, oldParent, newParent, position) {
- this.deplacerAction(tree, node, oldParent, newParent, position);
- },
- scope:this
- }
- });
- this.treePanel.getSelectionModel().addListener({
- selectionchange:{
- fn:function (selModel, node) {
- this.clickAction(node);
- },
- scope:this
- }
- });
- this.treePanel.addListener({
- expandnode:{
- fn:function (node) {
- this.deroulerAction(node);
- },
- scope:this
- }
- });
- this.treePanel.addListener({
- nodedragover:{
- fn:function (event) {
- this.dropAction(event);
- },
- scope:this
- }
- });
- },
-
- observeMenuContextuel:function () {
- Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuProprietesCdt).addListener({
- click:{
- fn:function () {
- // TOREFACT : A reprendre envoyer le node sélectionné
- // this.proprietesEventAction();
- }, scope:this
- }
- });
+ var atn;
+ if (config.etatArbre.length > 0) {
+ atn = new Ext.tree.AsyncTreeNode({
+ id:config.rootId,
+ draggable:false,
+ children:config.etatArbre,
+ loader:loader
+ });
+ }
+ else {
+ atn = new Ext.tree.AsyncTreeNode({
+ id:config.rootId,
+ draggable:false,
+ loader:loader
+ });
+ }
- Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuSupprimerCdt).addListener({
- click:{
- fn:function () {
- var isCurrentCdtAsContextMenuSelected =
- this.isCurrentCdtAsContextMenuSelected();
-
- if (this.noeudArbreDossierSel.id.charAt(0) == 'c') {
- this.leftToolbar.setNodeSelectionnee(
- this.noeudArbreDossierSel
- );
- this.leftToolbar.actionSupprimerCahier(
- isCurrentCdtAsContextMenuSelected
- );
- }
- if (this.noeudArbreDossierSel.id.charAt(0) == 'd') {
- this.leftToolbar.setNodeSelectionnee(
- this.noeudArbreDossierSel
- );
- this.leftToolbar.actionSupprimerDossier();
- }
- }, scope:this
- }
- });
+ var configTreePanel = {
+ id:config.identifiant,
+ contextMenu:config.contextMenu,
+ loader:loader,
+ rootVisible:false,
+ border:false,
+ useArrows:true,
+ animate:true,
+ enableDD:true,
+ autoScroll:true,
+ // Evite une bizarerie lors des drag drop
+ hlDrop:false,
+
+ dropConfig:{
+ appendOnly:true // on ne veut pas deposer les noeuds entre/dessus/dessous les autres
+ },
+
+ root:atn,
+
+ plugins:[new Ext.ux.state.StateTreePanel()],
+ listeners:{
+ load:{
+ fn:function (node) {
+ this.selectTreeNodeCdt(node, config.cdtSelectionne);
+ },
+ scope:this
+ }
+ }
+ };
+
+ this.treePanel = new Ext.tree.TreePanel(configTreePanel);
+ this.observeTree();
+
+ this.observeMenuContextuel();
+
+ // On trie l'arbre des cahiers par ordre alphabétique
+ new Ext.tree.TreeSorter(this.treePanel, {
+ folderSort:true,
+ dir:'asc',
+ sortType:function (node) {
+ if (node.id.charAt(0) == 'd') {
+ if (node.attributes.ordre == null) {
+ return parseInt('10000', 10);
+ } else {
+ return parseInt(node.attributes.ordre, 10);
+ }
+ }
+ else {
+ return 'Z' + node.text.toUpperCase();
+ }
+ }
+ });
+ // Ajout des évènements perso
+ this.selectionCahierEvent = 'selectionCahierEvent';
+ this.selectionDossierEvent = 'selectionDossierEvent';
+ this.importDansCahierEvent = 'importDansCahierEvent';
+ this.contextMenuEvent = 'contextMenuEvent';
+ this.proprietesEvent = 'proprietesEvent';
+ this.addEvents(this.selectionCahierEvent,
+ this.selectionDossierEvent,
+ this.importDansCahierEvent,
+ this.contextMenuEvent,
+ this.proprietesEvent
+ );
+
+ this.listeners = config.listeners;
+ },
+
+ /**
+ * Enregistrement des listeners des évènements de l'arbre
+ */
+ observeTree:function () {
+ this.treePanel.addListener({
+ contextmenu:{
+ fn:function (node, event) {
+ // Menu contextuel désactivé pour l'instant
+ /*this.contextMenuEventAction(node, event);
+ this.noeudArbreSelectionne = node;*/
+ },
+ scope:this
+ }
+ });
+
+ this.treePanel.addListener({
+ startdrag:{
+ fn:function (tree, node, event) {
+ this.dragAction(tree, node, event);
+ },
+ scope:this
+ }
+ });
+ this.treePanel.addListener({
+ movenode:{
+ fn:function (tree, node, oldParent, newParent, position) {
+ this.deplacerAction(tree, node, oldParent, newParent, position);
+ },
+ scope:this
+ }
+ });
+ this.treePanel.getSelectionModel().addListener({
+ selectionchange:{
+ fn:function (selModel, node) {
+ this.clickAction(node);
+ },
+ scope:this
+ }
+ });
+ this.treePanel.addListener({
+ expandnode:{
+ fn:function (node) {
+ this.deroulerAction(node);
+ },
+ scope:this
+ }
+ });
+ this.treePanel.addListener({
+ nodedragover:{
+ fn:function (event) {
+ this.dropAction(event);
+ },
+ scope:this
+ }
+ });
+ },
+
+ observeMenuContextuel:function () {
+ Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuProprietesCdt).addListener({
+ click:{
+ fn:function () {
+ // TOREFACT : A reprendre envoyer le node sélectionné
+ // this.proprietesEventAction();
+ }, scope:this
+ }
+ });
+
+ Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuSupprimerCdt).addListener({
+ click:{
+ fn:function () {
+ var isCurrentCdtAsContextMenuSelected =
+ this.isCurrentCdtAsContextMenuSelected();
+
+ if (this.noeudArbreDossierSel.id.charAt(0) == 'c') {
+ this.leftToolbar.setNodeSelectionnee(
+ this.noeudArbreDossierSel
+ );
+ this.leftToolbar.actionSupprimerCahier(
+ isCurrentCdtAsContextMenuSelected
+ );
+ }
+ if (this.noeudArbreDossierSel.id.charAt(0) == 'd') {
+ this.leftToolbar.setNodeSelectionnee(
+ this.noeudArbreDossierSel
+ );
+ this.leftToolbar.actionSupprimerDossier();
+ }
+ }, scope:this
+ }
+ });
- Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuColler).addListener({
- click:{
- fn:function () {
- // TOIMP : à completer
- }, scope:this
- }
- });
+ Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuColler).addListener({
+ click:{
+ fn:function () {
+ // TOIMP : à completer
+ }, scope:this
+ }
+ });
- Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuSupprimerDossier).addListener({
- click:{
- fn:function () {
- this.leftToolbar.actionSupprimerDossier();
- }, scope:this
- }
- });
+ Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuSupprimerDossier).addListener({
+ click:{
+ fn:function () {
+ this.leftToolbar.actionSupprimerDossier();
+ }, scope:this
+ }
+ });
- Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuRenommerDossier).addListener({
- click:{
- fn:function () {
- this.leftToolbar.actionRenommerDossier();
- }, scope:this
- }
- });
- },
-
-
- /**
- * Action déclenchée lors du "drag" d'un cahier ou dossier
- * @param tree l'arbre
- * @node la node "draggée"
- */
- dragAction:function (tree, node) {
- this.oldPosition = node.parentNode.indexOf(node);
- this.oldNextSibling = node.nextSibling;
- },
- /**
- * Action déclenchée lors du drop d'une node sur une autre, permet de
- * contrôler la validité du drop.
- * @param event l'évènement lancé par l'arbre
- */
- dropAction:function (event) {
- // NB vu que la TreeDropZone est configuree a appendOnly, event.point est toujours "append"
- var nodeSource = event.dropNode;
- var nodeTarget = event.target;
- var dropAutorise = true;
-
- // Si l'utilisateur n'a pas le droit de modifier le CDT cible
- // ou a un accès restrient à l'application
- var peutModifierCdtTarget =
- event.target.attributes.peutModifierLeContenuDuCdt &&
- !eliot.textes.Modele.isAcceesRestreint;
-
- if (eliot.textes.Utils.isCahier(nodeTarget) && !peutModifierCdtTarget) {
- dropAutorise = false;
- }
+ Ext.getCmp(eliot.textes.Constantes.menuContextuel.idMenuRenommerDossier).addListener({
+ click:{
+ fn:function () {
+ this.leftToolbar.actionRenommerDossier();
+ }, scope:this
+ }
+ });
+ },
+
+
+ /**
+ * Action déclenchée lors du "drag" d'un cahier ou dossier
+ * @param tree l'arbre
+ * @node la node "draggée"
+ */
+ dragAction:function (tree, node) {
+ this.oldPosition = node.parentNode.indexOf(node);
+ this.oldNextSibling = node.nextSibling;
+ },
+ /**
+ * Action déclenchée lors du drop d'une node sur une autre, permet de
+ * contrôler la validité du drop.
+ * @param event l'évènement lancé par l'arbre
+ */
+ dropAction:function (event) {
+ // NB vu que la TreeDropZone est configuree a appendOnly, event.point est toujours "append"
+ var nodeSource = event.dropNode;
+ var nodeTarget = event.target;
+ var dropAutorise = true;
+
+ // Si l'utilisateur n'a pas le droit de modifier le CDT cible
+ // ou a un accès restrient à l'application
+ var peutModifierCdtTarget =
+ event.target.attributes.peutModifierLeContenuDuCdt &&
+ !eliot.textes.Modele.isAcceesRestreint;
+
+ if (eliot.textes.Utils.isCahier(nodeTarget) && !peutModifierCdtTarget) {
+ dropAutorise = false;
+ }
- // On ne peut pas mettre les ACT/CHP ailleurs que dans un Cahier
- if ((eliot.textes.Utils.isActivite(nodeSource) ||
- eliot.textes.Utils.isChapitre(nodeSource)) &&
- !eliot.textes.Utils.isCahier(nodeTarget)) {
- dropAutorise = false;
- }
+ // On ne peut pas mettre les ACT/CHP ailleurs que dans un Cahier
+ if ((eliot.textes.Utils.isActivite(nodeSource) ||
+ eliot.textes.Utils.isChapitre(nodeSource)) &&
+ !eliot.textes.Utils.isCahier(nodeTarget)) {
+ dropAutorise = false;
+ }
- // Si la source est une activité ET la cible un dossier
- if (eliot.textes.Utils.isActivite(nodeSource) &&
- eliot.textes.Utils.isDossier(nodeTarget)) {
- dropAutorise = false;
- }
+ // Si la source est une activité ET la cible un dossier
+ if (eliot.textes.Utils.isActivite(nodeSource) &&
+ eliot.textes.Utils.isDossier(nodeTarget)) {
+ dropAutorise = false;
+ }
- // Si la source est un cdt ET la cible un cdt
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isCahier(nodeTarget)) {
- dropAutorise = false;
- }
+ // Si la source est un cdt ET la cible un cdt
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isCahier(nodeTarget)) {
+ dropAutorise = false;
+ }
- // Si la source est un cdt ET la cible un dossier
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossier(nodeTarget)) {
- dropAutorise = !(nodeSource.parentNode == nodeTarget);
- }
+ // Si la source est un cdt ET la cible un dossier
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossier(nodeTarget)) {
+ dropAutorise = !(nodeSource.parentNode == nodeTarget);
+ }
- // Si la source est un chapitre ET la cible un dossier
- if (eliot.textes.Utils.isChapitre(nodeSource) &&
- eliot.textes.Utils.isDossier(nodeTarget)) {
- dropAutorise = false;
- }
+ // Si la source est un chapitre ET la cible un dossier
+ if (eliot.textes.Utils.isChapitre(nodeSource) &&
+ eliot.textes.Utils.isDossier(nodeTarget)) {
+ dropAutorise = false;
+ }
- // on ne peut rien mettre dans les dossiers d'archivage
- if (eliot.textes.Utils.isDossier(nodeTarget) &&
- eliot.textes.Utils.isDossierArchive(nodeTarget.id)) {
- dropAutorise = false;
- }
+ // on ne peut rien mettre dans les dossiers d'archivage
+ if (eliot.textes.Utils.isDossier(nodeTarget) &&
+ eliot.textes.Utils.isDossierArchive(nodeTarget.id)) {
+ dropAutorise = false;
+ }
- // on ne peut pas déplacer les cahiers archivés
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossierArchive(nodeSource.parentNode.id)) {
- dropAutorise = false;
- }
+ // on ne peut pas déplacer les cahiers archivés
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossierArchive(nodeSource.parentNode.id)) {
+ dropAutorise = false;
+ }
- // on ne peut pas déplacer les cahiers privés dans les répertoire
- // "Mes cahiers de classe", "Cahiers de classe partage", "Cahiers prive partage"
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossierParDefaut(nodeSource.parentNode.id) &&
- eliot.textes.Utils.isDossier(nodeTarget) &&
- (
- eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id) ||
- eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
- eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
- )
- ) {
- dropAutorise = false;
- }
+ // on ne peut pas déplacer les cahiers privés dans les répertoire
+ // "Mes cahiers de classe", "Cahiers de classe partage", "Cahiers prive partage"
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossierParDefaut(nodeSource.parentNode.id) &&
+ eliot.textes.Utils.isDossier(nodeTarget) &&
+ (
+ eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
+ )
+ ) {
+ dropAutorise = false;
+ }
- // on ne peut pas déplacer les cahiers de classe dans les répertoire
- // "Mes cahiers privés", "Cahiers de classe partage", "Cahiers prive partage"
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeSource.parentNode.id) &&
- eliot.textes.Utils.isDossier(nodeTarget) &&
- (
- eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
- eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
- eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
- )
- ) {
- dropAutorise = false;
- }
+ // on ne peut pas déplacer les cahiers de classe dans les répertoire
+ // "Mes cahiers privés", "Cahiers de classe partage", "Cahiers prive partage"
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeSource.parentNode.id) &&
+ eliot.textes.Utils.isDossier(nodeTarget) &&
+ (
+ eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
+ )
+ ) {
+ dropAutorise = false;
+ }
- // on ne peut pas déplacer les cahiers de classe partage dans les répertoire
- // "Mes cahiers privés", "Mes cahiers de classe", "Cahiers prive partage"
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossierPartage(nodeSource.parentNode.id) &&
- eliot.textes.Utils.isDossier(nodeTarget) &&
- (
- eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
- eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id) ||
- eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
- )
- ) {
- dropAutorise = false;
- }
+ // on ne peut pas déplacer les cahiers de classe partage dans les répertoire
+ // "Mes cahiers privés", "Mes cahiers de classe", "Cahiers prive partage"
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossierPartage(nodeSource.parentNode.id) &&
+ eliot.textes.Utils.isDossier(nodeTarget) &&
+ (
+ eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierCahiersPrivePartage(nodeTarget.id)
+ )
+ ) {
+ dropAutorise = false;
+ }
- // on ne peut pas déplacer les cahiers privés partage dans les répertoire
- // "Mes cahiers privés", "Cahiers de classe partage", "Mes cahiers de classe"
- if (eliot.textes.Utils.isCahier(nodeSource) &&
- eliot.textes.Utils.isDossierCahiersPrivePartage(nodeSource.parentNode.id) &&
- eliot.textes.Utils.isDossier(nodeTarget) &&
- (
- eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
- eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
- eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id)
- )
- ) {
- dropAutorise = false;
- }
+ // on ne peut pas déplacer les cahiers privés partage dans les répertoire
+ // "Mes cahiers privés", "Cahiers de classe partage", "Mes cahiers de classe"
+ if (eliot.textes.Utils.isCahier(nodeSource) &&
+ eliot.textes.Utils.isDossierCahiersPrivePartage(nodeSource.parentNode.id) &&
+ eliot.textes.Utils.isDossier(nodeTarget) &&
+ (
+ eliot.textes.Utils.isDossierParDefaut(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierPartage(nodeTarget.id) ||
+ eliot.textes.Utils.isDossierMesCahiersDeClasse(nodeTarget.id)
+ )
+ ) {
+ dropAutorise = false;
+ }
- event.cancel = !dropAutorise;
- },
- /**
- * Action déclenchée lors du déplacement d'un cahier ou dossier
- * @param tree l'arbre
- * @param node la node déplacée
- * @param oldParent la node parente de celle déplacée
- * @param newParent la noode parente cible de celle déplacée
- * @param position la position parmi les fils de la node cible
- */
- deplacerAction:function (tree, node, oldParent, newParent, position) {
- // On récupère la "vieille" position (cf dragAction())
- var oldPosition = this.oldPosition;
- var oldNextSibling = this.oldNextSibling;
- // N'affiche pas l'icon d'activité au dessous de cdt quand
- // on drop une activité sur cdt (pour l'importer)
- if ((eliot.textes.Utils.isActivite(node) || eliot.textes.Utils.isChapitre(node)) &&
- eliot.textes.Utils.isCahier(newParent)) {
- newParent.removeChild(node);
- // cache l'image proxy d'item dragé
- Ext.dd.DragDropMgr.dragCurrent.proxy.hide();
+ event.cancel = !dropAutorise;
+ },
+ /**
+ * Action déclenchée lors du déplacement d'un cahier ou dossier
+ * @param tree l'arbre
+ * @param node la node déplacée
+ * @param oldParent la node parente de celle déplacée
+ * @param newParent la noode parente cible de celle déplacée
+ * @param position la position parmi les fils de la node cible
+ */
+ deplacerAction:function (tree, node, oldParent, newParent, position) {
+ // On récupère la "vieille" position (cf dragAction())
+ var oldPosition = this.oldPosition;
+ var oldNextSibling = this.oldNextSibling;
+ // N'affiche pas l'icon d'activité au dessous de cdt quand
+ // on drop une activité sur cdt (pour l'importer)
+ if ((eliot.textes.Utils.isActivite(node) || eliot.textes.Utils.isChapitre(node)) &&
+ eliot.textes.Utils.isCahier(newParent)) {
+ newParent.removeChild(node);
+ // cache l'image proxy d'item dragé
+ Ext.dd.DragDropMgr.dragCurrent.proxy.hide();
+ }
+ var afficherMsgErreur = true;
+ var url, params;
+ if (oldParent == newParent) {
+ return
+ } else {
+ url = eliot.textes.Constantes.urlCahierDeTextesDeplacer;
+ params = {'node':node.id, 'parent':newParent.id, 'oldParent':oldParent.id, 'position':position};
+ }
+ // Dans le cas d'un import vers un CDT
+ if ((oldParent != newParent) && eliot.textes.Utils.isCahier(newParent) &&
+ !eliot.textes.Utils.isCahier(node)) {
+ this.importerAction(tree, node, oldParent, newParent, position);
+ } else {
+ // Seul les dossiers peuvent être dans la racine de l'arbre des dossiers/CDT
+ if (newParent == this.treePanel.getRootNode() && !eliot.textes.Utils.isDossier(node)) {
+ if (eliot.textes.Utils.isCahier(node)) {
+ failureFunction(this, eliot.textes.Messages.cahierNoDep);
+ return;
}
- var afficherMsgErreur = true;
- var url, params;
- if (oldParent == newParent) {
- return
- } else {
- url = eliot.textes.Constantes.urlCahierDeTextesDeplacer;
- params = {'node':node.id, 'parent':newParent.id, 'oldParent':oldParent.id, 'position':position};
+ if (eliot.textes.Utils.isActivite(node)) {
+ failureFunction(this, eliot.textes.Messages.actNoDep);
+ return;
}
- // Dans le cas d'un import vers un CDT
- if ((oldParent != newParent) && eliot.textes.Utils.isCahier(newParent) &&
- !eliot.textes.Utils.isCahier(node)) {
- this.importerAction(tree, node, oldParent, newParent, position);
- } else {
- // Seul les dossiers peuvent être dans la racine de l'arbre des dossiers/CDT
- if (newParent == this.treePanel.getRootNode() && !eliot.textes.Utils.isDossier(node)) {
- if (eliot.textes.Utils.isCahier(node)) {
- failureFunction(this, eliot.textes.Messages.cahierNoDep);
- return;
- }
- if (eliot.textes.Utils.isActivite(node)) {
- failureFunction(this, eliot.textes.Messages.actNoDep);
- return;
- }
- if (eliot.textes.Utils.isChapitre(node)) {
- failureFunction(this, eliot.textes.Messages.chapNoDep);
- return;
- }
- failureFunction(this, eliot.textes.Messages.noDep);
- return;
- }
- // Ne deplace pas un CDT dans un Autre
- if (eliot.textes.Utils.isCahier(node) && eliot.textes.Utils.isCahier(newParent)) {
- failureFunction(this, eliot.textes.Messages.cahierNoDep);
- return;
- }
- // we disable tree interaction until we've heard a response from the server
- // this prevents concurrent requests which could yield unusual results
- this.treePanel.disable();
- Ext.Ajax.request({
- url:url,
- params:params,
- success:function (response, request) {
- // if the first char of our response is zero, then we fail the operation,
- // otherwise we re-enable the tree
- if (response.responseText.charAt(0) != 1) {
- var messageErreur = response.responseText.substring(1, response.responseText.length);
- failureFunction(this, messageErreur);
- } else {
- this.treePanel.enable();
- if (eliot.textes.Utils.isDossier(node)) {
- eliot.textes.Messages.showConfirmation(eliot.textes.Messages.dossierDep);
- }
- if (eliot.textes.Utils.isCahier(node)) {
- //this.trierCahierAlphabetique(node, 'deplace');
- eliot.textes.Messages.showConfirmation(eliot.textes.Messages.cahierDep);
- }
- }
- },
- failure:function (messageErreur) {
- failureFunction(this, messageErreur);
- },
- scope:this
- });
- function failureFunction(obj, messageErreur) {
- // we move the node back to where it was beforehand and
- // we suspendEvents() so that we don't get stuck in a possible infinite loop
- obj.treePanel.suspendEvents();
- oldParent.appendChild(node);
- if (oldNextSibling) {
- oldParent.insertBefore(node, oldNextSibling);
- }
- obj.treePanel.resumeEvents();
- obj.treePanel.enable();
- obj.treePanel.expandPath(oldParent.getPath());
- if (messageErreur) {
- eliot.textes.Messages.showErreur(messageErreur);
- }
- else {
- if (afficherMsgErreur && eliot.textes.Utils.isDossier(node)) {
- eliot.textes.Messages.showErreur(eliot.textes.Messages.dossierNoDep);
- }
- if (afficherMsgErreur && eliot.textes.Utils.isCahier(node)) {
- eliot.textes.Messages.showErreur(eliot.textes.Messages.cahierNoDep);
- }
- }
- }
+ if (eliot.textes.Utils.isChapitre(node)) {
+ failureFunction(this, eliot.textes.Messages.chapNoDep);
+ return;
}
- // Evite que l'arbre reste grisé
- this.treePanel.enable();
- },
- /**
- * Action d'import d'une activité vers un cahier.
- * @param tree l'arbre cible
- * @param node la node correspondant à l'activité
- * @param oldParent l'ancienne node parente
- * @param newParent la nouvelle node parente
- * @param position la position parmi les fils
- */
- importerAction:function (tree, node, oldParent, newParent, position) {
-
- // Recharge l'arbre source
- oldParent.reload();
-
- eliot.textes.Messages.afficherDialogConfirmation(
- 'Importation',
- 'Vous êtes sur le point de faire un import vers un cahier de texte, ' +
- 'Voulez-vous continuer ?',
- this.executerImporter.createDelegate(this),
- null,
- { node:node, newParent:newParent, position:position });
- },
-
- executerImporter:function (args) {
- var newParent = args.newParent;
- var url = eliot.textes.Constantes.urlCahierDeTextesImporter;
- var params = {
- 'node':args.node.id,
- 'parent':'c' + eliot.textes.Utils.getIdFromNode(newParent),
- 'delta':(args.position - this.oldPosition)
- };
-
- Ext.Ajax.request({
- url:url,
- params:params,
- scope:this,
- success:function () {
- // on balance un évènement p
- // our que l'arbre des activités
- // correspondant au cahier cible soit reloadé
- this.fireEvent(this.importDansCahierEvent, args.newParent);
- var message = 'L\'activité a été importée avec succès';
- if (eliot.textes.Utils.isChapitre(args.node))
- message = 'Le chapitre a été importé avec succès'
- eliot.textes.Messages.showConfirmation(message);
- },
- failure:function () {
- eliot.textes.Messages.showErreur('L\'import a échoué');
+ failureFunction(this, eliot.textes.Messages.noDep);
+ return;
+ }
+ // Ne deplace pas un CDT dans un Autre
+ if (eliot.textes.Utils.isCahier(node) && eliot.textes.Utils.isCahier(newParent)) {
+ failureFunction(this, eliot.textes.Messages.cahierNoDep);
+ return;
+ }
+ // we disable tree interaction until we've heard a response from the server
+ // this prevents concurrent requests which could yield unusual results
+ this.treePanel.disable();
+ Ext.Ajax.request({
+ url:url,
+ params:params,
+ success:function (response, request) {
+ // if the first char of our response is zero, then we fail the operation,
+ // otherwise we re-enable the tree
+ if (response.responseText.charAt(0) != 1) {
+ var messageErreur = response.responseText.substring(1, response.responseText.length);
+ failureFunction(this, messageErreur);
+ } else {
+ this.treePanel.enable();
+ if (eliot.textes.Utils.isDossier(node)) {
+ eliot.textes.Messages.showConfirmation(eliot.textes.Messages.dossierDep);
}
- });
- },
- /**
- * Action déclenchée lors du click sure node, cette action ne fait que
- * lancer un évènement, à traiter par le parent.
- * @param node la node clickée
- */
- clickAction:function (node) {
- if (eliot.textes.Utils.isCahier(node)) {
- // On lance un évènement disant qu'un cahier est sélectionné
- this.fireEvent(this.selectionCahierEvent, node);
+ if (eliot.textes.Utils.isCahier(node)) {
+ //this.trierCahierAlphabetique(node, 'deplace');
+ eliot.textes.Messages.showConfirmation(eliot.textes.Messages.cahierDep);
+ }
+ }
+ },
+ failure:function (messageErreur) {
+ failureFunction(this, messageErreur);
+ },
+ scope:this
+ });
+ function failureFunction(obj, messageErreur) {
+ // we move the node back to where it was beforehand and
+ // we suspendEvents() so that we don't get stuck in a possible infinite loop
+ obj.treePanel.suspendEvents();
+ oldParent.appendChild(node);
+ if (oldNextSibling) {
+ oldParent.insertBefore(node, oldNextSibling);
}
- else if (eliot.textes.Utils.isDossier(node)) {
- // On lance un évènement disant qu'un dossier est sélectionné
- this.fireEvent(this.selectionDossierEvent, node);
+ obj.treePanel.resumeEvents();
+ obj.treePanel.enable();
+ obj.treePanel.expandPath(oldParent.getPath());
+ if (messageErreur) {
+ eliot.textes.Messages.showErreur(messageErreur);
}
- },
- /**
- * Action délenchée lors du "déroulage" d'un dossier.
- * @param node la node clickée
- */
- deroulerAction:function (node) {
- // Rien pour l'instant
- },
- /**
- * Méthode permettant d'ajouter un dossier dans l'arbre
- * @param nodeId l'id de la node à ajouter
- * @param text le nom de la node
- */
- ajoutDossier:function (nodeId, text) {
- var newNode = new Ext.tree.AsyncTreeNode({
- text:text,
- leaf:false,
- expandable: true,
- allowDrag:false,
- id:nodeId
- });
- var insertedNode = this.treePanel.getRootNode().appendChild(newNode);
- this.treePanel.getSelectionModel().select(insertedNode);
- },
-
-
- selectTreeNodeCdt:function (treeNode, selectedNode) {
-
- // Sélectionne le cdt fournit dans la config
- if (treeNode.id == selectedNode) {
- treeNode.select();
- //On lance un évènement disant qu'un cahier est sélectionné
- this.fireEvent(this.selectionCahierEvent, treeNode)
+ else {
+ if (afficherMsgErreur && eliot.textes.Utils.isDossier(node)) {
+ eliot.textes.Messages.showErreur(eliot.textes.Messages.dossierNoDep);
+ }
+ if (afficherMsgErreur && eliot.textes.Utils.isCahier(node)) {
+ eliot.textes.Messages.showErreur(eliot.textes.Messages.cahierNoDep);
+ }
}
- },
-
- isCurrentCdtAsContextMenuSelected:function () {
- var currentCdtSelected = this.treePanel.
- getSelectionModel().selNode.attributes.id;
- return (this.noeudArbreSelectionne.id == currentCdtSelected)
- },
-
- contextMenuEventAction:function (node, event) {
- this.fireEvent(this.contextMenuEvent,
- node,
- event
- );
- },
-
- proprietesEventAction:function () {
- this.fireEvent(this.proprietesEvent)
+ }
+ }
+ // Evite que l'arbre reste grisé
+ this.treePanel.enable();
+ },
+ /**
+ * Action d'import d'une activité vers un cahier.
+ * @param tree l'arbre cible
+ * @param node la node correspondant à l'activité
+ * @param oldParent l'ancienne node parente
+ * @param newParent la nouvelle node parente
+ * @param position la position parmi les fils
+ */
+ importerAction:function (tree, node, oldParent, newParent, position) {
+
+ // Recharge l'arbre source
+ oldParent.reload();
+
+ eliot.textes.Messages.afficherDialogConfirmation(
+ 'Importation',
+ 'Vous êtes sur le point de faire un import vers un cahier de texte, ' +
+ 'Voulez-vous continuer ?',
+ this.executerImporter.createDelegate(this),
+ null,
+ { node:node, newParent:newParent, position:position });
+ },
+
+ executerImporter:function (args) {
+ var newParent = args.newParent;
+ var url = eliot.textes.Constantes.urlCahierDeTextesImporter;
+ var params = {
+ 'node':args.node.id,
+ 'parent':'c' + eliot.textes.Utils.getIdFromNode(newParent),
+ 'delta':(args.position - this.oldPosition)
+ };
+
+ Ext.Ajax.request({
+ url:url,
+ params:params,
+ scope:this,
+ success:function () {
+ // on balance un évènement p
+ // our que l'arbre des activités
+ // correspondant au cahier cible soit reloadé
+ this.fireEvent(this.importDansCahierEvent, args.newParent);
+ var message = 'L\'activité a été importée avec succès';
+ if (eliot.textes.Utils.isChapitre(args.node))
+ message = 'Le chapitre a été importé avec succès'
+ eliot.textes.Messages.showConfirmation(message);
+ },
+ failure:function () {
+ eliot.textes.Messages.showErreur('L\'import a échoué');
+ }
+ });
+ },
+ /**
+ * Action déclenchée lors du click sure node, cette action ne fait que
+ * lancer un évènement, à traiter par le parent.
+ * @param node la node clickée
+ */
+ clickAction:function (node) {
+ if (eliot.textes.Utils.isCahier(node)) {
+ // On lance un évènement disant qu'un cahier est sélectionné
+ this.fireEvent(this.selectionCahierEvent, node);
+ }
+ else if (eliot.textes.Utils.isDossier(node)) {
+ // On lance un évènement disant qu'un dossier est sélectionné
+ this.fireEvent(this.selectionDossierEvent, node);
+ }
+ },
+ /**
+ * Action délenchée lors du "déroulage" d'un dossier.
+ * @param node la node clickée
+ */
+ deroulerAction:function (node) {
+ // Rien pour l'instant
+ },
+ /**
+ * Méthode permettant d'ajouter un dossier dans l'arbre
+ * @param nodeId l'id de la node à ajouter
+ * @param text le nom de la node
+ */
+ ajoutDossier:function (nodeId, text) {
+ var newNode = new Ext.tree.AsyncTreeNode({
+ text:text,
+ leaf:false,
+ expandable: true,
+ allowDrag:false,
+ id:nodeId
+ });
+ var insertedNode = this.treePanel.getRootNode().appendChild(newNode);
+ this.treePanel.getSelectionModel().select(insertedNode);
+ },
+
+
+ selectTreeNodeCdt:function (treeNode, selectedNode) {
+
+ // Sélectionne le cdt fournit dans la config
+ if (treeNode.id == selectedNode) {
+ treeNode.select();
+ //On lance un évènement disant qu'un cahier est sélectionné
+ this.fireEvent(this.selectionCahierEvent, treeNode)
}
+ },
+
+ isCurrentCdtAsContextMenuSelected:function () {
+ var currentCdtSelected = this.treePanel.
+ getSelectionModel().selNode.attributes.id;
+ return (this.noeudArbreSelectionne.id == currentCdtSelected)
+ },
+
+ contextMenuEventAction:function (node, event) {
+ this.fireEvent(this.contextMenuEvent,
+ node,
+ event
+ );
+ },
+
+ proprietesEventAction:function () {
+ this.fireEvent(this.proprietesEvent)
+ }
});
Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonRenommerDossier);
this.menuSupprimerDossier =
Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonSupprimerDossier);
+ this.menuAfficherCahiersMasques =
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonAfficherCahiersMasques);
};
/**
*
this.menuProprietesCahier.disable();
this.menuImprimerCahier.disable();
this.menuSupprimerCahier.disable();
+ this.menuAfficherCahiersMasques.disable();
if (eliot.textes.Utils.isDossierSysteme(node.id)) {
this.menuRenommerDossier.disable();
this.menuSupprimerDossier.disable();
this.menuRenommerDossier.enable();
this.menuSupprimerDossier.enable();
}
+ if (eliot.textes.Modele.isDirectionOuADML &&
+ eliot.textes.Utils.isDossierPartage(node.id) &&
+ eliot.textes.Modele.contientCdtMasque){
+ this.menuAfficherCahiersMasques.enable();
+ }
};
/**
this.menuSupprimerCahier.disable();
this.menuRenommerDossier.disable();
this.menuSupprimerDossier.disable();
+ this.menuAfficherCahiersMasques.disable();
//var monNode = folderPanel.getNodeById(nodeId);
if (nodeCahier) {
eliot.textes.FonctionnaliteActivateur.prototype.actionDeselectionDossier = function() {
this.menuRenommerDossier.disable();
this.menuSupprimerDossier.disable();
+ this.menuAfficherCahiersMasques.disable();
+ this.menuAfficherCahiersMasques.disable();
};
/**
* Activité sélectionnée
// Ajoute les constantes propres à la toolbar ---------------------------------
eliot.textes.Constantes.leftToolbar = {
- idLeftToolBar:'toolBarL',
- idBoutonCreer:'bCreation',
- idBoutonCreerCahier:'bCreationCahier',
- idBoutonProprietesCahier:'proprietesCahierDeTexte',
- idBoutonImprimerCahier:'imprimerCahierDeTexte',
- idBoutonSupprimerCahier:'supprimerCahierDeTexte',
- idBoutonCreerDossier:'creationDossier',
- idBoutonRenommerDossier:'renommerDossier',
- idBoutonSupprimerDossier:'supprimerDossier',
- idBoutonSuivreImpressions:'suivreImpressions'
+ idLeftToolBar:'toolBarL',
+ idBoutonCreer:'bCreation',
+ idBoutonCreerCahier:'bCreationCahier',
+ idBoutonProprietesCahier:'proprietesCahierDeTexte',
+ idBoutonImprimerCahier:'imprimerCahierDeTexte',
+ idBoutonSupprimerCahier:'supprimerCahierDeTexte',
+ idBoutonCreerDossier:'creationDossier',
+ idBoutonRenommerDossier:'renommerDossier',
+ idBoutonSupprimerDossier:'supprimerDossier',
+ idBoutonAfficherCahiersMasques:'afficherCahiersMasques',
+ idBoutonSuivreImpressions:'suivreImpressions'
};
eliot.textes.LeftToolBar = Ext.extend(Ext.util.Observable, {
- constructor:function (config) {
-
- this.dialogueImpression = config.dialogueImpression;
- this.observeImpressionView(this.dialogueImpression);
-
- this.toolbar = new Ext.Toolbar({
- border:false,
- autoWidth:true,
- height:36,
- id:eliot.textes.Constantes.leftToolbar.idLeftToolBar,
- items:[
- {
- id:eliot.textes.Constantes.leftToolbar.idBoutonCreer,
- xtype:'button',
- text:'Créer',
- icon:'../images/add16x16.gif',
- disabled:eliot.textes.Modele.isAcceesRestreint,
- menu:[
- {
- text:'Cahier de textes',
- cls:'x-btn-icon',
- icon:'../images/add16x16.gif',
- id:eliot.textes.Constantes.leftToolbar.idBoutonCreerCahier,
- disabled:eliot.textes.Constantes.desactiverCreationCdt
- },
-
- {
- text:'Dossier',
- cls:'x-btn-icon',
- icon:'../images/add16x16.gif',
- id:eliot.textes.Constantes.leftToolbar.idBoutonCreerDossier
- }
- ]
- },
- {
- xtype:'button',
- text:'Autres actions',
- menu:[
- {
- text:'Propriétés du cahier de textes',
- cls:'x-btn-icon',
- icon:'../images/info.png',
- id:eliot.textes.Constantes.leftToolbar.idBoutonProprietesCahier,
- disabled:true
- },
- {
- text:'Imprimer le cahier de textes',
- cls:'x-btn-icon',
- icon:'../images/printpreview.png',
- id:eliot.textes.Constantes.leftToolbar.idBoutonImprimerCahier,
- disabled:true
- },
- {
- text:'Supprimer un cahier de textes',
- cls:'x-btn-icon',
- icon:'../images/delete.gif',
- id:eliot.textes.Constantes.leftToolbar.idBoutonSupprimerCahier,
- disabled:true
- },
- {
- text:'Renommer le dossier',
- cls:'x-btn-icon',
- icon:'../images/edit.png',
- id:eliot.textes.Constantes.leftToolbar.idBoutonRenommerDossier,
- disabled:true
- },
- {
- text:'Supprimer le dossier',
- cls:'x-btn-icon',
- icon:'../images/delete.gif',
- id:eliot.textes.Constantes.leftToolbar.idBoutonSupprimerDossier,
- disabled:true
- }
- ]
- }
- ]
- });
- // Ajout des évènements persos
- this.suppressionCahierEvent = 'suppressionCahierEvent';
- this.echecSuppressionCahierEvent = 'echecSuppressionCahierEvent';
- this.creationDossierEvent = 'creationDossierEvent';
- this.suppressionDossierEvent = 'suppressionDossierEvent';
- this.addEvents(this.suppressionCahierEvent,
- this.echecSuppressionCahierEvent,
- this.creationDossierEvent,
- this.suppressionDossierEvent);
- this.listeners = config.listeners;
- this.observeToolbar();
- },
-
- observeToolbar:function () {
- // Observe le menu "Créer un cahier de textes"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonCreerCahier).addListener({
- click:{
- fn:function () {
- this.actionCreerCahier();
- },
- scope:this
- }
- });
- // Observe le menu "Propriétés d'un cahier de textes"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonProprietesCahier).addListener({
- click:{
- fn:function () {
- this.actionProprietesCahier();
- },
- scope:this
- }
- });
- // Observe le menu "Imprimer un cahier de textes"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonImprimerCahier).addListener({
- click:{
- fn:function () {
- this.actionImprimerCahier();
- },
- scope:this
- }
- });
- // Observe le menu "Supprimer un cahier de textes"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonSupprimerCahier).addListener({
- click:{
- fn:function () {
- this.actionSupprimerCahier(true);
- },
- scope:this
- }
- });
- // Observe le menu "Créer un dossier"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonCreerDossier).addListener({
- click:{
- fn:function () {
- this.actionCreerDossier();
- },
- scope:this
- }
- });
- // Observe le menu "Renommer un dossier"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonRenommerDossier).addListener({
- click:{
- fn:function () {
- this.actionRenommerDossier();
- },
- scope:this
- }
- });
- // Observe le menu "Supprimer un dossier"
- Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonSupprimerDossier).addListener({
- click:{
- fn:function () {
- this.actionSupprimerDossier();
- },
- scope:this
- }
- });
- },
-
- /**
- * Méthode destinée à être appelée de l'extérieur pour passer la node
- * sélectionnée dans le tree folder.
- */
- // TOREFACT : refactoring cette méthode : supprmier et utiliser dans GestionnaireCdt
- setNodeSelectionnee:function (node) {
- this.nodeSelectionnee = node;
- },
-
- /**
- * Action appelée lors de la création d'un cahier de textes.
- */
- actionCreerCahier:function () {
- document.location.href = eliot.textes.Constantes.urlCahierDeTextesCreer;
- },
-
- /**
- * Action appelée lors du click sur le menu "Propriétés d'un cahier"
- */
- // TOREFACT : refactoring cette méthode: supprmier et utiliser dans GestionnaireCdt
- actionProprietesCahier:function () {
- var node = this.nodeSelectionnee;
- var idCdt = eliot.textes.Utils.getIdFromNode(node);
- var url = eliot.textes.Constantes.urlCahierDeTextesProprietes;
- url = url + '?id=' + idCdt;
- document.location.href = url;
- },
-
- /**
- * Action appelée lors du click sur le menu "Imprimer cahier"
- */
- actionImprimerCahier:function () {
-
- var node = this.nodeSelectionnee;
-
- var idCdt = eliot.textes.Utils.getIdFromNode(node);
-
- // on lance ici la boite de dialogue
- this.dialogueImpression.afficherWindowSelectionActiviteView(idCdt);
- },
-
- /**
- * Action appelée lors du click sur le menu "Suprimer cahier"
- */
- actionSupprimerCahier:function (isCurrentCdtAsContextMenuSelected) {
- var node = this.nodeSelectionnee;
- eliot.textes.Messages.afficherDialogConfirmation(
- 'Supprimer le cahier de textes ?',
- 'Êtes-vous sûr de vouloir supprimer le cahier de textes : ' + node.text + ' ? '
- + 'Attention, cette opération supprimera toutes les activités et chapitres de ce cahier de textes.',
-
- this.executerSupprimerCahier.createDelegate(this),
- null,
- isCurrentCdtAsContextMenuSelected
- );
- },
-
- /**
- * Action déclenchée lors de la création d'un dossier
- */
- actionCreerDossier:function () {
- eliot.textes.Messages.afficherDialogSaisie(
- 'Ajouter un dossier',
- 'Nom du dossier:',
- this.executerCreerDossier.createDelegate(this));
-
- },
-
- // Renommer un dossier
- actionRenommerDossier:function () {
- eliot.textes.Messages.afficherDialogSaisie(
- 'Renommer un dossier',
- 'Nouveau nom du dossier:',
- this.executerRenommerDossier.createDelegate(this),
- null,
- this.nodeSelectionnee.text);
- },
-
- actionSupprimerDossier:function () {
- var node = this.nodeSelectionnee;
- eliot.textes.Messages.afficherDialogConfirmation(
- 'Supprimer le dossier ?',
- 'Êtes-vous sûr de vouloir supprimer le dossier : ' + node.text,
- this.executerSupprimerDossier.createDelegate(this)
- );
- },
-
-
-
- observeImpressionView:function (impressionView) {
-
- impressionView.addListener(
- eliot.textes.Constantes.actionImpression,
-
- function (idCdt, dateDebut, dateFin, chapitreSansActivite) {
-
- var url = eliot.textes.Constantes.urlCahierDeTextesImprimer;
-
- var params = {
- ids:idCdt,
- dateDebut:dateDebut.format("d/m/Y"),
- dateFin:dateFin.format("d/m/Y"),
- chapitreSansActivite:chapitreSansActivite
- };
-
- Ext.Ajax.request({
- url:url,
- params:params,
- success:function (response, request) {
- var reponse = Ext.decode(response.responseText);
- if (reponse.success == true) {
- var url = eliot.textes.Constantes.urlGetImpressionPdf+'?demandeId=' + reponse.demandeId;
-
- // Les scrollbars ne sont pas affichés. Pour qoui ? On ne sait pas :(
- window.open(url, "_blank", "height=600, width=800, toolbar=no,menubar=no,scrollbars=yes");
-
-
- } else {
- if (reponse.message) {
- eliot.textes.Messages.showErreur(reponse.message);
- }
- else {
- request.failure.call(this);
- }
- }
- },
- scope:this,
- failure:function () {
- eliot.textes.Messages.showErreur(
- eliot.textes.Modele.message.ajoutDemandeImpressionErreur
- );
- }
- });
- }
- );
-
- },
-
- executerSupprimerCahier:function (isCurrentCdtAsContextMenuSelected) {
- var node = this.nodeSelectionnee;
- // Affichage de la progresse bar
- var mask = new Ext.LoadMask(
- Ext.getBody(),
- {
- msg:eliot.textes.Modele.message.suppressionEnCours
- });
- mask.show();
-
- Ext.Ajax.request({
- url:eliot.textes.Constantes.urlCahierDeTextesSupprimer,
- params:{ node:node.id },
- scope:this,
- success:function (response, request) {
- // On masque le sablier
- mask.hide();
- if (response.responseText.charAt(0) != 1) {
- request.failure();
- } else {
- node.remove();
- eliot.textes.Messages.showConfirmation(
- 'Le cahier de textes ' + node.text + ' a été supprimé');
- // On lance un évènement pour que le "parent"
- // manipule éventuellement les autres composants
- this.fireEvent(this.suppressionCahierEvent,
- node,
- isCurrentCdtAsContextMenuSelected
- );
- }
+ constructor:function (config) {
+
+ this.dialogueImpression = config.dialogueImpression;
+ this.observeImpressionView(this.dialogueImpression);
+
+ this.toolbar = new Ext.Toolbar({
+ border:false,
+ autoWidth:true,
+ height:36,
+ id:eliot.textes.Constantes.leftToolbar.idLeftToolBar,
+ items:[
+ {
+ id:eliot.textes.Constantes.leftToolbar.idBoutonCreer,
+ xtype:'button',
+ text:'Créer',
+ icon:'../images/add16x16.gif',
+ disabled:eliot.textes.Modele.isAcceesRestreint,
+ menu:[
+ {
+ text:'Cahier de textes',
+ cls:'x-btn-icon',
+ icon:'../images/add16x16.gif',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonCreerCahier,
+ disabled:eliot.textes.Constantes.desactiverCreationCdt
},
- failure:function () {
- // On masque le sablier
- mask.hide();
- // Help ! on dirait que "this" ici n'a pas l'air d'être celui
- // de leftToolbar ! pourtant le paramètre scope:this est censé
- //this.fireEvent(this.echecSuppressionCahierEvent, node);
- eliot.textes.Messages.showErreur(
- 'Le cahier de textes ' + node.text + ' n\'est pas vide. Il n\'a pas pu être supprimé');
- }
- });
- },
- executerCreerDossier:function (text) {
- Ext.Ajax.request({
- url:eliot.textes.Constantes.urlDossierCreer,
- params:{ nom:text },
- scope:this,
- success:function (response, request) {
- var retour = Ext.decode(response.responseText);
- if (!retour.success) {
- request.failure();
- } else {
- // Récupère l'id du dossier créer
- var nodeId = 'd' + retour.id;
- var nom = retour.nom;
- eliot.textes.Messages.showConfirmation('Le dossier ' + nom + ' a été créé');
- this.fireEvent(this.creationDossierEvent, nodeId, nom);
- }
- },
- failure:function () {
- eliot.textes.Messages.showErreur('Le dossier n\'a pas pu être créé');
+ {
+ text:'Dossier',
+ cls:'x-btn-icon',
+ icon:'../images/add16x16.gif',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonCreerDossier
}
- });
- },
-
- executerRenommerDossier:function (text) {
- var node = this.nodeSelectionnee;
- // appeler la création de dossier
- var ancienNom = node.text;
- Ext.Ajax.request({
- url:eliot.textes.Constantes.urlDossierRenommer,
- params:{ nom:text, node:node.id },
- success:function (response, request) {
- if (response.responseText.charAt(0) != 1) {
- request.failure();
- } else {
- node.setText(text);
- eliot.textes.Messages.showConfirmation(
- 'Le dossier ' + ancienNom + ' a été renommé en ' + text);
- }
+ ]
+ },
+ {
+ xtype:'button',
+ text:'Autres actions',
+ menu:[
+ {
+ text:'Propriétés du cahier de textes',
+ cls:'x-btn-icon',
+ icon:'../images/info.png',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonProprietesCahier,
+ disabled:true
},
- failure:function () {
- eliot.textes.Messages.showErreur(
- 'Le dossier ' + node.text + ' n\'a pas pu être renommé');
+ {
+ text:'Imprimer le cahier de textes',
+ cls:'x-btn-icon',
+ icon:'../images/printpreview.png',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonImprimerCahier,
+ disabled:true
+ },
+ {
+ text:'Supprimer un cahier de textes',
+ cls:'x-btn-icon',
+ icon:'../images/delete.gif',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonSupprimerCahier,
+ disabled:true
+ },
+ {
+ text:'Renommer le dossier',
+ cls:'x-btn-icon',
+ icon:'../images/edit.png',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonRenommerDossier,
+ disabled:true
+ },
+ {
+ text:'Supprimer le dossier',
+ cls:'x-btn-icon',
+ icon:'../images/delete.gif',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonSupprimerDossier,
+ disabled:true
+ },
+ {
+ text:'Afficher les cahiers de textes masqués',
+ cls:'x-btn-icon',
+ id:eliot.textes.Constantes.leftToolbar.idBoutonAfficherCahiersMasques,
+ disabled:true
}
- });
- },
-
- executerSupprimerDossier:function () {
- var node = this.nodeSelectionnee;
- // appeler la suppression de dossier
- Ext.Ajax.request({
- url:eliot.textes.Constantes.urlDossierSupprimer,
- params:{ node:node.id },
- scope:this,
+ ]
+ }
+ ]
+ });
+ // Ajout des évènements persos
+ this.suppressionCahierEvent = 'suppressionCahierEvent';
+ this.echecSuppressionCahierEvent = 'echecSuppressionCahierEvent';
+ this.creationDossierEvent = 'creationDossierEvent';
+ this.suppressionDossierEvent = 'suppressionDossierEvent';
+ this.addEvents(this.suppressionCahierEvent,
+ this.echecSuppressionCahierEvent,
+ this.creationDossierEvent,
+ this.suppressionDossierEvent);
+ this.listeners = config.listeners;
+
+ this.creePopupAfficherCahiersMasques();
+
+ this.observeToolbar();
+ },
+
+ observeToolbar:function () {
+ // Observe le menu "Créer un cahier de textes"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonCreerCahier).addListener({
+ click:{
+ fn:function () {
+ this.actionCreerCahier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Propriétés d'un cahier de textes"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonProprietesCahier).addListener({
+ click:{
+ fn:function () {
+ this.actionProprietesCahier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Imprimer un cahier de textes"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonImprimerCahier).addListener({
+ click:{
+ fn:function () {
+ this.actionImprimerCahier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Supprimer un cahier de textes"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonSupprimerCahier).addListener({
+ click:{
+ fn:function () {
+ this.actionSupprimerCahier(true);
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Créer un dossier"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonCreerDossier).addListener({
+ click:{
+ fn:function () {
+ this.actionCreerDossier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Renommer un dossier"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonRenommerDossier).addListener({
+ click:{
+ fn:function () {
+ this.actionRenommerDossier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Supprimer un dossier"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonSupprimerDossier).addListener({
+ click:{
+ fn:function () {
+ this.actionSupprimerDossier();
+ },
+ scope:this
+ }
+ });
+ // Observe le menu "Afficher les cahiers de textes masqués"
+ Ext.getCmp(eliot.textes.Constantes.leftToolbar.idBoutonAfficherCahiersMasques).addListener({
+ click:{
+ fn:function () {
+ this.actionAfficherCahiersMasques();
+ },
+ scope:this
+ }
+ });
+ },
+
+ /**
+ * Méthode destinée à être appelée de l'extérieur pour passer la node
+ * sélectionnée dans le tree folder.
+ */
+ // TOREFACT : refactoring cette méthode : supprmier et utiliser dans GestionnaireCdt
+ setNodeSelectionnee:function (node) {
+ this.nodeSelectionnee = node;
+ },
+
+ /**
+ * Action appelée lors de la création d'un cahier de textes.
+ */
+ actionCreerCahier:function () {
+ document.location.href = eliot.textes.Constantes.urlCahierDeTextesCreer;
+ },
+
+ /**
+ * Action appelée lors du click sur le menu "Propriétés d'un cahier"
+ */
+ // TOREFACT : refactoring cette méthode: supprmier et utiliser dans GestionnaireCdt
+ actionProprietesCahier:function () {
+ var node = this.nodeSelectionnee;
+ var idCdt = eliot.textes.Utils.getIdFromNode(node);
+ var url = eliot.textes.Constantes.urlCahierDeTextesProprietes;
+ url = url + '?id=' + idCdt;
+ document.location.href = url;
+ },
+
+ /**
+ * Action appelée lors du click sur le menu "Imprimer cahier"
+ */
+ actionImprimerCahier:function () {
+
+ var node = this.nodeSelectionnee;
+
+ var idCdt = eliot.textes.Utils.getIdFromNode(node);
+
+ // on lance ici la boite de dialogue
+ this.dialogueImpression.afficherWindowSelectionActiviteView(idCdt);
+ },
+
+ /**
+ * Action appelée lors du click sur le menu "Suprimer cahier"
+ */
+ actionSupprimerCahier:function (isCurrentCdtAsContextMenuSelected) {
+ var node = this.nodeSelectionnee;
+ eliot.textes.Messages.afficherDialogConfirmation(
+ 'Supprimer le cahier de textes ?',
+ 'Êtes-vous sûr de vouloir supprimer le cahier de textes : ' + node.text + ' ? '
+ + 'Attention, cette opération supprimera toutes les activités et chapitres de ce cahier de textes.',
+
+ this.executerSupprimerCahier.createDelegate(this),
+ null,
+ isCurrentCdtAsContextMenuSelected
+ );
+ },
+
+ /**
+ * Action déclenchée lors de la création d'un dossier
+ */
+ actionCreerDossier:function () {
+ eliot.textes.Messages.afficherDialogSaisie(
+ 'Ajouter un dossier',
+ 'Nom du dossier:',
+ this.executerCreerDossier.createDelegate(this));
+
+ },
+
+ // Renommer un dossier
+ actionRenommerDossier:function () {
+ eliot.textes.Messages.afficherDialogSaisie(
+ 'Renommer un dossier',
+ 'Nouveau nom du dossier:',
+ this.executerRenommerDossier.createDelegate(this),
+ null,
+ this.nodeSelectionnee.text);
+ },
+
+ actionSupprimerDossier:function () {
+ var node = this.nodeSelectionnee;
+ eliot.textes.Messages.afficherDialogConfirmation(
+ 'Supprimer le dossier ?',
+ 'Êtes-vous sûr de vouloir supprimer le dossier : ' + node.text,
+ this.executerSupprimerDossier.createDelegate(this)
+ );
+ },
+
+ actionAfficherCahiersMasques:function () {
+ this.popupAfficherCahiersMasques.show();
+ },
+
+
+
+ observeImpressionView:function (impressionView) {
+
+ impressionView.addListener(
+ eliot.textes.Constantes.actionImpression,
+
+ function (idCdt, dateDebut, dateFin, chapitreSansActivite) {
+
+ var url = eliot.textes.Constantes.urlCahierDeTextesImprimer;
+
+ var params = {
+ ids:idCdt,
+ dateDebut:dateDebut.format("d/m/Y"),
+ dateFin:dateFin.format("d/m/Y"),
+ chapitreSansActivite:chapitreSansActivite
+ };
+
+ Ext.Ajax.request({
+ url:url,
+ params:params,
success:function (response, request) {
- if (response.responseText.charAt(0) != 1) {
- request.failure();
- } else {
- node.remove();
- eliot.textes.Messages.showConfirmation(
- 'Le dossier ' + node.text + ' a été supprimé');
- this.fireEvent(this.suppressionDossierEvent, node);
+ var reponse = Ext.decode(response.responseText);
+ if (reponse.success == true) {
+ var url = eliot.textes.Constantes.urlGetImpressionPdf+'?demandeId=' + reponse.demandeId;
+
+ // Les scrollbars ne sont pas affichés. Pour qoui ? On ne sait pas :(
+ window.open(url, "_blank", "height=600, width=800, toolbar=no,menubar=no,scrollbars=yes");
+
+
+ } else {
+ if (reponse.message) {
+ eliot.textes.Messages.showErreur(reponse.message);
+ }
+ else {
+ request.failure.call(this);
}
+ }
},
+ scope:this,
failure:function () {
- eliot.textes.Messages.showErreur(
- 'Le dossier ' + node.text + ' n\'est pas vide. Il n\'a pas pu être supprimé');
+ eliot.textes.Messages.showErreur(
+ eliot.textes.Modele.message.ajoutDemandeImpressionErreur
+ );
}
+ });
+ }
+ );
+
+ },
+
+ executerSupprimerCahier:function (isCurrentCdtAsContextMenuSelected) {
+ var node = this.nodeSelectionnee;
+ // Affichage de la progresse bar
+ var mask = new Ext.LoadMask(
+ Ext.getBody(),
+ {
+ msg:eliot.textes.Modele.message.suppressionEnCours
});
- },
-
- // activer le bouton "créer"
- activerBoutonCreer:function () {
- var boutonCreer = Ext.getCmp(eliot.textes.Constantes.leftToolbar.
- idBoutonCreer);
- boutonCreer.enable();
-
- },
-
- // desactiver le bouton "créer"
- desactiverBoutonCreer:function () {
- var boutonCreer = Ext.getCmp(eliot.textes.Constantes.leftToolbar.
- idBoutonCreer);
- boutonCreer.disable();
+ mask.show();
+
+ Ext.Ajax.request({
+ url:eliot.textes.Constantes.urlCahierDeTextesSupprimer,
+ params:{ node:node.id },
+ scope:this,
+ success:function (response, request) {
+ // On masque le sablier
+ mask.hide();
+ if (response.responseText.charAt(0) != 1) {
+ request.failure();
+ } else {
+ node.remove();
+ eliot.textes.Messages.showConfirmation(
+ 'Le cahier de textes ' + node.text + ' a été supprimé');
+ // On lance un évènement pour que le "parent"
+ // manipule éventuellement les autres composants
+ this.fireEvent(this.suppressionCahierEvent,
+ node,
+ isCurrentCdtAsContextMenuSelected
+ );
+ }
+ },
+ failure:function () {
+ // On masque le sablier
+ mask.hide();
+ // Help ! on dirait que "this" ici n'a pas l'air d'être celui
+ // de leftToolbar ! pourtant le paramètre scope:this est censé
+ //this.fireEvent(this.echecSuppressionCahierEvent, node);
+ eliot.textes.Messages.showErreur(
+ 'Le cahier de textes ' + node.text + ' n\'est pas vide. Il n\'a pas pu être supprimé');
+ }
+ });
+ },
+
+ executerCreerDossier:function (text) {
+ Ext.Ajax.request({
+ url:eliot.textes.Constantes.urlDossierCreer,
+ params:{ nom:text },
+ scope:this,
+ success:function (response, request) {
+ var retour = Ext.decode(response.responseText);
+ if (!retour.success) {
+ request.failure();
+ } else {
+ // Récupère l'id du dossier créer
+ var nodeId = 'd' + retour.id;
+ var nom = retour.nom;
+ eliot.textes.Messages.showConfirmation('Le dossier ' + nom + ' a été créé');
+ this.fireEvent(this.creationDossierEvent, nodeId, nom);
+ }
+ },
+ failure:function () {
+ eliot.textes.Messages.showErreur('Le dossier n\'a pas pu être créé');
+ }
+ });
+ },
+
+ executerRenommerDossier:function (text) {
+ var node = this.nodeSelectionnee;
+ // appeler la création de dossier
+ var ancienNom = node.text;
+ Ext.Ajax.request({
+ url:eliot.textes.Constantes.urlDossierRenommer,
+ params:{ nom:text, node:node.id },
+ success:function (response, request) {
+ if (response.responseText.charAt(0) != 1) {
+ request.failure();
+ } else {
+ node.setText(text);
+ eliot.textes.Messages.showConfirmation(
+ 'Le dossier ' + ancienNom + ' a été renommé en ' + text);
+ }
+ },
+ failure:function () {
+ eliot.textes.Messages.showErreur(
+ 'Le dossier ' + node.text + ' n\'a pas pu être renommé');
+ }
+ });
+ },
+
+ executerSupprimerDossier:function () {
+ var node = this.nodeSelectionnee;
+ // appeler la suppression de dossier
+ Ext.Ajax.request({
+ url:eliot.textes.Constantes.urlDossierSupprimer,
+ params:{ node:node.id },
+ scope:this,
+ success:function (response, request) {
+ if (response.responseText.charAt(0) != 1) {
+ request.failure();
+ } else {
+ node.remove();
+ eliot.textes.Messages.showConfirmation(
+ 'Le dossier ' + node.text + ' a été supprimé');
+ this.fireEvent(this.suppressionDossierEvent, node);
+ }
+ },
+ failure:function () {
+ eliot.textes.Messages.showErreur(
+ 'Le dossier ' + node.text + ' n\'est pas vide. Il n\'a pas pu être supprimé');
+ }
+ });
+ },
+
+ // activer le bouton "créer"
+ activerBoutonCreer:function () {
+ var boutonCreer = Ext.getCmp(eliot.textes.Constantes.leftToolbar.
+ idBoutonCreer);
+ boutonCreer.enable();
+
+ },
+
+ // desactiver le bouton "créer"
+ desactiverBoutonCreer:function () {
+ var boutonCreer = Ext.getCmp(eliot.textes.Constantes.leftToolbar.
+ idBoutonCreer);
+ boutonCreer.disable();
+ },
+
+ creePopupAfficherCahiersMasques: function() {
+
+ this.creeBoutonsPopupAffichageCahiersMasques();
+
+ this.checkBox = new Ext.grid.CheckboxSelectionModel({
+ header:'<div id="eliot-text-checker" class="x-grid3-hd-checker"> </div>'
+ });
+
+ this.gridCahiersAAfficher = new Ext.grid.GridPanel({
+ store: new Ext.data.Store({
+ autoDestroy:true,
+ storeId:'cahiersMasquesStore',
+ reader:new Ext.data.JsonReader(
+ {
+ root:'cahiers',
+ idProperty:'id',
+ fields:[
+ {name:'id'},
+ {name:'libelle'}
+ ]
+ })
+ }),
+ colModel: new Ext.grid.ColumnModel({
+ defaults: {
+ width: 120,
+ sortable: true
+ },
+ columns: [
+ this.checkBox,
+ {header: 'Cahiers de textes', dataIndex: 'libelle', sortable:true, menuDisabled:true, resizable: false}
+ ]
+ }),
+ viewConfig: {
+ stripeRows:true,
+ autoExpandColumn:'libelle',
+ forceFit: true
+ },
+ sm: this.checkBox,
+ cls:'portal-default_table'
+ });
+
+ this.getCahiersMasques();
+
+ this.popupAfficherCahiersMasques = new Ext.Window({
+ id:'popupAfficherCahiersMasques',
+ width:450,
+ height:280,
+ layout:'fit',
+ modal:true,
+ title:eliot.textes.Modele.libelle.popupAfficherCahiersMasques,
+ closeAction:'hide',
+ resizable:false,
+ plain:true,
+ items:[
+ {
+ xtype:'fieldset',
+ border:false,
+ autoHeight:true,
+ items:[
+ {
+ xtype:'label',
+ text:'Sélectionnez les cahiers de textes masqués à afficher :'
+ }
+ ,
+ {
+ xtype:'panel',
+ border:false,
+ style:'margin: 20px auto;',
+ height:140,
+ layout:'fit',
+ items:[
+ this.gridCahiersAAfficher
+ ]
+ }
+ ]
+ }
+ ],
+ buttons: [
+ this.btnAfficher,
+ this.btnAnnuler
+ ]
+ });
+
+ var selectionModel = this.gridCahiersAAfficher.getSelectionModel();
+
+ this.btnAnnuler.addListener("click",
+ function(){this.popupAfficherCahiersMasques.hide()},
+ this
+ );
+
+ this.btnAfficher.addListener("click",
+ function(){
+ this.afficherCahiersMasques(
+ selectionModel.getSelections()
+ );
+ this.popupAfficherCahiersMasques.hide();
+ this.getCahiersMasques();
+ },
+ this
+ );
+
+ selectionModel.addListener(
+ "rowselect",
+ function(){
+ this.btnAfficher.enable()
+ },
+ this
+ );
+
+ selectionModel.addListener(
+ "rowdeselect",
+ function(){
+ if(selectionModel.getSelections().length == 0){
+ this.btnAfficher.disable()
+ }
+ },
+ this
+ );
+ },
+
+ /**
+ * Création boutons popup affichage cahiers masqués
+ */
+ creeBoutonsPopupAffichageCahiersMasques: function(){
+ this.btnAfficher = new Ext.Button({
+ id: 'boutonAfficher',
+ text: eliot.textes.Modele.button.boutonAfficher
+ });
+ this.btnAnnuler = new Ext.Button({
+ id: 'boutonAnnuler',
+ text: eliot.textes.Modele.button.boutonAnnuler
+ });
+
+ this.btnAfficher.disable();
+ },
+
+ getCahiersMasques: function(){
+
+ Ext.Ajax.request({
+ url:eliot.textes.Modele.url.getCahiersMasques,
+ failure:function (response, request) {
+ eliot.textes.Messages.showErreur(
+ eliot.textes.Modele.message.erreurInconnue);
+ },
+ success:function (response, request) {
+ var resultats = Ext.decode(response.responseText);
+ if (resultats.success) {
+ this.reloadStoreCahiersAAfficher(resultats);
+ }
+ },
+ scope:this
+ });
+
+ },
+
+ reloadStoreCahiersAAfficher: function(resultats) {
+ this.gridCahiersAAfficher.store.loadData({
+ cahiers : resultats.liste
+ });
+ },
+
+ afficherCahiersMasques: function(cahiersAAfficher) {
+
+ var cdtIds = [];
+
+ for (var i = 0; i < cahiersAAfficher.length; ++i){
+ cdtIds.push(cahiersAAfficher[i].id);
}
+ Ext.Ajax.request({
+ url:eliot.textes.Modele.url.afficherCahiersMasques,
+ params:{'cdtIds' : cdtIds},
+ failure:function (response, request) {
+ eliot.textes.Messages.showErreur(
+ eliot.textes.Modele.message.erreurInconnue);
+ },
+ success:function (response, request) {
+ var resultats = Ext.decode(response.responseText);
+ if (!resultats.success) {
+ eliot.textes.Messages.showErreur(resultats.message);
+ } else {
+ window.location.reload(true);
+ }
+ },
+ scope:this
+ });
+
+ }
+
});
\ No newline at end of file
etatArbreCdtEdt:undefined,
etatArbreActivite:undefined,
dateDebutAnnee:undefined,
+ contientCdtMasque:undefined,
+ isDirectionOuADML:undefined,
isAcceesRestreint:undefined,
+ libelle:{
+ popupAfficherCahiersMasques: undefined
+ },
+
+ url:{
+ getCahiersMasques: undefined,
+ afficherCahiersMasques: undefined
+ },
+
+ button:{
+ boutonAfficher: undefined,
+ boutonAnnuler: undefined
+ },
+
message:{
suppressionEnCours:undefined,
titreModificationDate:undefined,
return (nodeId == nodeId.charAt(0) + eliot.textes.Constantes.idDossierCahiersPrivePartage);
},
/**
- * Méthode utilitaire testant si la node est le dossier partagé.
+ * Méthode utilitaire testant si la node est le dossier des cahiers de classe partagés.
* @param nodeId id de la node.
*/
isDossierPartage:function (nodeId) {
this.visaController
);
+ // Composant 'vide'
+ var idSelectionneVide = eliot.textes.recherche.Constantes.identifiant.tous;
+ if (
+ chargeCriteres &&
+ eliot.textes.recherche.Modele.data.criteresRecherche.vide
+ ) {
+ if (eliot.textes.recherche.Modele.data.criteresRecherche.vide === true) {
+ idSelectionneVide = eliot.textes.recherche.Constantes.identifiant.oui;
+ } else {
+ idSelectionneVide = eliot.textes.recherche.Constantes.identifiant.non;
+ }
+ }
+ this.videController = new eliot.textes.recherche.ComboController({
+ data:[
+ {
+ id:eliot.textes.recherche.Constantes.identifiant.non,
+ libelle:eliot.textes.recherche.Modele.libelle.non
+ },
+ {
+ id:eliot.textes.recherche.Constantes.identifiant.oui,
+ libelle:eliot.textes.recherche.Modele.libelle.oui
+ }
+ ],
+ idSelectionne:idSelectionneVide,
+ ajouteTous:true,
+ tous:eliot.textes.recherche.Modele.libelle.tous
+ });
+
+ this.videView = new eliot.textes.recherche.ComboView({
+ store:this.videController.store,
+ valeurInitiale:this.videController.idSelectionne,
+ libelle:eliot.textes.recherche.Modele.libelle.vide,
+ width:60,
+ listWidth:70
+ });
+
+ this.videController.observeCombo(
+ this.videView
+ );
+ this.videView.observeComboController(
+ this.videController
+ );
// Controller principal => coordonne les différentes intércations
// Composant controller principal
matiereController:this.matiereController,
structureController:this.structureController,
visaController:this.visaController,
- dossierView:this.dossierView
+ dossierView:this.dossierView,
+ videController:this.videController
});
this.grid.observeControllerRecherche(this.rechercheController);
this.matiereView,
this.structureView,
this.visaView,
- this.rechercheController
+ this.rechercheController,
+ this.videView
);
disabled:true
},
'-',
+ {
+ xtype:'button',
+ text:'Masquer',
+ id:'masquer',
+ disabled:true
+ },
+ '-',
{
xtype:'button',
text:'Propriétés',
{name:'nbAct'},
{name:'dateSaisie'},
{name:'dateDernierVisa'},
- {name:'estCahierArchive'}
+ {name:'estCahierArchive'},
+ {name:'estVide'},
+ {name:'estCdtClasse'}
]
})
});
}
});
+ Ext.getCmp('masquer').addListener({
+ click:{
+ fn:this.actionMasquer, scope:this
+ }
+ });
+
Ext.getCmp('proprietes').addListener({
click:{
fn:this.actionProprietes, scope:this
this
)
},
+
+ /**
+ * Création boutons popup masquage
+ */
+ creeBoutonsPopupMasquage: function(){
+ this.btnMasque = new Ext.Button({
+ id: 'boutonMasquer',
+ text: eliot.textes.recherche.Modele.button.boutonMasquer
+ });
+ this.btnAnnuler = new Ext.Button({
+ id: 'boutonAnnuler',
+ text: eliot.textes.recherche.Modele.button.boutonAnnuler
+ });
+
+ this.btnMasque.disable();
+ },
+
+ /**
+ * Création popup masquage
+ */
+ creePopupMasquage: function(cahiersMasquables){
+
+ var nbCahiersAffiches = cahiersMasquables.length;
+
+ this.creeBoutonsPopupMasquage();
+
+ this.initGridCahiersAMasquer(cahiersMasquables);
+
+ this.winMasquage = new Ext.Window({
+ id:'fenetreMasquerCdts',
+ width:600,
+ height:280,
+ layout:'fit',
+ modal:true,
+ title:eliot.textes.recherche.Modele.libelle.masquerCahiers,
+ closeAction:'close',
+ resizable:false,
+ plain:true,
+ items:[
+ {
+ xtype:'fieldset',
+ border:false,
+ autoHeight:true,
+ items:[
+ {
+ xtype:'label',
+ text:'Vous allez masquer les cahiers de textes sélectionnés (' +
+ nbCahiersAffiches +
+ '). ' +
+ 'Ils ne seront plus visibles par les utilisateurs.'
+ },
+ {
+ xtype:'panel',
+ border:false,
+ style:'margin: 20px auto;',
+ width:250,
+ layout:'fit',
+ items:[
+ this.gridCahiersAMasquer
+ ]
+ },
+ {
+ xtype:'label',
+ id:'labelPopupMasquageInfo',
+ style:'color:red;',
+ text: eliot.textes.recherche.Modele.message.popupMasquageInfo
+ }
+ ]
+ }
+ ],
+ buttons: [
+ this.btnMasque,
+ this.btnAnnuler
+ ]
+ });
+
+ this.btnAnnuler.addListener("click",
+ function(){this.winMasquage.close()},
+ this
+ );
+
+ this.btnMasque.addListener("click",
+ function(){
+ this.masqueCahiers(this.gridCahiersAMasquer.getSelectionModel().getSelections())
+ },
+ this
+ );
+
+ },
+
+ initGridCahiersAMasquer: function(cahiersMasquables){
+ this.gridCahiersAMasquer = new Ext.grid.GridPanel({
+ store:
+ new Ext.data.Store({
+ autoDestroy:true,
+ reader:new Ext.data.JsonReader({
+ root:'cahiersMasquables',
+ idProperty:'id',
+ fields:[
+ {name:'id'},
+ {name:'data.nom'}
+ ]
+ })
+ })
+ ,
+ colModel:new Ext.grid.ColumnModel({
+ columns:[
+ {dataIndex:'data.nom', width:230}
+ ]
+ }),
+ width:330,
+ height:115,
+ hideHeaders:true,
+ autoSize:false,
+ border:false,
+ cls:'portal-default_table'
+ });
+
+ this.gridCahiersAMasquer.store.loadData({
+ cahiersMasquables:cahiersMasquables
+ });
+
+ var selectionModel = this.gridCahiersAMasquer.getSelectionModel();
+
+ selectionModel.addListener(
+ "rowselect",
+ function(){
+ this.btnMasque.enable()
+ },
+ this
+ );
+
+ selectionModel.addListener(
+ "rowdeselect",
+ function(){
+ if (selectionModel.getSelections().length == 0){
+ this.btnMasque.disable()
+ }
+ },
+ this
+ );
+ },
+
/**
* Selection d'un cahier
*/
Ext.getCmp('visu').enable();
Ext.getCmp('proprietes').disable();
}
+ if (this.hasSelectionVideEtDeClasse()){
+ Ext.getCmp('masquer').enable();
+ }
},
/**
* Déselection d'un cahier
} else if (count == 1) {
Ext.getCmp('proprietes').enable();
}
+ if (this.hasSelectionVideEtDeClasse()){
+ Ext.getCmp('masquer').enable();
+ } else {
+ Ext.getCmp('masquer').disable();
+ }
},
/**
* Visualisation du cahier
win.show(this);
},
+ /**
+ * Masquer les Cdt
+ */
+ actionMasquer: function(){
+
+ var cahiersMasquables = [];
+
+ var selections = this.checkBox.getSelections();
+ var afficherLabelPopupMasquageInfo = false;
+ for (var i = 0; i< selections.length; ++i){
+ if(selections[i].data.estCdtClasse){
+ if(selections[i].data.estVide){
+ cahiersMasquables.push(selections[i])
+ } else {
+ afficherLabelPopupMasquageInfo = true
+ }
+ }
+ }
+
+ this.creePopupMasquage(cahiersMasquables);
+
+ if (afficherLabelPopupMasquageInfo){
+ Ext.getCmp('labelPopupMasquageInfo').show();
+ } else {
+ Ext.getCmp('labelPopupMasquageInfo').hide();
+ }
+
+ this.winMasquage.show(this);
+ },
+
/**
* Afficher les propriétés du Cdt
*/
'?cdsIds=' + ids.join(',');
},
+ masqueCahiers: function(cahiersAMasquer) {
+
+ var cdtIds = [];
+
+ for (var i = 0; i < cahiersAMasquer.length; ++i){
+ cdtIds.push(cahiersAMasquer[i].id);
+ }
+
+ Ext.Ajax.request({
+ url:eliot.textes.recherche.Modele.url.masquer,
+ params:{'cdtIds':cdtIds},
+ failure:function (response, request) {
+ eliot.textes.Messages.showErreur(
+ eliot.textes.recherche.Modele.message.erreurInconnue);
+ this.winMasquage.close();
+ },
+ success:function (response, request) {
+
+ var resultats = Ext.decode(response.responseText);
+ if (!resultats.success) {
+ eliot.textes.Messages.showErreur(resultats.message);
+ } else {
+ eliot.textes.Messages.showConfirmation(resultats.message);
+ this.rechercheController.executeRecherche();
+ }
+ this.winMasquage.close();
+ },
+ scope:this
+ });
+
+ },
+
/**
*
* @param params
}
}
return isAllCdtArchive
+ },
+ /**
+ * Détermine si le CDTs sélectionné est un cdt de classe partagé et vide
+ */
+ isSelectionVideEtDeClasse: function(){
+ var result = false;
+
+ var selection = this.checkBox.getSelected();
+ if (selection.data.estCdtClasse && selection.data.estVide){
+ result = true;
+ }
+
+ return result;
+ },
+ /**
+ * Détermine si il y a des CDTs de classe partagés vide sélectionnés
+ */
+ hasSelectionVideEtDeClasse: function(){
+ var result = false;
+
+ var selections = this.checkBox.getSelections();
+ for (var i = 0; i < selections.length; ++i){
+ if (selections[i].data.estCdtClasse && selections[i].data.estVide){
+ result = true;
+ }
+ }
+
+ return result;
}
+
});
Ext.reg('gridcahiers', eliot.textes.recherche.Grid);
dateSaisie:undefined,
viserPlusieursCahiers:undefined,
dossier:undefined,
- inclureArchives:undefined
+ inclureArchives:undefined,
+ vide:undefined,
+ masquerCahiers: undefined
},
data:{
recherche:undefined
},
+ button:{
+ boutonMasquer: undefined,
+ boutonAnnuler: undefined
+ },
+
message:{
rechercheEnCours:undefined,
ajoutDemandeImpressionSucces:undefined,
- ajoutDemandeImpressionErreur:undefined
+ ajoutDemandeImpressionErreur:undefined,
+ popupMasquageInfo: undefined,
+ erreurInconnue: undefined
}
};
\ No newline at end of file
this.matiereController = config.matiereController;
this.structureController = config.structureController;
this.visaController = config.visaController;
+ this.videController = config.videController;
this.dossierView = config.dossierView;
// Evénements
);
}
+ if (
+ this.videController.idSelectionne !=
+ eliot.textes.recherche.Constantes.identifiant.tous
+ ) {
+ params.vide = (
+ this.videController.idSelectionne ===
+ eliot.textes.recherche.Constantes.identifiant.oui
+ );
+ }
+
this.fireEvent(
eliot.textes.recherche.Constantes.eventId.actionRecherche,
params
matiereView,
structureView,
visaView,
- rechercheController
+ rechercheController,
+ videView
) {
visaView.combo
]
},
+ {
+ width :70,
+ labelWidth: 40,
+ labelAlign : 'top',
+ items:[
+ videView.combo
+ ]
+ },
{
xtype: 'tbbutton',
text : eliot.textes.recherche.Modele.libelle.rechercher,