eliot.scolarite.urlServeur = 'http://127.0.0.1:8080'
eliot.textes.nomApplication = 'eliot-textes'
eliot.textes.urlServeur = 'http://127.0.0.1:8080'
-
+ //répertoire racine pour le dépôt des fichiers UDT
+ eliot.scolarite.import.udtConnecteur.racineDossiers = '/tmp/importUDT'
}
// Parametrage cité scolaire
package org.lilie.services.eliot.scolarite
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.temps.importcommun.ImportType
/**
* Préférences pour un établissement : données communes
Boolean magisterActive = false
AnneeScolaire anneeScolaire
+
+ String typeDernierImport // STS ou UDT
+ Boolean importUdtManuelActif
- static transients = ['anneeScolaireService']
+ static transients = ['anneeScolaireService', 'importType']
def beforeValidate(){
if(!this.anneeScolaire){
"etablissement=" + etablissement +
'}';
}
+
+ public void setImportType(ImportType importType) {
+ this.typeDernierImport = importType.name()
+ }
+
+ public ImportType getImportType() {
+ ImportType.values().find{it.name() == this.typeDernierImport}
+ }
}
package org.lilie.services.eliot.temps.importcommun
import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.PreferencesEtablissement
import org.lilie.services.eliot.scolarite.etablissement.EtablissementService
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
import org.lilie.services.eliot.temps.importsts.StsImportUtil
import java.text.SimpleDateFormat
EtablissementService etablissementService
AnneeScolaireService anneeScolaireService
+ PreferenceEtablissementService preferenceEtablissementService
// Préfixe du nom des dossiers des établissements
private final static String PREFIXE_NOM_DOSSIER_ETABLISSEMENT = "ETAB_"
return etablissementsEnAttente
}
+
+ /**
+ * Met à jour le champ typeDernierImport
+ */
+ protected void majTypeDernierImport(Etablissement etablissement,
+ ImportType importType) {
+ PreferencesEtablissement preferencesEtablissement =
+ preferenceEtablissementService.getPreferenceEtablissement(etablissement)
+ preferencesEtablissement.setImportType(importType)
+ preferenceEtablissementService.setPreferenceEtablissement(
+ preferencesEtablissement
+ )
+ }
}
// Ecriture des fichiers
fileStsEmp << fluxStsEmp
fileEmpSts << fluxEmpSts
+
+ majTypeDernierImport(etablissement, ImportType.STS)
}
/**
return file.exists()
}
+ boolean isDossierVide(Etablissement etablissement, ImportEtat importEtat) {
+ getFileDossierForEtablissementAndEtat(
+ etablissement,
+ importEtat
+ ).list().toList().isEmpty()
+ }
+
String getTraitementCode() {
return PRETRAITEMENT_UDT
}
}
safeDelete(getFileVerrouForEtablissement(etablissement))
}
+
+ /**
+ * Envoie un fichier UDT à importer pour un établissement
+ * @param etablissement l'établissement pour lequel ces données sont envoyées
+ * @param fluxUdt le flux de données Udt
+ * @param ecraser si true, et qu'il existe déjà des données à importer,
+ * celles-ci seront écrasées
+ * @throws IllegalStateException si le paramètre ecraser vaut false et que
+ * des données à importer existe déjà
+ * @throws IllegalStateException si un import STS est en cours pour cet
+ * établissement
+ */
+ void envoieDonneesAImporter(Etablissement etablissement,
+ InputStream fluxUdt,
+ String nomFichierUdt)
+ throws IllegalStateException {
+
+ if (!isDossierVide(etablissement, ImportEtat.EN_ATTENTE)) { // dossier non vide
+ throw new IllegalStateException(
+ "Il y a déjà des données à importer pour l'établissement " +
+ "${etablissement.uai} (flag ecraser=false)"
+ )
+ }
+
+ // Récupération des fichiers UDT du dossier "EnAttente"
+ File fileUdt = getFileUdt(etablissement,
+ ImportEtat.EN_ATTENTE,
+ nomFichierUdt)
+
+ // Création des fichiers
+ fileUdt.createNewFile()
+
+ // Ecriture des fichiers
+ fileUdt << fluxUdt
+
+ // Décompression
+ AntBuilder antBuilder = new AntBuilder()
+ antBuilder.unzip( src:fileUdt.getPath(),
+ dest:fileUdt.getParent(),
+ overwrite:false )
+
+ // Suppression zip
+ fileUdt.delete()
+
+ // création fichier IMPORT.TXT
+ File descripteurImport = getFileImportDescripteur(etablissement,
+ ImportEtat.EN_ATTENTE)
+ descripteurImport.createNewFile()
+
+ majTypeDernierImport(etablissement, ImportType.UDT)
+ }
+
+
+ /**
+ * Retourne un pointeur sur le fichier UDT pour un établissement et un état
+ * (en attente, en cours, traité)
+ */
+ public File getFileUdt(Etablissement etablissement,
+ ImportEtat etat,
+ String nomFichierUdt,
+ Date dateTraiment = null) {
+ if (log.debugEnabled) {log.debug "getFileUdt"}
+ return getFile(etablissement, nomFichierUdt, etat, dateTraiment)
+ }
+
}
--- /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.temps.importudt
+
+import org.apache.tools.ant.taskdefs.Zip
+import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.temps.importcommun.ImportEtat
+import org.lilie.services.eliot.temps.importudt.connecteur.UdtConnecteurDonneesManagerService
+
+
+class UdtConnecteurDonneesManagerServiceTests extends GroovyTestCase {
+
+ UdtConnecteurDonneesManagerService udtConnecteurDonneesManagerService
+ Etablissement etablissement
+ String repertoireTemp
+
+ GrailsApplication grailsApplication
+
+ protected void setUp() {
+ super.setUp()
+ repertoireTemp = System.getProperty("java.io.tmpdir")
+ grailsApplication.config.eliot.scolarite.import.udtConnecteur.racineDossiers = repertoireTemp
+ }
+
+ protected void tearDown() {
+ super.tearDown()
+ }
+
+ void testEnvoieDonneesAImporter() {
+
+ Etablissement etablissement = Etablissement.list().first()
+ String nomFichierUdt = 'UDT-Filesxxxxxx.zip'
+ String nomFichierVide = 'vide.txt'
+
+ //Crée un fichier vide dans le repertoireTemp pour pouvoir le zipper
+ File fichierVide = new File(cheminFichier(nomFichierVide,repertoireTemp))
+ fichierVide.createNewFile()
+
+ //Crée un fichier zip dans le repertoireTemp
+ def ant = new AntBuilder()
+ Zip zip = ant.zip(destfile: cheminFichier(nomFichierUdt, repertoireTemp),
+ basedir: repertoireTemp,
+ includes: fichierVide.getName())
+
+ //Envoie le zip
+ InputStream fluxUdt = new FileInputStream(zip.zipFile)
+ udtConnecteurDonneesManagerService.envoieDonneesAImporter(etablissement,
+ fluxUdt,
+ nomFichierUdt)
+
+ //Teste l'existance du fichier IMPORT.TXT dans le répertoire d'attente
+ assertTrue (udtConnecteurDonneesManagerService.getFileImportDescripteur(
+ etablissement,ImportEtat.EN_ATTENTE
+ ).exists())
+
+ }
+
+ private String cheminFichier(String nomFichier, String repertoire) {
+ def chemin = repertoire
+ chemin <<= File.separator
+ chemin <<= nomFichier
+ chemin.toString()
+ }
+}
--- /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>.
+ -->
+
+<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="obon">
+ <comment>
+ Rajout de deux colonnes à la table ent.preference_etablissement :
+ - type_dernier_import : STS ou UDT (pour eliot-scolarite/emploi du temps)
+ - import_udt_manuel_actif : vrai si l'import UDT manuel est activé
+ </comment>
+
+ <addColumn schemaName="ent" tableName="preference_etablissement">
+ <column name="type_dernier_import" defaultValue="STS" type="varchar(5)">
+ <constraints nullable="false"/>
+ </column>
+ </addColumn>
+
+ <addColumn schemaName="ent" tableName="preference_etablissement">
+ <column name="import_udt_manuel_actif" defaultValue="false" type="boolean">
+ <constraints nullable="false"/>
+ </column>
+ </addColumn>
+
+ </changeSet>
+
+</databaseChangeLog>
<include file="changelogs/securite/2014-01-17-0033207.xml"/>
<include file="changelogs/scolarite/2014-01-30-0033643.xml"/>
<include file="changelogs/scolarite/2014-02-03-0033848.xml"/>
+ <include file="changelogs/scolarite/2014-02-03-0033862.xml"/>
</databaseChangeLog>
}
}
-eliot.scolarite.synchronisationUDTv16Activee = true
// Si true, active le bouton permettant de lancer une synchronisation STS
environments {
}
test {
}
+ //répertoire racine pour le dépôt des fichiers UDT
+ eliot.scolarite.import.udtConnecteur.racineDossiers = '/tmp/importUDT'
}
package org.lilie.services.eliot.scolarite
+import org.lilie.services.eliot.temps.importcommun.ImportEtat
import org.springframework.web.multipart.MultipartFile
import org.springframework.web.multipart.MultipartHttpServletRequest
import grails.converters.JSON
import org.lilie.services.eliot.temps.importcommun.ImportType
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
import org.lilie.services.eliot.scolarite.page.ScolaritePage
+import org.lilie.services.eliot.temps.importudt.connecteur.UdtConnecteurDonneesManagerService
+import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
/**
* Contrôleur de la section 'Import STS' de l'application eliot-scolarite
EtablissementService etablissementService
UdtImportRapportService udtImportRapportService
CalendrierService calendrierService
-
- private static final Boolean SYNCHRO_UDT_V16_ACTIVEE =
- ConfigurationHolder.config.eliot.scolarite.synchronisationUDTv16Activee
+ UdtConnecteurDonneesManagerService udtConnecteurDonneesManagerService
+ PreferenceEtablissementService preferenceEtablissementService
// Paramètre pour la pagination dans la présentation des rapports
public final static int NB_RAPPORTS_PAR_PAGE = 7
*/
def index = {
- checkAccesPage(ScolaritePage.IMPORT_STS)
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
- Boolean synchroEnCours = false
Etablissement etablissement = etablissementCourant()
+ PreferencesEtablissement preferencesEtablissement =
+ preferenceEtablissementService.getPreferenceEtablissement(etablissement)
- if (stsImportDonneesManagerService.hasImportEnCours(etablissement)) {
- synchroEnCours = true
- }
+ ImportType importType = preferencesEtablissement.getImportType()
// Récupère tous les rapports UDT d'annee en cours
List<ImportRapportInfo> udtRapportInfos = udtImportRapportService.
// moment où scolarité aura plusieurs pages il faudra passer en paramètre
// à prepareBaseModele un objet représentant la page actuellement
// sélectionnée.
- Map model = prepareBaseModele(ScolaritePage.IMPORT_STS)
+ Map model = prepareBaseModele(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
- model.synchroUDTv16 = SYNCHRO_UDT_V16_ACTIVEE
- model.synchroEnCours = synchroEnCours
model.listeRapportInfo = listeRapportInfoPaginee
model.nbRapports = listeRapportInfo.size()
model.max = max
model.btnSynchroniser = ConfigurationHolder.config.eliot.scolarite.sts.btnSynchroniser
model.calendrierInitialise = getCalendrierInitialise()
-
+ model.importManuelUdtActif = preferencesEtablissement.importUdtManuelActif
+ model.optionImportParDefaut = importType.name()
return model
}
*/
def visualiseFichier = {
- checkAccesPage(ScolaritePage.IMPORT_STS)
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
String etablissementUai = params.etablissementUai
Etablissement etablissement = etablissementService.findEtablissementByUai(
* Méthode utilisée pour afficher le message du statut d'import en ajax
* au dessus les deux champs de upload
*/
- def etatFichiersDansServeur = {
+ def etatFichiersStsDansServeur = {
- checkAccesPage(ScolaritePage.IMPORT_STS)
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
Etablissement etablissement = etablissementCourant()
List<String> messageJson = []
+ Boolean desactiverEnvoi = false
if (stsImportDonneesManagerService.hasDonneesAImporter(etablissement)) {
messageJson << message(
code: 'eliot.import-temps.message.fichiersDeposes'
)
- }
- else {
+ } else if (stsImportDonneesManagerService.hasImportEnCours(etablissement)){
+ messageJson << message(
+ code: 'eliot.importTemps.message.importSts.enCours'
+ )
+ desactiverEnvoi = true
+ } else {
messageJson << message(
code: 'eliot.import-temps.message.fichiersNonDeposes'
)
}
- Map reponseJson = [success: true, messageSuccess: messageJson]
+ Map reponseJson = [
+ success: true,
+ messageSuccess: messageJson,
+ desactiverEnvoi: desactiverEnvoi
+ ]
+
+ render(reponseJson as JSON)
+ }
+
+ /**
+ * Méthode utilisée pour afficher le message du statut d'import en ajax
+ * au dessus les deux champs de upload
+ */
+ def etatFichierUdtDansServeur = {
+
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
+
+ Etablissement etablissement = etablissementCourant()
+
+ List<String> messageJson = []
+ Boolean desactiverEnvoi = false
+
+ if (!udtConnecteurDonneesManagerService.isDossierVide(etablissement, ImportEtat.EN_ATTENTE)) {
+ messageJson << message(
+ code: 'eliot.importTemps.messageErreur.conflitDepotFichiersEnAttente'
+ )
+ desactiverEnvoi = true
+ }
+ Map reponseJson = [
+ success: true,
+ messageSuccess: messageJson,
+ desactiverEnvoi: desactiverEnvoi
+ ]
render(reponseJson as JSON)
}
+
+ /**
+ * Méthode utilisée pour envoyer le deux fichiers aux serveur
+ */
+ def uploadFichierUdt = {
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
+
+ List messagesErreurs = []
+ String msg = ''
+
+ if (log.infoEnabled) {log.info "Dépôt des fichiers UDT"}
+
+ MultipartFile importUdt
+
+ if (request instanceof MultipartHttpServletRequest) {
+ MultipartHttpServletRequest multipartRequest =
+ (MultipartHttpServletRequest) request
+
+ importUdt = multipartRequest.getFile('idUdt')
+
+ }
+ else {
+ messagesErreurs << message(
+ code: 'eliot.importTemps.messageErreur.envoyerFichierEchec'
+ )
+ messagesErreurs.each {
+ def messageErreur ->
+ msg += messageErreur + '<br/>'
+ }
+ String reponseJson = """{ success:false, messagesErreurs:"$msg"}"""
+
+ render(reponseJson)
+ return
+ }
+
+ String reponseJson = verifieImportUdtEnAttente()
+
+ if (reponseJson != null) {
+ render(reponseJson)
+ return
+ }
+
+ udtConnecteurDonneesManagerService.envoieDonneesAImporter(
+ etablissementCourant(),
+ importUdt.inputStream,
+ importUdt.getOriginalFilename()
+ )
+
+ def texte
+ if (params.message == message(code: 'eliot.import-temps.message.fichiersNonDeposes')) {
+ texte = message(code: 'eliot.import-temps.message.submitSuccess')
+ }
+ else {
+ texte = message(code: 'eliot.import-temps.message.submitSuccess')
+ }
+ String message = """{success:true, msg: '${texte}' }"""
+ render(message)
+ }
+
/**
* Méthode utilisée pour envoyer les deux fichiers aux serveur
*/
def uploadFichiersSts = {
- checkAccesPage(ScolaritePage.IMPORT_STS)
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
List messagesErreurs = []
String msg = ''
if (request instanceof MultipartHttpServletRequest) {
MultipartHttpServletRequest multipartRequest =
- (MultipartHttpServletRequest) request
+ (MultipartHttpServletRequest) request
importStsEmp = multipartRequest.getFile('idStsEmp')
importEmpSts = multipartRequest.getFile('idEmpSts')
)
messagesErreurs.each {
def messageErreur ->
- msg += messageErreur + '<br/>'
+ msg += messageErreur + '<br/>'
}
String reponseJson = """{ success:false, messagesErreurs:"$msg"}"""
}
// Vérification de l'intégrité des fichiers à importer
- String reponseJson = valideFichiersImport(importStsEmp, importEmpSts)
+ String reponseJson = valideFichiersImportSts(importStsEmp, importEmpSts)
if (reponseJson != null) {
render(reponseJson)
return
}
- reponseJson = verifieImportEnCours()
+ reponseJson = verifieImportStsEnCours()
if (reponseJson != null) {
render(reponseJson)
@SuppressWarnings('CatchException')
- private String valideFichiersImport(MultipartFile importStsEmp,
+ private String valideFichiersImportSts(MultipartFile importStsEmp,
MultipartFile importEmpSts) {
String reponseJson = null
List messagesErreurs = []
}
- private String verifieImportEnCours() {
- String reponseJson = null
- List messagesErreurs = []
- String msg = ''
+ private String verifieImportStsEnCours() {
+ jsonVerifImport(
+ stsImportDonneesManagerService.hasImportEnCours(etablissementCourant()),
+ 'eliot.importTemps.messageErreur.coflitDepotFichiers'
+ )
+ }
- if (stsImportDonneesManagerService.hasImportEnCours(etablissementCourant())) {
- log.error "Impossible de déposer les fichiers : Une synchronisation est " +
- "en cours."
- messagesErreurs << message(
- code: 'eliot.importTemps.messageErreur.coflitDepotFichiers'
- )
- messagesErreurs.each {
- def messageErreur ->
- msg += messageErreur + '<br/>'
- }
+ private String verifieImportUdtEnAttente() {
+ jsonVerifImport(
+ !udtConnecteurDonneesManagerService.isDossierVide(etablissementCourant(),
+ ImportEtat.EN_ATTENTE),
+ 'eliot.importTemps.messageErreur.conflitDepotFichiersEnAttente'
+ )
+ }
- reponseJson = """{ success:false, messagesErreurs:"$msg"}"""
+ private String jsonVerifImport(Boolean enErreur, String codeMsgErreur) {
+ String reponseJson = null
+ if (enErreur) {
+ String msgErreur = message(code: codeMsgErreur)
+ log.error msgErreur
+ reponseJson = """{ success:false, messagesErreurs:"$msgErreur"}"""
}
reponseJson
}
@SuppressWarnings('CatchException')
def synchroniserImportSts = {
- checkAccesPage(ScolaritePage.IMPORT_STS)
+ checkAccesPage(ScolaritePage.IMPORT_EMPLOI_DU_TEMPS)
List messages = []
String msg = ''
ScolariteFonctionnalites.SCOL_MAGISTER
),
- IMPORT_STS(
+ IMPORT_EMPLOI_DU_TEMPS(
ScolariteFonctionnalites.SCOL_EDT,
'gestionSynchroEdt',
'index'
eliot.importTemps.messageErreur.StsEmp=Le fichier STS-EMP n'a pas le bon format Il doit être du type : STS_EMP_NumEtab_Annee.xml
eliot.importTemps.messageErreur.EmpSts=Le fichier EMP-STS n'a pas le bon format.Il doit être du type : EMP_STS_NumEtab_Annee.xml
+eliot.importTemps.messageErreur.Udt=Le fichier UDT n'a pas le bon format.Il doit être du type : UDT-Filesxxxxxx.zip
eliot.importTemps.messageErreur.clientInvalide=Impossible de démarrer l'import
eliot.importTemps.messageErreur.connectionEchou=Ajax communication échoué
eliot.importTemps.messageErreur.deuxChampVide=Aucun des fichiers nécessaires à l'import n'ont été renseignés.
eliot.importTemps.messageErreur.fichiersDeposes=Les deux fichiers sont déjà déposés, cliquez sur bouton Synchroniser pour lancer l'import.
eliot.importTemps.messageErreur.titreImport=Import
eliot.importTemps.messageErreur.coflitDepotFichiers=Dépôt des fichiers impossible, un import est en cours d'exécution
+eliot.importTemps.messageErreur.conflitDepotFichiersEnAttente=Dépôt des fichiers impossible, d'autres fichiers sont déjà en attente de traitement.
eliot.importTemps.messageErreur.envoyerFichierEchec=les fichiers n'ont pas été envoyés pour une raison inconnue
eliot.importTemps.messageErreur.conflitSynchroFichiers= Etablissement {0} ({1}) : synchronisation des fichiers impossible, un import est en cours d'exécution.
eliot.importTemps.messageErreur.fichierNonDepose= Etablissement {0} ({1}) : aucun fichier à importer.
eliot.importTemps.message.success=Success
eliot.importTemps.message.echoue=Echoué
eliot.importTemps.message.erreur=Erreur
-
+eliot.importTemps.message.importUdt.auto=Vous pouvez déclencher la synchronisation directe des emplois du temps sur l'ENT depuis UnDeuxTEMPS version 2013 (v19) ou ultérieure par la commande : « Fichier – Publier vers - l'ENT »<br/>Un rapport est généré à l'issue de chaque traitement de synchronisation et est présenté ci-dessous.
+eliot.importTemps.message.importUdt.manu=Vous pouvez déclencher la synchronisation des emplois du temps sur l'ENT en déposant sur l'ENT le fichier UDT-Filesxxxxxxx.zip issu d'UnDeuxTEMPS 2013 (v19) ou ultérieure par la commande : « Fichier – Publier vers - l'ENT ».<br/> Le formulaire ci-dessous vous permet de déposer le fichier sur l'ENT.<br/>Un rapport est généré à l'issue de chaque traitement de synchronisation et est présenté ci-dessous.
+eliot.importTemps.message.importSts.manu=Vous pouvez déclencher la synchronisation des emplois du temps sur l'ENT en déposant sur l'ENT les fichiers STS_emp_xxx.xml issu de STS_Web et emp_STS_xxx.xml issu de votre logiciel d'emploi du temps.<br/>Le formulaire ci-dessous vous permet de déposer ces fichiers sur l'ENT. Une demande de synchronisation faite pendant la journée est traitée dans la nuit suivante. Un compte rendu sera disponible sur cette même page après le traitement.
+eliot.importTemps.message.importSts.enCours=Une synchronisation est en cours.<br/>Un compte rendu sera disponible sur cette même page après le traitement.
##libellé de champ
eliot.importTemps.libelle.StsEmp=Envoi du fichier STS_EMP
eliot.importTemps.libelle.EmpSts=Envoi du fichier EMP_STS
+eliot.importTemps.libelle.Udt=UDT-Filesxxxxxx.zip
eliot.importTemps.libelle.titreImport=Import
+eliot.importTemps.libelle.radio.StsWeb=STS-WEB
+eliot.importTemps.libelle.radio.Udt=UnDeuxTEMPS
##libellé de bouton
eliot.importTemps.bouton.consulterLog=Consulter Log
eliot.importTemps.title.synchroniser=Lancer la synchronisation des emplois du temps sur les fichiers présents sur ENT
eliot.importTemps.title.importer=Déposer les fichiers STS_emp et emp_STS sur ENT
+##titre de formulaire
+eliot.importTemps.form.title.choixImport = Source Emploi du temps
+eliot.importTemps.form.title.depotFichier.sts = Dépôt des fichiers STS_emp et emp_STS
+eliot.importTemps.form.title.depotFichier.udt = Dépôt des fichiers UDT-Filesxxxxxx.zip
+
+
+
## titre menu
eliot.scolarite.menu.emploiDuTemps.titrePrincipal=Emploi du temps
eliot.scolarite.menu.vieScolaire.titrePrincipal=Vie Scolaire
SYNCHRO_EDT(
'eliot.scolarite.menu.emploiDuTemps.titrePrincipal',
- ScolaritePage.IMPORT_STS,
+ ScolaritePage.IMPORT_EMPLOI_DU_TEMPS,
),
PARAMETRAGE_TITRE_PRINCIPAL(
- <http://www.cecill.info/licences.fr.html>.
--}%
-<%@ page import="org.lilie.services.eliot.menu.MenuInfo" %>
+<%@ page import="org.lilie.services.eliot.temps.importcommun.ImportType; org.lilie.services.eliot.menu.MenuInfo" %>
<script type="text/javascript">
//URL
- eliot.importTemps.Constantes.urlImport = '${createLink(action:'uploadFichiersSts', controller:'gestionSynchroEdt')}';
- eliot.importTemps.Constantes.urlSelectionFichiersSts = '${createLink(action:'etatFichiersDansServeur', controller:'gestionSynchroEdt')}';
+ eliot.importTemps.Constantes.urlImportSts = '${createLink(action:'uploadFichiersSts', controller:'gestionSynchroEdt')}';
+ eliot.importTemps.Constantes.urlImportUdt = '${createLink(action:'uploadFichierUdt', controller:'gestionSynchroEdt')}';
+ eliot.importTemps.Constantes.urlSelectionFichiersSts = '${createLink(action:'etatFichiersStsDansServeur', controller:'gestionSynchroEdt')}';
+ eliot.importTemps.Constantes.urlSelectionFichierUdt = '${createLink(action:'etatFichierUdtDansServeur', controller:'gestionSynchroEdt')}';
eliot.importTemps.Constantes.urlSynchronisation = '${createLink(action:'synchroniserImportSts', controller:'gestionSynchroEdt')}';
//Message erreur
eliot.importTemps.Constantes.messageErreur.StsEmp = "<g:message code='eliot.importTemps.messageErreur.StsEmp'/>";
eliot.importTemps.Constantes.messageErreur.EmpSts = "<g:message code='eliot.importTemps.messageErreur.EmpSts'/>";
+ eliot.importTemps.Constantes.messageErreur.Udt = "<g:message code='eliot.importTemps.messageErreur.Udt'/>";
eliot.importTemps.Constantes.messageErreur.clientInvalide = "<g:message code='eliot.importTemps.messageErreur.clientInvalide'/>";
eliot.importTemps.Constantes.messageErreur.connectionEchou = "<g:message code='eliot.importTemps.messageErreur.connectionEchou'/>";
eliot.importTemps.Constantes.messageErreur.deuxChampVide = "<g:message code='eliot.importTemps.messageErreur.deuxChampVide'/>";
eliot.importTemps.Constantes.message.echoue = "<g:message code='eliot.importTemps.message.echoue'/>";
eliot.importTemps.Constantes.message.erreur = "<g:message code='eliot.importTemps.message.erreur'/>";
eliot.importTemps.Constantes.message.fichierDepose = "<g:message code='eliot.import-temps.message.fichiersDeposes'/>";
+ eliot.importTemps.Constantes.message.importStsManu = "<g:message code='eliot.importTemps.message.importSts.manu'/>";
+ eliot.importTemps.Constantes.message.importUdtManu = "<g:message code='eliot.importTemps.message.importUdt.manu'/>";
+ eliot.importTemps.Constantes.message.importUdtAuto = "<g:message code='eliot.importTemps.message.importUdt.auto'/>";
//Libellé
eliot.importTemps.Constantes.libelle.titreImport = "<g:message code='eliot.importTemps.libelle.titreImport'/>";
eliot.importTemps.Constantes.libelle.StsEmp = "<g:message code='eliot.importTemps.libelle.StsEmp'/>";
eliot.importTemps.Constantes.libelle.EmpSts = "<g:message code='eliot.importTemps.libelle.EmpSts'/>";
+ eliot.importTemps.Constantes.libelle.Udt = "<g:message code='eliot.importTemps.libelle.Udt'/>";
+ eliot.importTemps.Constantes.libelle.optionImportParDefaut = "${optionImportParDefaut}";
+ eliot.importTemps.Constantes.libelle.optionImportSts = "${ImportType.STS.name()}";
+ eliot.importTemps.Constantes.libelle.optionImportUdt = "${ImportType.UDT.name()}";
//bouton
eliot.importTemps.Constantes.bouton.consulterLog = "<g:message code='eliot.importTemps.bouton.consulterLog'/>";
eliot.importTemps.Constantes.title.synchroniser = "<g:message code='eliot.importTemps.title.synchroniser'/>";
eliot.importTemps.Constantes.title.importer = "<g:message code='eliot.importTemps.title.importer'/>";
eliot.importTemps.Constantes.menuTitrePrincipal = "<g:message code='eliot.scolarite.menu.emploiDuTemps.titrePrincipal'/>";
+ eliot.importTemps.Constantes.title.formDepotFichierSts = "<g:message code='eliot.importTemps.form.title.depotFichier.sts'/>";
+ eliot.importTemps.Constantes.title.formDepotFichierUdt = "<g:message code='eliot.importTemps.form.title.depotFichier.udt'/>";
// Environnement
eliot.importTemps.Constantes.btnSynchroniser = (${btnSynchroniser});
+ eliot.importTemps.Constantes.importManuelUdtActif = ${importManuelUdtActif};
</script>
\ No newline at end of file
- <http://www.cecill.info/licences.fr.html>.
--}%
-<%@ page import="org.lilie.services.eliot.scolarite.GestionSynchroEdtController; org.lilie.services.eliot.temps.importsts.StsImportUtil" %>
+<%@ page import="org.lilie.services.eliot.temps.importcommun.ImportType; org.lilie.services.eliot.scolarite.GestionSynchroEdtController; org.lilie.services.eliot.temps.importsts.StsImportUtil; org.lilie.services.eliot.temps.importcommun.ImportType" %>
<html>
<head>
<meta name="layout" content="eliot.simple.html+extjs.3.2.0"/>
<g:javascript library="src/views/gestionSynchroEdt/Constantes"/>
<g:render template="/gestionSynchroEdt/constants"/>
<g:javascript library="src/views/gestionSynchroEdt/configMessageBox"/>
- <g:javascript library="src/views/gestionSynchroEdt/configFormPanel"/>
+ <g:javascript library="src/views/gestionSynchroEdt/configFormPanelSts"/>
+ <g:javascript library="src/views/gestionSynchroEdt/configFormPanelUdt"/>
<g:javascript library="src/views/gestionSynchroEdt/Application"/>
- <script type="text/javascript">
- function utiliseUDT16() {
- var check = document.getElementById('box').checked;
- if (!check) {
- document.getElementById('choixFichiers').style.display = 'block';
- document.getElementById('txtUDT').style.display = 'none';
- document.getElementById('txtEDT').style.display = 'block';
- }
- else {
- document.getElementById('choixFichiers').style.display = 'none';
- document.getElementById('txtUDT').style.display = 'block';
- document.getElementById('txtEDT').style.display = 'none';
- }
- }
- function title() {
- var check = document.getElementById('box').checked;
- if (check) {
- document.getElementById('box').title = "Décochez cette case si vous n'utilisez pas UnDeuxTEMPS version 18 ou supérieure dans votre établissement";
- }
- else {
- document.getElementById('box').title = "Cochez cette case si vous utilisez UnDeuxTEMPS version 18 ou supérieure dans votre établissement";
- }
- }
- function cocheCheckBox() {
- <g:if test="${ synchroUDTv16 }">
- document.getElementById('box').checked = true;
- </g:if>
- }
- </script>
</head>
-<body onload="cocheCheckBox();">
-<!--<content tag="breadcrumbs" class="x-hide-display"></content>-->
+<body>
-<g:if test="${ synchroUDTv16 && !synchroEnCours}">
<div id="choixLogiciel" style="display: block;" class="DivContainsTable">
<table id="tableLogiciel" class="activities_list tablesorter fullsize">
<thead>
<tr>
- <td class="entete">Logiciel d'emploi du temps</td>
+ <td class="entete">
+ <g:message code="eliot.importTemps.form.title.choixImport"/>
+ </td>
</tr>
</thead>
<tbody id="bodyTableLogiciel">
<tr>
- <td style="text-align: center;">
- <br/>
- <input type="checkbox" id="box" title="Décochez cette case si vous n'utilisez pas UnDeuxTEMPS version 18 ou supérieure dans votre établissement"
- name="Utilise UnDeuxTEMPS " onClick="utiliseUDT16();"/>
- UnDeuxTEMPS 2013 (v19)
- <br/>
- <br/>
+ <td>
+ <div id="radioGroupStsUdt">
+ <g:radioGroup name="radioGroupImport" labels="[
+ message(code:'eliot.importTemps.libelle.radio.StsWeb'),
+ message(code:'eliot.importTemps.libelle.radio.Udt')]"
+ values="[ImportType.STS.name(),ImportType.UDT.name()]" value="${optionImportParDefaut}">
+ <p>${it.radio} ${it.label}</p>
+ </g:radioGroup>
+ </div>
</td>
</tr>
</tbody>
</table>
</div>
-</g:if>
-<g:if test="${ synchroEnCours }">
- <div style="margin-left:20%;margin-right:20%;display: block;" id="enCours" align="center">
- <br/>
- <br/>
- Une synchronisation est en cours.<br/>
- Un compte rendu sera disponible sur cette même page après le traitement.
- </div>
-</g:if>
-<g:else>
- <g:if test="${ synchroUDTv16 }">
- <div style="margin-left:20%;margin-right:20%;display: block;" id="txtUDT">
- <br/>
- Vous pouvez déclencher la synchronisation directe des emplois du temps sur l'ENT depuis UnDeuxTEMPS version 2013 (v19) ou ultérieure par la commande : "Fichier - Publier vers - l'ENT"
- <br/>
- Un rapport est généré à l'issue de chaque traitement de synchronisation et est présenté ci-dessous.
- <br/> <br/>
- </div>
- </g:if>
- <div style="margin-left:20%;margin-right:20%;display: ${synchroUDTv16 ? "none;" : "block;"}" id="txtEDT">
- <br/>
- Vous pouvez déclencher la synchronisation des emplois du temps sur l'ENT en déposant sur l'ENT les fichiers STS_emp_xxx.xml issu de STS_Web
- et emp_STS_xxx.xml issu de votre logiciel d'emploi du temps.
- <br/>
- Le formulaire ci-dessous vous permet de déposer ces fichiers sur l'ENT.
- Une demande de synchronisation faite pendant la journée est traitée dans la nuit suivante.
- Un compte rendu sera disponible sur cette même page après le traitement.
- <br/> <br/>
- </div>
- <div id="choixFichiers" style="display:${synchroUDTv16 ? "none;" : "block;"}" class="DivContainsTable">
+
+ <div id="texteImport"></div>
+ <div id="choixFichiers" style="display:block;" class="DivContainsTable">
<table id="tableFichiers" class="activities_list tablesorter fullsize">
<thead>
<tr>
- <td class="entete">Dépôt des fichiers STS_emp et emp_STS</td>
+ <td class="entete" id="titreFormDepotFichier"></td>
</tr>
</thead>
<tbody>
<g:if test="${calendrierInitialise}">
<div id="messageImport"></div><br/><br/>
<div align="center">
- <div id="divConteneurFormImport" style="width:380px" class="divFormImport">
+ <div id="divConteneurFormImport" style="width:500px" class="divFormImport">
</div>
</div>
</g:if>
</tbody>
</table>
</g:if>
-</g:else>
</body>
</html>
.x-grid3-check-col-on.disabled {
background-image:url(../images/menu/checked-disabled.gif);
+}
+
+#texteImport {
+ margin-left: 20%;
+ margin-right: 20%;
+ margin-top: 10px;
+ margin-bottom: 10px;
+}
+
+#radioGroupStsUdt {
+ width: 120px;
+ margin-left: auto;
+ margin-right: auto;
}
\ No newline at end of file
Ext.QuickTips.init();
+ this.ecouteRadioGroupImport();
+
this.construireMenu();
- this.form = new Ext.form.FormPanel(
- eliot.importTemps.config.formPanel(
- eliot.importTemps.Constantes.btnSynchroniser
- )
- );
- this.afficherMsgImport();
+ this.majAffichageImport(
+ eliot.importTemps.Constantes.libelle.optionImportParDefaut
+ );
// Problème de render du pannel des boutons sous IE8 (27224)
if (Ext.isIE == true) {
return /((emp_sts_).*.(_).*.(xml)$)/i.test(v);
},
+ udtValide : function(v) {
+ return /UDT-FILES.*\.zip$/i.test(v);
+ },
+
/**
* function pour importer les deux fichiers sts_emp et emp_sts dans
* le serveur
*/
- executeImport : function() {
+ executeImportSts : function() {
var nomFichierStsEmp = Ext.getCmp('idStsEmp').getValue();
var nomFichierEmpSts = Ext.getCmp('idEmpSts').getValue();
if (!this.sts_empValide(nomFichierStsEmp)) {
eliot.importTemps.Application.resetMessages();
eliot.importTemps.Application.showErreur(
- eliot.importTemps.Constantes.messageErreur.
- StsEmp);
+ eliot.importTemps.Constantes.messageErreur.StsEmp);
return
}
if (!this.emp_stsValide(nomFichierEmpSts)) {
eliot.importTemps.Application.resetMessages();
eliot.importTemps.Application.showErreur(
- eliot.importTemps.Constantes.messageErreur.
- EmpSts);
+ eliot.importTemps.Constantes.messageErreur.EmpSts);
+ return
+ }
+
+ this.submitFichiers();
+ },
+
+ /**
+ * function pour importer le fichier udt dans
+ * le serveur
+ */
+ executeImportUdt : function() {
+
+ var nomFichierUdt = Ext.getCmp('idUdt').getValue();
+ if (!this.udtValide(nomFichierUdt)) {
+ eliot.importTemps.Application.resetMessages();
+ eliot.importTemps.Application.showErreur(
+ eliot.importTemps.Constantes.messageErreur.Udt);
return
}
/**
- * Envoyer les deux fichiers sts_emp et emp_sts aux serveur http
+ * Envoyer les deux fichiers sts_emp et emp_sts
+ * ou bien le fichier udt au serveur http
*/
submitFichiers
:
// Envoi des données du formulaire
this.form.getForm().submit({
- params : {
- message : Ext.get("messageImport").dom.childNodes[0].wholeText
- },
// En cas de succès
success: function(form, action) {
- eliot.importTemps.Application.afficherMsgImport();
+ eliot.importTemps.Application.afficherMsgImport(
+ eliot.importTemps.Application.isFormImportUdt(form)
+ );
eliot.importTemps.Application.resetMessages();
eliot.importTemps.Application.showConfirmation(
action.result.msg);
,
/**
* Fonction permettant d'afficher le message de l'import
+ * et de désactiver l'envoi le cas échéant
*/
- afficherMsgImport : function() {
+ afficherMsgImport : function(isFormImportUdt) {
Ext.Ajax.request({
scope : this,
- url : eliot.importTemps.Constantes.urlSelectionFichiersSts,
+ url : isFormImportUdt ?
+ eliot.importTemps.Constantes.urlSelectionFichierUdt :
+ eliot.importTemps.Constantes.urlSelectionFichiersSts,
params : {},
success : function(response, request) {
var reponse = Ext.decode(response.responseText);
Ext.get("messageImport").update(reponse.messageSuccess);
+ if(reponse.desactiverEnvoi) {
+ this.activeBoutons(this.form, false);
+ } else {
+ this.activeBoutons(this.form, true);
+ }
}
});
}
*/
resetMessages: function() {
Ext.get("messages").update('');
- }
+ },
+
+ /**
+ * Ecoute le radioGroupImport
+ */
+ ecouteRadioGroupImport : function() {
+ Ext.select("[name=radioGroupImport]").on("click", function() {
+ eliot.importTemps.Application.majAffichageImport(this.value);
+ });
+ },
+
+ /**
+ * Affiche le formulaire d'import STS-WEB / UDT
+ */
+ afficheFormImport : function(optionImport) {;
+ if(this.form){
+ this.form.destroy();
+ }
+ if(optionImport === eliot.importTemps.Constantes.libelle.optionImportUdt &&
+ eliot.importTemps.Constantes.importManuelUdtActif) {
+ this.form = new Ext.form.FormPanel(
+ eliot.importTemps.config.formPanelUdt()
+ );
+ } else if(optionImport ===
+ eliot.importTemps.Constantes.libelle.optionImportSts) {
+ this.form = new Ext.form.FormPanel(
+ eliot.importTemps.config.formPanelSts(
+ eliot.importTemps.Constantes.btnSynchroniser
+ )
+ );
+ }
+ },
+
+ /**
+ * Indique s'il s'agit du formulaire d'import Udt (ou pas = Sts)
+ */
+ isFormImportUdt : function(formulaire) {
+ return formulaire.url === eliot.importTemps.Constantes.urlImportUdt;
+ },
+ /**
+ * met à jour le titre du formulaire de dépôt de fichier
+ */
+ majTitreFormDepotFichier : function(optionImport) {
+ var divChoixFichiers = Ext.fly("choixFichiers");
+ divChoixFichiers.show();
+ var titre;
+ switch(optionImport) {
+ case eliot.importTemps.Constantes.libelle.optionImportUdt :
+ if(eliot.importTemps.Constantes.importManuelUdtActif){
+ titre = eliot.importTemps.Constantes.title.formDepotFichierUdt;
+ } else {
+ divChoixFichiers.hide();
+ }
+ break;
+ case eliot.importTemps.Constantes.libelle.optionImportSts :
+ titre = eliot.importTemps.Constantes.title.formDepotFichierSts;
+ break;
+ }
+ Ext.fly("titreFormDepotFichier").update(titre);
+ },
+
+ /**
+ * Affiche le texte qui va bien
+ */
+ majTexteImport : function(optionImport) {
+ var texte;
+ switch(optionImport) {
+ case eliot.importTemps.Constantes.libelle.optionImportUdt :
+ if(eliot.importTemps.Constantes.importManuelUdtActif){
+ texte = eliot.importTemps.Constantes.message.importUdtManu;
+ } else {
+ texte = eliot.importTemps.Constantes.message.importUdtAuto;
+ }
+ break;
+ case eliot.importTemps.Constantes.libelle.optionImportSts :
+ texte = eliot.importTemps.Constantes.message.importStsManu;
+ break;
+ }
+ Ext.fly("texteImport").update(texte);
+ },
+
+ /**
+ * Met à jour l'affichage suivant l'option d'import choisie
+ */
+ majAffichageImport : function(optionImport) {
+ this.resetMessages();
+ this.afficheFormImport(optionImport);
+ this.majTexteImport(optionImport);
+ this.majTitreFormDepotFichier(optionImport);
+ this.afficherMsgImport(this.isFormImportUdt(this.form));
+ },
+
+ /**
+ * Active ou désactive les boutons d'un formulaire
+ */
+ activeBoutons : function(formulaire, active) {
+ formulaire.items.each( function(item, index, length) {
+ if(item.getXType() == 'button') {
+ if(active) {
+ item.enable();
+ } else {
+ item.disable();
+ }
+ }
+ });
+ }
});
+
return new Clazz({
name: 'eliot-import-temps-app'
});
Ext.ns('eliot.importTemps');
eliot.importTemps.Constantes = {
- urlImport : undefined,
+ urlImportSts : undefined,
+ urlImportUdt : undefined,
urlSelectionFichiersSts : undefined,
+ urlSelectionFichierUdt : undefined,
urlSynchronisation : undefined,
- menuTitrePrincipal : undefined
+ menuTitrePrincipal : undefined,
+ importManuelUdtActif : undefined
};
eliot.importTemps.Constantes.messageErreur = {
-
+ StsEmp : undefined,
+ EmpSts : undefined,
+ Udt : undefined
};
eliot.importTemps.Constantes.message = {
-
+ importUdtManu : undefined,
+ importUdtAuto : undefined,
+ importStsManu : undefined
};
eliot.importTemps.Constantes.libelle = {
-
+ optionImportParDefaut : undefined,
+ optionImportSts : undefined,
+ optionImportUdt : undefined
};
eliot.importTemps.Constantes.bouton = {
};
eliot.importTemps.Constantes.title = {
-
+ formDepotFichierSts : undefined,
+ formDepotFichierUdt : undefined
};
eliot.importTemps.Constantes.environnement = {
/**
- * Construit la configuration du formPanel
+ * Construit la configuration du formPanel STS-web
* @param btnSynchronisation si true, le formPanel contiendra le bouton de
* lancement de la synchronisation
*/
-eliot.importTemps.config.formPanel = function(btnSynchronisation) {
+eliot.importTemps.config.formPanelSts = function(btnSynchronisation) {
var config = {
renderTo:'divConteneurFormImport',
cls:'formImport',
fileUpload: true,
- url: eliot.importTemps.Constantes.urlImport,
+ url: eliot.importTemps.Constantes.urlImportSts,
autoScroll:true,
items :[
{
autoScroll:true,
items: [
{
- x: 100,
- y: 5,
fieldLabel:eliot.importTemps.Constantes.libelle.StsEmp,
id: 'idStsEmp',
xtype:'textfield',
labelWidth:200
},
{
- x: 100,
- y: 30,
fieldLabel:eliot.importTemps.Constantes.libelle.EmpSts,
id: 'idEmpSts',
xtype:'textfield',
inputType:'file'
},
{
- x:0,
- y:80,
id : 'zoneErreur',
xtype : 'panel',
baseCls: 'x-plain'
]
},
{
- x: 370,
- y: 180,
xtype : 'button',
+ style : "margin-right:60px;",
text : eliot.importTemps.Constantes.bouton.envoyer,
width : 100,
title: eliot.importTemps.Constantes.title.importer,
listeners : {
click : {
fn : function() {
- eliot.importTemps.Application.executeImport();
+ eliot.importTemps.Application.executeImportSts();
},
scope : this
}
if (btnSynchronisation) {
config.items.push(
{
- x: 370,
- y: 220,
xtype : 'button',
id : "synchroniserImportSts",
text : eliot.importTemps.Constantes.bouton.synchroniser,
}
return config;
-};
\ No newline at end of file
+};
+
--- /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>.
+ */
+
+/**
+ * Configuration la form panel
+ * @author:wy
+ **/
+Ext.ns('eliot.importTemps.config');
+
+
+/**
+ * Construit la configuration du formPanel UDT
+ */
+eliot.importTemps.config.formPanelUdt = function () {
+ var config = {
+ renderTo: 'divConteneurFormImport',
+ cls: 'formImport',
+ fileUpload: true,
+ url: eliot.importTemps.Constantes.urlImportUdt,
+ autoScroll: true,
+ with : 550,
+ layout: 'column',
+ items: [
+ {
+ layout: 'form',
+ labelWidth: 130,
+ width:400,
+ items: {
+ fieldLabel: eliot.importTemps.Constantes.libelle.Udt,
+ id: 'idUdt',
+ xtype: 'textfield',
+ msgTarget: "messages",
+ inputType: 'file'
+ }
+ },
+ {
+ xtype: 'button',
+ text: eliot.importTemps.Constantes.bouton.envoyer,
+ width: 100,
+ title: eliot.importTemps.Constantes.title.importer,
+ listeners: {
+ click: {
+ fn: function () {
+ eliot.importTemps.Application.executeImportUdt();
+ },
+ scope: this
+ }
+ }
+ }
+ ]
+ };
+
+ return config;
+};
+