2841 lines
126 KiB
Java
2841 lines
126 KiB
Java
package MEPTL;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.BufferedWriter;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.nio.charset.Charset;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.text.DecimalFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.Dictionary;
|
|
import java.util.Enumeration;
|
|
import java.util.Hashtable;
|
|
import java.util.regex.Pattern;
|
|
|
|
import javax.swing.JEditorPane;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import org.xml.sax.SAXException;
|
|
import cXML.node;
|
|
import calcul.formatDateWriter;
|
|
import evaluer.analyseFichier;
|
|
import evaluer.evaluation;
|
|
import cXML.Run;
|
|
import cXML.Run.UserStatus;
|
|
import net.lingala.zip4j.exception.ZipException;
|
|
|
|
|
|
/**
|
|
*
|
|
* @author pablo rodriguez
|
|
*
|
|
*
|
|
*/
|
|
public class meptl {
|
|
|
|
static DecimalFormat df = new DecimalFormat("###.##");
|
|
//static String patch ="";
|
|
static double progression = 1.0;
|
|
|
|
/**
|
|
* Ancienne version en mode console</br>
|
|
* Démarrage de l'application.<br>
|
|
* <br>
|
|
* @param args : les commandes de l'application.
|
|
* @throws ParserConfigurationException
|
|
* @throws SAXException
|
|
* @throws IOException
|
|
* @throws CloneNotSupportedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException, CloneNotSupportedException, InterruptedException {
|
|
System.getProperty("file.encoding","UTF-8");
|
|
commandes.path = System.getProperty("user.dir");
|
|
// patch = "C:/Users/pabr6/OneDrive/Desktop/Nouveau dossier";
|
|
|
|
//*******************
|
|
//** les commandes **
|
|
//*******************
|
|
new commandes(args,commandes.path);
|
|
|
|
|
|
//** Nouveau node qui permet de convertir le fichier contenant la liste des étudiants en node.
|
|
node nodeCSV = null;
|
|
|
|
//**********************************
|
|
//** Initialisation des variables **
|
|
//**********************************
|
|
Run a = null;
|
|
Run.path = commandes.path;
|
|
int nbFichierWriter=0;
|
|
|
|
if(!commandes.calculLeHashDuFichier&&!commandes.ecritSujet) {
|
|
//*****************************************************
|
|
//** Lancement des lectures des dossiers ou fichiers **
|
|
//*****************************************************
|
|
a = new Run(commandes.path,commandes.Profil, commandes.fichierStudentMoodle);
|
|
|
|
|
|
//*****************************************
|
|
//** Nombre de fichier writer à analyser **
|
|
//*****************************************
|
|
nbFichierWriter = a.getLectDossiers().getEC().getListeContentWriter().size();
|
|
}
|
|
|
|
//************
|
|
//** -sujet **
|
|
//************
|
|
if(commandes.ecritSujet) {
|
|
verificationFichierAnalyse.ecrisLeFichierSujetXML();
|
|
}
|
|
|
|
|
|
//****************************************************************************
|
|
//** Calcul le hash du fichier d'analyse et met à jour le fichier d'analyse **
|
|
//****************************************************************************
|
|
if(commandes.calculLeHashDuFichier) {
|
|
verificationFichierAnalyse.MiseAJourFichierAnalyse();
|
|
}
|
|
|
|
|
|
//*****************
|
|
//** -writefiles **
|
|
//*****************
|
|
if(commandes.writefiles) {
|
|
for(int i = 0 ; i < nbFichierWriter ; i++) {
|
|
//** Chargement du format (content) et transformation en node pour l'application
|
|
node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
|
|
node nodStudent = LectureFichierEtudiantSousFormeDeNode(nod,a,i);
|
|
Run.ecritureNodeEnXML(nodStudent, a.getLectDossiers().getEC().getListeNomDossier().get(i),commandes.path,Run.TypeFile.StudentFile); //écriture du node de l'étudiant
|
|
}
|
|
//** bye bye analyseWriter
|
|
commandes.clotureApplication();
|
|
}
|
|
|
|
//********************************************************
|
|
//** Ecriture d'une fichier d'analyse : commande -write **
|
|
//********************************************************
|
|
if(commandes.ecritCode) {
|
|
for(int index = 0 ; index < nbFichierWriter ; index++) {
|
|
node nodSujet = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(index));
|
|
nodSujet = LectureFichierEtudiantSousFormeDeNode(nodSujet,a,index);
|
|
nodSujet.getAttributs().put("analysis_filename", a.getLectDossiers().getEC().getListeNomDossier().get(index)+".xml");
|
|
nodSujet = ecritureSujet.nodePourEcritureSujet(nodSujet,a,index);
|
|
Run.ecritureNodeEnXML(nodSujet, a.getLectDossiers().getEC().getListeNomDossier().get(index),commandes.path,Run.TypeFile.Sujet);
|
|
}
|
|
//** bye bye analyseWriter
|
|
commandes.clotureApplication();
|
|
}
|
|
|
|
|
|
//*********************************************************************************************
|
|
//** PREPARATION du node Sujet pour les commandes (-use file.xml) ou (-use file.xml -sujet) **
|
|
//*********************************************************************************************
|
|
if(commandes.analyse||commandes.ecritNodeAnalyse) {
|
|
commandes.sujet = chargementFichierAnalyse(commandes.nameSujet, true);
|
|
|
|
if(commandes.sujet==null) {
|
|
//***************************
|
|
//** bye bye analyseWriter **
|
|
//***************************
|
|
commandes.clotureApplicationAvecErreur();
|
|
}
|
|
|
|
//******************************************************************************************************
|
|
//** La méthode verification Fichier Analyse permet de détecter des erreurs dans le fichier d'analyse **
|
|
//** Permet aussi de verifier la mise à jour du hash ou du nom du fichier d'analyse **
|
|
//******************************************************************************************************
|
|
new verificationFichierAnalyse();
|
|
|
|
|
|
if(verificationFichierAnalyse.erreur==true) verificationFichierAnalyse.clotureWithErrorInanalyzeFile();
|
|
//a.ecritureNodeEnXML(nodeSujet, "sujet","",false); // ecriture du node sujet
|
|
|
|
//****************************************************
|
|
//** Chargement des paramètres du fichier d'analyse **
|
|
//****************************************************
|
|
chargementParametresFichierAnalyse();
|
|
|
|
//************************************************
|
|
//** Nouvelle ecriture du fichier si MAJ fichier**
|
|
//************************************************
|
|
if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
|
|
commandes.sujet.getAttributs().put("hash", commandes.hash);
|
|
commandes.sujet.getAttributs().put("analysis_filename", commandes.nameSujet);
|
|
}
|
|
|
|
try {
|
|
|
|
//***********************
|
|
//** -newlogo file.svg **
|
|
//***********************
|
|
if(commandes.newLogo && !commandes.nameSVG.isEmpty()) {
|
|
commandes.contenuFichierSVG= chargementFichierSVG();
|
|
}
|
|
|
|
//**********************************************
|
|
//** Chargement et verification du CVS fourni **
|
|
//**********************************************
|
|
if(commandes.fourniCSV) {
|
|
nodeCSV = chargementFichierCSV();
|
|
}
|
|
|
|
}catch (Exception e) {
|
|
System.out.println(e);
|
|
}
|
|
|
|
}
|
|
|
|
//***************************************
|
|
//** -verif ou -use file.xml -verifcsv **
|
|
//***************************************
|
|
node verif = new node();
|
|
if(commandes.verifHisto || commandes.verifHisto2) {
|
|
node verification = new node();
|
|
verification.setNomElt("verification");
|
|
verification.getAttributs().put("nombre_fichier", String.valueOf(a.getLectDossiers().getEC().getListeFichierodt().size()));
|
|
for(int i = 0 ; i < nbFichierWriter ; i++) {
|
|
node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
|
|
node nodStudent = LectureFichierEtudiantPourVerification(nod,a,i);
|
|
verification.getNodes().add(nodStudent);
|
|
}
|
|
//a.ecritureNodeEnXML(verification, "VerificationHistorique","",false); //écriture du node de l'étudiant
|
|
verif = verificationHistorique(verification, a); // vérification des correspondances entre les fichiers
|
|
|
|
//********************************
|
|
//** Ecriture du node verif.xml **
|
|
//********************************
|
|
Run.ecritureNodeEnXML(verif, "Verif",commandes.path,Run.TypeFile.Verif); //écriture du node de vérification
|
|
if(!commandes.analyse) {
|
|
//** bye bye analyseWriter
|
|
commandes.clotureApplication();
|
|
}
|
|
}
|
|
|
|
System.getProperty("file.encoding","UTF-8");
|
|
|
|
//*********************************************************
|
|
//** Node contenant l'ensemble des analyses des étudiants **
|
|
//*********************************************************
|
|
node ensembleanalyse = new node();
|
|
ensembleanalyse.setNomElt("analyses");
|
|
|
|
|
|
//*****************************************************
|
|
//** Parcours l'ensemble des fichiers des étudiants ***
|
|
//*****************************************************
|
|
for(int i = 0 ; i < nbFichierWriter ; i++) {
|
|
|
|
//** Ne prends pas en compte le dossier destination créé par la commande -dest
|
|
//** Si pas d'analyse alors le nom doit contenir le caractère $ dans le nom du dossier.
|
|
if(commandes.fourniDossierDestination)if(a.getLectDossiers().getEC().getListeNomDossier().get(i).equals(commandes.pathDestination)) continue;
|
|
|
|
//***********************************************************
|
|
//** Lecture et transformation en node du fichier étudiant **
|
|
//***********************************************************
|
|
node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
|
|
node nodStudent = LectureFichierEtudiantSousFormeDeNode(nod,a,i);
|
|
//a.ecritureNodeEnXML(nodStudent, a.getLectDossiers().getEC().getListeNomDossier().get(i),"",false,""); //écriture du node de l'étudiant
|
|
|
|
//**********************************
|
|
//** Analyse des fichiers student **
|
|
//**********************************
|
|
JEditorPane txt = new JEditorPane();
|
|
if(commandes.analyse||commandes.ecritNodeAnalyse) {
|
|
|
|
if(!verificationFichierAnalyse.erreur) {
|
|
// Run.ecritureNodeEnXML(nodStudent, "fichier student","",false,""); //écriture du node nodStudent de l'étudiant
|
|
node ana = analyseFichier.analyse(nodStudent, commandes.sujet, i, a,txt,"0");
|
|
|
|
//**************************************************
|
|
//** Ecriture des fichiers d'analyse des students **
|
|
//**************************************************
|
|
if(commandes.ecritNodeAnalyse) {
|
|
Run.ecritureNodeEnXML(ana, "nodana"+ana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"),commandes.path,Run.TypeFile.Analyse); //écriture du node analyse de l'étudiant
|
|
}
|
|
|
|
//****************************
|
|
//** Création des feedbacks **
|
|
//****************************
|
|
if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
|
|
if(!commandes.zipfeedback) {
|
|
//feedback(ana, verif); //classique directement dans le répertoire
|
|
feedbacks.feedback(ana,verif, false, false);
|
|
}
|
|
if(commandes.zipfeedback) { // Dans une archive pour Moodle
|
|
try {
|
|
a.AddStreamToZip(feedbacks.feedback(ana, verif, true, false), retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
|
|
} catch (ZipException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
//********************************************************************************
|
|
//** Ajoute au node ensembleanalyse lorsque -csv file.csv ou -verifcsv file.scv **
|
|
//********************************************************************************
|
|
if(commandes.ecritNoteCSV) ensembleanalyse.addNode(ana);
|
|
|
|
//*********************************************************
|
|
//** Message dans la console sur l'analyse de l'étudiant **
|
|
//*********************************************************
|
|
messageSystem(ana);
|
|
}else {
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if(commandes.sujet!=null) {
|
|
//*****************************************************
|
|
//** Exportation au format CSV si -csv ou -verifcsv **
|
|
//*****************************************************
|
|
if(commandes.ecritNoteCSV && !commandes.fourniCSV) {
|
|
if(!commandes.verifHisto2) ecritureCSV(ensembleanalyse);
|
|
if(commandes.verifHisto2) ecritureCSV(ensembleanalyse,verif,a,commandes.sujet.retourneFirstEnfantsByName("setting"));
|
|
//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
|
|
}
|
|
|
|
//***********************************************************************
|
|
//** Exportation au format CSV si -csv file.csv ou -verifcsv file.csv **
|
|
//***********************************************************************
|
|
if(commandes.ecritNoteCSV && commandes.fourniCSV) {
|
|
ecritureCSV(ensembleanalyse,verif,a,nodeCSV, commandes.sujet.retourneFirstEnfantsByName("setting"));
|
|
//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
|
|
}
|
|
|
|
//**************************************
|
|
//** Mise à jour du fichier d'analyse **
|
|
//**************************************
|
|
if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
|
|
verificationFichierAnalyse.MiseAJourFichierAnalyse();
|
|
verificationFichierAnalyse.messagMiseAJourFichierAnalyseAprèsAnalyse();
|
|
}
|
|
}
|
|
|
|
//***************************
|
|
//** bye bye analyseWriter **
|
|
//***************************
|
|
commandes.clotureApplication();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Lecture du fichier Student pour vérification des historiques.<br>
|
|
* <br>
|
|
* @param nod node
|
|
* @param a
|
|
* @param i
|
|
* @return
|
|
*/
|
|
public static node LectureFichierEtudiantPourVerification(node nod, Run a, Integer i) {
|
|
node fichier = new node();
|
|
fichier.setNomElt("fichier");
|
|
fichier.getAttributs().put("filename", a.getLectDossiers().getEC().getListeFichierodt().get(i));
|
|
fichier.getAttributs().put("dossier", a.getLectDossiers().getEC().getListeNomDossier().get(i));
|
|
|
|
|
|
node nodmeta = nod.retourneFirstEnfantsByName("office:meta");
|
|
if(!nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().get(0));
|
|
}else {
|
|
fichier.getAttributs().put("producteur", "nobody");
|
|
}
|
|
if(!nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().get(0));
|
|
}else {
|
|
fichier.getAttributs().put("producteur", "unknow");
|
|
}
|
|
if(!nodmeta.retourneFirstEnfantsByName("dc:date").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("dateModification", nodmeta.retourneFirstEnfantsByName("dc:date").getContenu().get(0));
|
|
}else {
|
|
fichier.getAttributs().put("dateModification", "unknow");
|
|
}
|
|
if(!nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("dureeEdition", nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().get(0));
|
|
}else {
|
|
fichier.getAttributs().put("dureeEdition", "unknow");
|
|
}
|
|
fichier.getNodes().add(nodmeta);
|
|
|
|
node nodhistorique = new node();
|
|
int nbrModif = nod.retourneFirstEnfantsByName("text:tracked-changes").getNodes().size();
|
|
nodhistorique.setNomElt("historique");
|
|
nodhistorique.getAttributs().put("nbrModif", String.valueOf(nbrModif));
|
|
nodhistorique.getNodes().addAll(a.retourneNames(a.NodeFirstName(nod, "office:text"), "text:tracked-changes"));
|
|
fichier.getNodes().add(nodhistorique);
|
|
|
|
return fichier;
|
|
}
|
|
|
|
/**
|
|
* Retourne le node menu qui est réalisé à partir de l'attibut "<b>addmenu=true</b>".<br>
|
|
* L'attribut "<b>addmenu=true</b>" se trouve uniquement dans les node de niveu 1 (les nodes principaux).<br>
|
|
*
|
|
* @param nod Le node dans lequel on recherche les node
|
|
* @param menu Le node menu.
|
|
* @param niv Le niveau du node.
|
|
* @param Compteur Le compteur permet d'incrémenter les niveaux des nodes.
|
|
* @return Le node menu est retourner avec des nodes "<b>item</b>" ajoutés.
|
|
*/
|
|
public static node retourneNodeMenu(node nod , node menu, Integer niv, Integer Compteur) {
|
|
|
|
if(nod==null) return null;
|
|
|
|
if(nod.getAttributs().get("addmenu")!=null) {
|
|
|
|
boolean erreur = false;
|
|
|
|
if(nod.getAttributs().get("addmenu").equals("true")) {
|
|
node newnode = new node();
|
|
newnode.setNomElt("item");
|
|
String titre ="";
|
|
if(nod.getAttributs().get("titre")!=null) {
|
|
titre = nod.getAttributs().get("titre");
|
|
newnode.getAttributs().put("titre",titre);
|
|
}
|
|
if(nod.getAttributs().get("titre1")!=null) {
|
|
titre = nod.getAttributs().get("titre1");
|
|
newnode.getAttributs().put("titre",titre);
|
|
}
|
|
if(nod.getAttributs().get("titre2")!=null) {
|
|
titre = nod.getAttributs().get("titre2");
|
|
newnode.getAttributs().put("titre",titre);
|
|
}
|
|
if(nod.getAttributs().get("titre3")!=null) {
|
|
titre = nod.getAttributs().get("titre3");
|
|
newnode.getAttributs().put("titre",titre);
|
|
}
|
|
newnode.getAttributs().put("niveau",String.valueOf(niv));
|
|
newnode.getAttributs().put("name",nod.getNomElt());
|
|
newnode.getAttributs().put("id","#M"+ titre.replace(" ", ""));
|
|
menu.getNodes().add(newnode);
|
|
}
|
|
|
|
|
|
if(nod.getAttributs().get("evaluer")!=null) {
|
|
|
|
if(nod.getAttributs().get("evaluer").equalsIgnoreCase("true")) {
|
|
if(nod.getAttributs().get("addmenu").equals("false") && niv==1) {
|
|
System.out.println();
|
|
System.out.println("** ERREUR -- L'attribut \"addmenu\" n'est pas associé au node principal <" + nod.getNomElt() + "> dans le fichier d'analyse.");
|
|
System.out.println("** -- Changer la valeur de l'attribut \"addmenu\" à TRUE.");
|
|
System.out.println();
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n ERREUR L'attribut \"addmenu\" n'est pas associé au node principal <" + nod.getNomElt() + "> dans le fichier d'analyse.");
|
|
commandes.message.append("\n Changer la valeur de l'attribut \"addmenu\" à TRUE.");
|
|
commandes.message.append("\n******************************************************");
|
|
erreur =true;
|
|
}
|
|
|
|
if(nod.getAttributs().get("addmenu").equals("true") && nod.getAttributs().get("titre")==null && nod.getAttributs().get("titre1")==null && nod.getAttributs().get("titre2")==null && nod.getAttributs().get("titre3")==null) {
|
|
System.out.println();
|
|
System.out.println("** WARNING -- L'attribut \"addmenu\" n'est pas associé à un titre dans le node <" + nod.getNomElt() + ">, dans le fichier d'analyse.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\nAVERTISSEMENT -- L'attribut \"addmenu\" n'est pas associé à un titre dans le node <" + nod.getNomElt() + ">, dans le fichier d'analyse.");
|
|
commandes.message.append("\n******************************************************");
|
|
|
|
if(nod.getAttributs().get("titre")==null && nod.getAttributs().get("titre1")==null && nod.getAttributs().get("titre2")==null && nod.getAttributs().get("titre3")==null){
|
|
System.out.println("** -- Ajouter l'attribut \"titre\" à ce node.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n Ajouter l'attribut \"titre\" à ce node.");
|
|
commandes.message.append("\n******************************************************");
|
|
}
|
|
|
|
if(nod.getAttributs().get("titre").isEmpty()){
|
|
System.out.println("** -- Ajouter l'attribut \"titre\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n Ajouter l'attribut \"titre\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
}
|
|
if(nod.getAttributs().get("titre1").isEmpty()){
|
|
System.out.println("** -- Ajouter l'attribut \"titre1\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n Ajouter l'attribut \"titre1\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
}
|
|
if(nod.getAttributs().get("titre2").isEmpty()){
|
|
System.out.println("** -- Ajouter l'attribut \"titre2\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n Ajouter l'attribut \"titre2\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
}
|
|
if(nod.getAttributs().get("titre3").isEmpty()){
|
|
System.out.println("** -- Ajouter l'attribut \"titre2\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
commandes.message.append("\n Ajouter l'attribut \"titre2\" une valeur.");
|
|
commandes.message.append("\n******************************************************");
|
|
}
|
|
System.out.println();
|
|
erreur =true;
|
|
}
|
|
|
|
//***************************
|
|
//** bye bye analyseWriter **
|
|
//***************************
|
|
if(commandes.console) if(erreur) commandes.clotureApplicationAvecErreur();
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
for(int i = 0 ; i < nod.getNodes().size();i++) {
|
|
menu = retourneNodeMenu(nod.getNodes().get(i), menu, niv+1, Compteur++);
|
|
}
|
|
|
|
return menu;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Lecture du fichier Writer des étudiants et fournir tous les nodes de la lecture dans un node nommé "fichier".<br>
|
|
* Permet aussi de créer un fichier d'analyse à partir d'un fichier ODF.<br>
|
|
* @param nod Le node Writer de l'étudiant.
|
|
* @param a Objet de la class Run package cXML
|
|
* @param i Index de l'étudiant dans la liste EC de l'objet a.
|
|
* @return le node contenant tous les nodes de la lectures.
|
|
* @throws IOException Input Output exception file.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static node LectureFichierEtudiantSousFormeDeNode(node nod, Run a, Integer i) throws IOException {
|
|
node nodecontent = nod.retourneFirstEnfantsByName("office:document-content");
|
|
node nodestyle = nod.retourneFirstEnfantsByName("office:document-styles");
|
|
node nodbody = nod.retourneFirstEnfantsByName("office:text"); //a.NodeFirstName(nodecontent, "office:text");
|
|
//
|
|
node nodmeta = nod.retourneFirstEnfantsByName("office:meta");
|
|
|
|
// ajoute les créateurs ou éditeur dans les nodes dc:creator ou meta:initial-creator
|
|
// Pour permettre l'analyse avec les attributs evalNameCreator ou evalNameInitialCreator
|
|
if(nodmeta.retourneEnfantsByNameExist("dc:creator")) {
|
|
if(a.getLectDossiers().getEC().getListeNomDossier().get(i)!=null) {
|
|
nodmeta.retourneFirstEnfantsByName("dc:creator").getAttributs().put("creator", a.getLectDossiers().getEC().getListeNomDossier().get(i));
|
|
}else {
|
|
nodmeta.retourneFirstEnfantsByName("dc:creator").getAttributs().put("creator", "null");
|
|
}
|
|
}
|
|
|
|
if(nodmeta.retourneEnfantsByNameExist("meta:initial-creator")) {
|
|
if(a.getLectDossiers().getEC().getListeNomDossier().get(i)!=null) {
|
|
nodmeta.retourneFirstEnfantsByName("meta:initial-creator").getAttributs().put("initial-creator", a.getLectDossiers().getEC().getListeNomDossier().get(i));
|
|
}else {
|
|
nodmeta.retourneFirstEnfantsByName("meta:initial-creator").getAttributs().put("initial-creator", "null");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
node nodstyle = new node();
|
|
nodstyle.setNomElt("styles");
|
|
nodstyle.addNode(a.NodeFirstName(nodecontent,"office:automatic-styles"));
|
|
nodstyle.addNode(a.NodeFirstName(nodestyle, "office:automatic-styles"));
|
|
nodstyle.addNode(a.NodeFirstName(nodestyle, "office:styles"));
|
|
nodstyle.addNode(a.NodeFirstName(nodestyle, "office:master-styles"));
|
|
|
|
// Le node des styles de page
|
|
node nodstylepage = new node();
|
|
nodstylepage.setNomElt("style:page");
|
|
nodstylepage.addNode(a.retourneNames(nodstyle, "style:master-page"));
|
|
for(int j = 0 ; j < nodstylepage.getNodes().size();j++) {
|
|
if(nodstylepage.getNodes().get(j).getAttributs().get("style:page-layout-name")!=null) {
|
|
node nod1 = a.retourneFirstNodeByNameAttributValue(nodstyle, "style:page-layout", "style:name", nodstylepage.getNodes().get(j).getAttributs().get("style:page-layout-name"));
|
|
if(nod1!=null) nodstylepage.getNodes().get(j).addNode(nod1);
|
|
}
|
|
}
|
|
|
|
// le node des styles de paragraphe
|
|
node nodstyleparagraphe = new node();
|
|
nodstyleparagraphe.setNomElt("style:paragraph");
|
|
nodstyleparagraphe.addNode(a.NodesAyantAttribut(nodstyle, "style:family","paragraph"));
|
|
nodstyleparagraphe.addNode(a.NodesAyantAttribut(nodstyle, "style:family","text"));
|
|
nodstyleparagraphe.addNode(a.NodesAyantAttribut(nodstyle, "style:family","section"));
|
|
nodstyleparagraphe.addNode(a.NodesAyantAttribut(nodstyle, "style:family","graphic"));
|
|
nodstyleparagraphe = ajouteValeurLesValeursDuStyleParagraphParent(nodstyleparagraphe);
|
|
nodstyleparagraphe = ajouteValeurParDefautAuStyleParagraph(nodstyleparagraphe);
|
|
|
|
|
|
//Le node numérotation des chapitres
|
|
node nodnumerochapitre = new node();
|
|
nodnumerochapitre.setNomElt("numerotationchapitre");
|
|
nodnumerochapitre.addNode(a.retourneNames(nodstyle, "text:outline-level-style"));
|
|
|
|
|
|
// le node variable de sequence
|
|
node nodsequence = new node();
|
|
nodsequence.setNomElt("sequences");
|
|
nodsequence.addNode(a.retourneNames(nodbody, "text:sequence-decl"));
|
|
|
|
|
|
// le node des frames : renomme les nodes style:style avec le nom de draw:name exemple style:styledraw:name
|
|
// si une draw:text-box contenant un attribut fo:min-height alors ajoute dans darw:farme l'attribut svg:height
|
|
node nodframe = new node();
|
|
nodframe.setNomElt("frames");
|
|
nodframe.addNode(a.retourneNames(nodbody, "draw:frame")); //Problème place des doublons dans la liste des nodes
|
|
for(int j = 0 ; j < nodframe.getNodes().size(); j++) {
|
|
node nodframestyle = a.retourneFirstNodeByNameAttributValue(nodstyle, "style:style", "style:name", nodframe.getNodes().get(j).getAttributs().get("draw:style-name"));
|
|
String nomObjet = nodframe.getNodes().get(j).getAttributs().get("draw:name");
|
|
if(nomObjet!=null) {
|
|
nomObjet= nomObjet.replace(" ", "_");
|
|
if(nodframestyle!=null) nodframestyle.setNomElt("style:style"+nomObjet);
|
|
}
|
|
nodframe.getNodes().get(j).getNodes().add(nodframestyle);
|
|
if(a.retourneName(nodframe.getNodes().get(j), "draw:text-box", "fo:min-height")!=null) {
|
|
nodframe.getNodes().get(j).getAttributs().put("svg:height", a.retourneName(nodframe.getNodes().get(j), "draw:text-box", "fo:min-height").getAttributs().get("fo:min-height"));
|
|
}
|
|
}
|
|
|
|
|
|
// le node section
|
|
node nodsection = new node();
|
|
nodsection.setNomElt("sections");
|
|
nodsection.addNode(a.retourneNames(nodbody, "text:section"));
|
|
|
|
// le node table:table
|
|
node nodtableaux = new node();
|
|
nodtableaux.setNomElt("tableaux");
|
|
nodtableaux.addNode(a.retourneNames(nodbody, "table:table"));
|
|
|
|
// la bibliographie
|
|
node nodbiblio = new node();
|
|
nodbiblio.setNomElt("biblio");
|
|
nodbiblio.addNode(a.retourneNames(nodbody, "text:bibliography"));
|
|
|
|
//table des matieres
|
|
node nodtable = new node();
|
|
nodtable.setNomElt("tablematieres");
|
|
// nodtable.addNode(a.retourneNames(nodbody, "text:table-of-content"));
|
|
// renomme le node text:table-of-content-source en text:table-of-content-sourceTitreIndex
|
|
ArrayList<node> A = a.retourneNames(nodbody, "text:table-of-content");
|
|
for(int j = 0 ; j<A.size(); j++) {
|
|
String titreIndex=A.get(j).retourneFirstEnfantsByName("text:index-title-template").getContenu().get(0).toLowerCase();
|
|
titreIndex = titreIndex.replace(" ", "_");
|
|
A.get(j).retourneFirstEnfantsByName("text:table-of-content-source").setNomElt("text:table-of-content-source"+titreIndex);
|
|
nodtable.getNodes().add(A.get(j));
|
|
}
|
|
|
|
|
|
|
|
//index illustration
|
|
node nodillustrations = new node();
|
|
nodillustrations.setNomElt("tableillustrations");
|
|
//nodillustrations.addNode(a.retourneNames(nodbody, "text:illustration-index")); //avant
|
|
// renomme le node text:illustration-index-source en text:illustration-index-sourceTitreIndex
|
|
A = a.retourneNames(nodbody, "text:illustration-index");
|
|
for(int j = 0 ; j<A.size(); j++) {
|
|
String titreIndex=A.get(j).retourneFirstEnfantsByName("text:index-title-template").getContenu().get(0);
|
|
titreIndex = titreIndex.replace(" ", "_");
|
|
A.get(j).retourneFirstEnfantsByName("text:illustration-index-source").setNomElt("text:illustration-index-source"+titreIndex);
|
|
nodillustrations.getNodes().add(A.get(j));
|
|
}
|
|
|
|
|
|
//historique des modifications
|
|
node nodhistorique = new node();
|
|
int nbrModif = nodbody.retourneFirstEnfantsByName("text:tracked-changes").getNodes().size();
|
|
nodhistorique.setNomElt("historique");
|
|
nodhistorique.getAttributs().put("nbrModif", String.valueOf(nbrModif));
|
|
nodhistorique.getNodes().addAll(a.retourneNames(nodbody, "text:tracked-changes"));
|
|
|
|
//*********************************************************
|
|
//** Création du node structure à partir du node nodbody **
|
|
//*********************************************************
|
|
node nodstructure = new node();
|
|
nodstructure.setNomElt("structure");
|
|
for(int j = 0 ; j < nodbody.getNodes().size();j++) {
|
|
String nomNode = nodbody.getNodes().get(j).getNomElt();
|
|
if(nomNode.equals("draw:frame")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:p")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:h")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:table-of-content")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:list")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:illustration-index")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:bibliography")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("table:table")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
if(nomNode.equals("text:section")) nodstructure.addNode(nodbody.getNodes().get(j));
|
|
}
|
|
|
|
|
|
// Struture et composition du document avec les pages
|
|
// cette boucle utilise le node nodstructure
|
|
ArrayList<node> nodpage = new ArrayList<node>();
|
|
node page = new node();
|
|
page.setNomElt("page");
|
|
page.getAttributs().put("numero", "0");
|
|
page.getAttributs().put("style:master-page-name", "Standard"); // style par défaut des pages
|
|
nodpage.add(page);
|
|
|
|
int compteurpage = 1;
|
|
|
|
for(int j = 0 ; j< nodstructure.getNodes().size();j++) {
|
|
|
|
page = nodpage.get(nodpage.size()-1); // dernière page enregistrer pour insérer des enfants en bas de la boucle
|
|
|
|
//******************************************************************************
|
|
//** les sauts automatiques de page dans les paragraphes (text:soft-page-break)
|
|
//******************************************************************************
|
|
if(nodstructure.getNodes().get(j).retourneEnfantsByNameExist("text:soft-page-break")) {
|
|
ArrayList<node> nods1 = a.retourneNames(nodstructure.getNodes().get(j), "text:soft-page-break");
|
|
|
|
if(nods1.size()>1) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","automatique");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
|
|
// recherche de l'index parmis les enfants du node text:soft-page-break.
|
|
int[] indexBreak = new int[nods1.size()];
|
|
indexBreak[0]=0;
|
|
for(int v = 0 ; v < nods1.size() ; v++) {
|
|
indexBreak[v]=-1;
|
|
}
|
|
|
|
int i2 = 0;
|
|
for(int v = 0 ; v < nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getNodes().get(v).getNomElt().equals("text:soft-page-break")) {
|
|
indexBreak[i2]=v;
|
|
i2++;
|
|
}
|
|
}
|
|
|
|
|
|
//Détermine s'il y a que du texte vide avant le saut automatique
|
|
boolean[] ContenusVidesAvantBreak = new boolean[nods1.size()];
|
|
boolean[] insertionRealiser = new boolean[nods1.size()];
|
|
for(int v = 0 ; v < nods1.size() ; v++) {
|
|
ContenusVidesAvantBreak[v]=true;
|
|
insertionRealiser[v]=false;
|
|
}
|
|
|
|
for(int u = 0; u < nods1.size() ; u++) {
|
|
for(int v = 0 ; v <= indexBreak[u]; v++) {
|
|
if(nodstructure.getNodes().get(j).getContenu().get(v)!=null) {
|
|
if(ContenusVidesAvantBreak[u]) {
|
|
if(!nodstructure.getNodes().get(j).getContenu().get(v).isEmpty()) {
|
|
ContenusVidesAvantBreak[u]=false;
|
|
}
|
|
}
|
|
if(v==indexBreak[u] && !ContenusVidesAvantBreak[u]) {
|
|
nodstructure.getNodes().get(j).getContenu().set(
|
|
v,nodstructure.getNodes().get(j).getContenu().get(v) + "** TEXT:SOFT-PAGE-BREAK **");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Contenu & node après le text:soft-page-break
|
|
node[] textSoftPageBreak = new node[nods1.size()];
|
|
|
|
|
|
for(int u = 0; u < nods1.size() ; u++) {
|
|
textSoftPageBreak[u] = new node();
|
|
textSoftPageBreak[u].setNomElt("saut:automatique");
|
|
|
|
if(!ContenusVidesAvantBreak[u]) {
|
|
// Ajoute dans le node textSoftPageBreak
|
|
for(int v = indexBreak[u]+1 ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getContenu().size()>v) {
|
|
textSoftPageBreak[u].getContenu().add(nodstructure.getNodes().get(j).getContenu().get(v));
|
|
}
|
|
if(nodstructure.getNodes().get(j).getNodes().size()>v) {
|
|
textSoftPageBreak[u].getNodes().add(nodstructure.getNodes().get(j).getNodes().get(v));
|
|
}
|
|
}
|
|
|
|
// suprresion des contenus et des nodes enfants dans le paragraphe dans le paragraphe
|
|
for(int v = indexBreak[u]+1 ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getContenu().size()>indexBreak[u]+1) nodstructure.getNodes().get(j).getContenu().remove(indexBreak[u]+1);
|
|
}
|
|
|
|
for(int v = indexBreak[u] ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getNodes().size()>indexBreak[u]) nodstructure.getNodes().get(j).getNodes().remove(indexBreak[u]);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for(int u = 0; u < nods1.size() ; u++) {
|
|
|
|
|
|
if(ContenusVidesAvantBreak[0]) {
|
|
if(!insertionRealiser[0]) {
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
insertionRealiser[0]=true;
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
|
|
node p1 = new node();
|
|
p1.setNomElt("page");
|
|
p1.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p1.getAttributs().put("type","automatique");
|
|
p1.getAttributs().put("index",String.valueOf(j));
|
|
p1.getNodes().add(textSoftPageBreak[u+1]);
|
|
|
|
insertionRealiser[1]=true;
|
|
|
|
if(nods1.size()<3) {
|
|
nodpage.add(p1);
|
|
compteurpage++;
|
|
}
|
|
|
|
}
|
|
|
|
if(!insertionRealiser[0]&&!ContenusVidesAvantBreak[0]) {
|
|
// place le node de la page précédente
|
|
nodpage.get(nodpage.size()-1).getNodes().add(nodstructure.getNodes().get(j)); //ok
|
|
// place le textSoftPageBreak sur la page du node p.
|
|
p.getNodes().add(textSoftPageBreak[u]);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if(!insertionRealiser[0]&&!insertionRealiser[1]) {
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
}
|
|
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
|
|
}else {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","automatique");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
|
|
// recherche de l'index parmis les enfants du node text:soft-page-break.
|
|
int indexBreak = -1;
|
|
for(int v = 0 ; v < nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getNodes().get(v).getNomElt().equals("text:soft-page-break")) indexBreak=v;
|
|
}
|
|
|
|
//Détermine s'il y a que du texte vide avant le saut automatique
|
|
boolean ContenusVidesAvantBreak = true;
|
|
// Contenu & node après le text:soft-page-break
|
|
node textSoftPageBreak = new node();
|
|
textSoftPageBreak.setNomElt("saut:automatique");
|
|
|
|
for(int v = 0 ; v <= indexBreak; v++) {
|
|
if(!nodstructure.getNodes().get(j).getContenu().isEmpty()) {
|
|
if(nodstructure.getNodes().get(j).getContenu().get(v)!=null) {
|
|
if(!nodstructure.getNodes().get(j).getContenu().get(v).isEmpty()) {
|
|
ContenusVidesAvantBreak=false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!ContenusVidesAvantBreak && nodstructure.getNodes().get(j)!=null) {
|
|
// Ajoute dans le node textSoftPageBreak
|
|
for(int v = indexBreak+1 ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getContenu().size()>v) {
|
|
textSoftPageBreak.getContenu().add(nodstructure.getNodes().get(j).getContenu().get(v));
|
|
}
|
|
if(nodstructure.getNodes().get(j).getNodes().size()>v) {
|
|
textSoftPageBreak.getNodes().add(nodstructure.getNodes().get(j).getNodes().get(v));
|
|
}
|
|
}
|
|
|
|
for(int v = indexBreak+1 ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getContenu().size()>indexBreak+1) nodstructure.getNodes().get(j).getContenu().remove(indexBreak+1);
|
|
}
|
|
|
|
for(int v = indexBreak ; v <= nodstructure.getNodes().get(j).getNodes().size(); v++) {
|
|
if(nodstructure.getNodes().get(j).getNodes().size()>indexBreak) nodstructure.getNodes().get(j).getNodes().remove(indexBreak);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// S'il y a que du texte vide.
|
|
if(ContenusVidesAvantBreak) {
|
|
// place le node dans la même page du node p.
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
}else {
|
|
// place le node de la page précédente
|
|
nodpage.get(nodpage.size()-1).getNodes().add(nodstructure.getNodes().get(j));
|
|
// place le textSoftPageBreak sur la page du node p.
|
|
p.getNodes().add(textSoftPageBreak);
|
|
}
|
|
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//**************************************************************************
|
|
// les sauts manuels de page dans les paragraphes <text:p> et <text:list>
|
|
//**************************************************************************
|
|
if(nodstructure.getNodes().get(j).getAttributs().get("text:style-name")!=null) {
|
|
node nod2 = a.retourneFirstNodeByNameAttributValue(nodstyle.getNodes(), "style:style", "style:name", nodstructure.getNodes().get(j).getAttributs().get("text:style-name"));
|
|
if(nod2!=null) {
|
|
if(nod2.getAttributs().get("style:master-page-name")!=null) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","manuel");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
p.getAttributs().put("style:master-page-name",nod2.getAttributs().get("style:master-page-name"));
|
|
p.getAttributs().put("style:name",nod2.getAttributs().get("style:name"));
|
|
|
|
node nod3 = a.retourneName(nod2.getNodes(), "style:paragraph-properties","fo:break-before");
|
|
if(nod3!=null) {
|
|
if(nod3.getAttributs().get("style:page-number")!=null) p.getAttributs().put("style:page_number", nod3.getAttributs().get("style:page-number"));
|
|
}else {
|
|
nod3 = nod2.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
if(nod3!=null) if(nod3.getAttributs().get("style:page-number")!=null) {
|
|
p.getAttributs().put("style:page_number", nod3.getAttributs().get("style:page-number"));
|
|
}
|
|
}
|
|
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
}
|
|
if(a.retourneFirstNodeByNameAttributValue(nod2.getNodes(), "style:paragraph-properties","fo:break-before","page")!=null) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","automatique");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//*************************************************
|
|
// les sauts manuels hors paragraphe et titre
|
|
//*************************************************
|
|
if(!nodstructure.getNodes().get(j).getNomElt().equals("text:p") && !nodstructure.getNodes().get(j).getNomElt().equals("text:h") ) {
|
|
ArrayList<node> lesparagraphes = a.retourneNames(nodstructure.getNodes().get(j).getNodes(), "text:p");
|
|
node nod2 = a.retourneName(lesparagraphes, "text:p", "text:style-name");
|
|
if(nod2!=null) {
|
|
node nod3 = a.retourneFirstNodeByNameAttributValue(nodstyle.getNodes(), "style:style", "style:name", nod2.getAttributs().get("text:style-name"));
|
|
if(nod3!=null) {
|
|
if(nod3.getAttributs().get("style:master-page-name")!=null) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","manuel");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
p.getAttributs().put("style:master-page-name",nod3.getAttributs().get("style:master-page-name"));
|
|
p.getAttributs().put("style:name",nod3.getAttributs().get("style:name"));
|
|
|
|
node nod4 = a.retourneName(nod3.getNodes(), "style:paragraph-properties","fo:break-before");
|
|
if(nod4!=null) {
|
|
if(nod4.getAttributs().get("style:page-number")!=null) p.getAttributs().put("style:page_number", nod4.getAttributs().get("style:page-number"));
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
}else {
|
|
nodpage.get(nodpage.size()-1).getNodes().add(nodstructure.getNodes().get(j));
|
|
}
|
|
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
}
|
|
if(a.retourneFirstNodeByNameAttributValue(nod3.getNodes(), "style:paragraph-properties","fo:break-before","page")!=null) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("numero", String.valueOf(compteurpage));
|
|
p.getAttributs().put("type","automatique");
|
|
p.getAttributs().put("index",String.valueOf(j));
|
|
|
|
p.getNodes().add(nodstructure.getNodes().get(j));
|
|
nodpage.add(p);
|
|
compteurpage++;
|
|
page = nodpage.get(nodpage.size()-1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ajoute au node de la page les éléments sauf les paragraphes de texte
|
|
page.getNodes().add(nodstructure.getNodes().get(j));
|
|
|
|
}
|
|
|
|
// verification que dans la page numero 0 il y a un paragraphe.
|
|
// s'il n'y a pas de paragraphe alors ce n'est pas une page et elle est supprimée
|
|
// indique le style de la page
|
|
// insère les pages vides
|
|
// déplace les graphiques dans les bonnes pages.
|
|
if(nodpage.get(0)!=null) {
|
|
boolean pagezerosupprimer = false;
|
|
ArrayList<node> noddraw = a.retourneNames(nodpage.get(0), "draw:frame"); //il faut replacer peut être les cadre et image ancrer à la page après numérotation absolue
|
|
|
|
//suppresion de la page zéro si inutile
|
|
if(!nodpage.get(0).retourneEnfantsByNameExist("text:p") && !nodpage.get(0).retourneEnfantsByNameExist("text:h")) {
|
|
nodpage.remove(0);
|
|
pagezerosupprimer=true;
|
|
}
|
|
|
|
|
|
//indiquer le style de chaque page
|
|
for(int j = 0 ; j < nodpage.size();j++) {
|
|
if(j!=0) {
|
|
if(nodpage.get(j).getAttributs().get("type").equals("automatique")) {
|
|
if(nodpage.get(j-1).getAttributs().get("style:master-page-name")!=null) {
|
|
node nod5 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:master-page", "style:name", nodpage.get(j-1).getAttributs().get("style:master-page-name"));
|
|
if(nod5.getAttributs().get("style:next-style-name")!=null) {
|
|
nodpage.get(j).getAttributs().put("style:master-page-name", nod5.getAttributs().get("style:next-style-name"));
|
|
}else {
|
|
nodpage.get(j).getAttributs().put("style:master-page-name", nodpage.get(j-1).getAttributs().get("style:master-page-name"));
|
|
}
|
|
}else {
|
|
nodpage.get(j).getAttributs().put("style:master-page-name", "Standard"); //défini une page en style page par défaut
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//insère les pages vides
|
|
ArrayList<node> newnodpage = (ArrayList<node>) nodpage.clone();
|
|
int compteurinsertion = 0 ;
|
|
for(int j = 0 ; j < nodpage.size();j++) {
|
|
if(j!=0) {
|
|
String usage1 ="1";
|
|
String usage2 ="2";
|
|
|
|
if(nodpage.get(j).getAttributs().get("style:master-page-name")!=null) {
|
|
node nod5 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:master-page", "style:name", nodpage.get(j).getAttributs().get("style:master-page-name"));
|
|
if(nod5.getAttributs().get("style:page-layout-name")!=null) {
|
|
node nod6 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:page-layout", "style:name", nod5.getAttributs().get("style:page-layout-name"));
|
|
if(nod6.getAttributs().get("style:page-usage")!=null) {
|
|
usage1 = nod6.getAttributs().get("style:page-usage");
|
|
nodpage.get(j).getAttributs().put("style:page-usage", usage1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if(nodpage.get(j-1).getAttributs().get("style:master-page-name")!=null) {
|
|
node nod5 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:master-page", "style:name", nodpage.get(j-1).getAttributs().get("style:master-page-name"));
|
|
if(nod5.getAttributs().get("style:page-layout-name")!=null) {
|
|
node nod6 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:page-layout", "style:name", nod5.getAttributs().get("style:page-layout-name"));
|
|
if(nod6.getAttributs().get("style:page-usage")!=null) {
|
|
usage2 = nod6.getAttributs().get("style:page-usage");
|
|
}
|
|
}
|
|
}
|
|
|
|
if(j-1==0) usage2="right"; //la première page est toujours à droite.
|
|
|
|
//insertion d'un page vide
|
|
if(usage1.equals(usage2)) {
|
|
node p = new node();
|
|
p.setNomElt("page");
|
|
p.getAttributs().put("vide", "true");
|
|
p.getAttributs().put("style:master-page-name", "page_vide");
|
|
newnodpage.add(j+compteurinsertion,p);
|
|
compteurinsertion++;
|
|
}
|
|
|
|
}else {
|
|
if(nodpage.get(j).getAttributs().get("style:master-page-name")!=null) {
|
|
node nod5 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:master-page", "style:name", nodpage.get(j).getAttributs().get("style:master-page-name"));
|
|
if(nod5.getAttributs().get("style:page-layout-name")!=null) {
|
|
node nod6 = a.retourneFirstNodeByNameAttributValue(nodstylepage, "style:page-layout", "style:name", nod5.getAttributs().get("style:page-layout-name"));
|
|
if(nod6.getAttributs().get("style:page-usage")!=null) {
|
|
nodpage.get(j).getAttributs().put("style:page-usage", nod6.getAttributs().get("style:page-usage"));
|
|
}
|
|
if(j==0) nodpage.get(j).getAttributs().put("style:page-usage", "right"); //la première page est toujours à droite.
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
nodpage = (ArrayList<node>) newnodpage.clone();
|
|
|
|
|
|
|
|
// numerotation des pages
|
|
int compteurnumeropage = 1 ;
|
|
int compteurabsoluepage = 1 ;
|
|
for(int j = 0 ; j < nodpage.size();j++) {
|
|
if(nodpage.get(j).getAttributs().get("style:page_number")!=null){
|
|
if(!nodpage.get(j).getAttributs().get("style:page_number").equals("auto")) {
|
|
compteurnumeropage= Integer.valueOf(nodpage.get(j).getAttributs().get("style:page_number"));
|
|
nodpage.get(j).getAttributs().put("numero", String.valueOf(compteurnumeropage));
|
|
nodpage.get(j).getAttributs().put("numeroabsolue", String.valueOf(compteurabsoluepage));
|
|
compteurnumeropage++;
|
|
compteurabsoluepage++;
|
|
continue;
|
|
}
|
|
}
|
|
nodpage.get(j).getAttributs().put("numero", String.valueOf(compteurnumeropage));
|
|
nodpage.get(j).getAttributs().put("numeroabsolue", String.valueOf(compteurabsoluepage));
|
|
compteurnumeropage++;
|
|
compteurabsoluepage++;
|
|
|
|
}
|
|
|
|
// replacer les cadres et images ancrés dans les bonnes pages de la structure
|
|
for(int j = 0 ; j <noddraw.size();j++) {
|
|
if(noddraw.get(j).getAttributs().get("text:anchor-type")!=null) {
|
|
if(noddraw.get(j).getAttributs().get("text:anchor-type").equals("page")) {
|
|
if(noddraw.get(j).getAttributs().get("text:anchor-page-number")!=null) {
|
|
node page1 = a.retourneFirstNodeByNameAttributValue(nodpage, "page", "numeroabsolue", noddraw.get(j).getAttributs().get("text:anchor-page-number"));
|
|
if(page1!=null) {
|
|
if(pagezerosupprimer) {
|
|
page1.getNodes().add(noddraw.get(j));
|
|
}else {
|
|
if(!noddraw.get(j).getAttributs().get("text:anchor-page-number").equals("1")){
|
|
page1.getNodes().add(noddraw.get(j));
|
|
node page2 = a.retourneFirstNodeByNameAttributValue(nodpage, "page", "numeroabsolue", "1");
|
|
page2.getNodes().remove(noddraw.get(j));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// construction du node de l'étudiant
|
|
node structurePage = new node();
|
|
structurePage.setNomElt("structurepage");
|
|
structurePage.setLevel(1);
|
|
structurePage.setNodes(nodpage);
|
|
structurePage.setClose(true);
|
|
|
|
|
|
|
|
|
|
node fichier = new node();
|
|
fichier.setNomElt("fichier");
|
|
|
|
|
|
if(a.getLectDossiers().getEC().getListeFichierodt().get(i)!=null) {
|
|
fichier.getAttributs().put("filename", a.getLectDossiers().getEC().getListeFichierodt().get(i));
|
|
if(commandes.Profil.equals(UserStatus.STUDENT)) {
|
|
a.getLectDossiers().getEC().getListeNomDossier().add(i, a.getLectDossiers().getEC().getListeFichierodt().get(i).substring(0, a.getLectDossiers().getEC().getListeFichierodt().get(i).lastIndexOf(".")));
|
|
}
|
|
fichier.getAttributs().put("dossier", a.getLectDossiers().getEC().getListeNomDossier().get(i));
|
|
}
|
|
|
|
if(!nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().get(0));
|
|
}
|
|
if(!nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("dureeEdition", nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().get(0));
|
|
}
|
|
if(!nodmeta.retourneFirstEnfantsByName("dc:date").getContenu().isEmpty()) {
|
|
fichier.getAttributs().put("dateModification", nodmeta.retourneFirstEnfantsByName("dc:date").getContenu().get(0));
|
|
}
|
|
|
|
fichier.getNodes().add(nodmeta);
|
|
nodstylepage = a.numeroteNameNode(nodstylepage, "0"); //ajoute les numéros d'index et des attributs
|
|
fichier.getNodes().add(nodstylepage);
|
|
fichier.getNodes().add(nodstyleparagraphe);
|
|
// fichier.getNodes().add(nodstyleformatage);
|
|
fichier.getNodes().add(nodsequence);
|
|
fichier.getNodes().add(nodnumerochapitre);
|
|
fichier.getNodes().add(nodframe);
|
|
|
|
fichier.getNodes().add(nodsection);
|
|
fichier.getNodes().add(nodtableaux);
|
|
//nodbiblio = a.numeroteNameNode(nodbiblio, "0"); //ajoute les numéros d'index et des attributs
|
|
fichier.getNodes().add(nodbiblio);
|
|
//nodtable = a.numeroteNameNode(nodtable, "0"); //ajoute les numéros d'index et des attributs
|
|
fichier.getNodes().add(nodtable);
|
|
//nodillustrations = a.numeroteNameNode(nodillustrations, "0"); //ajoute les numéros d'index et des attributs
|
|
fichier.getNodes().add(nodillustrations);
|
|
|
|
structurePage = a.numeroteNameNode(structurePage,""); //ajoute les numéros d'index et des attributs
|
|
fichier.getNodes().add(structurePage);
|
|
|
|
fichier.getNodes().add(nodhistorique);
|
|
|
|
fichier = attributLesParentsAuxNodes(fichier);
|
|
fichier.setParent(null);
|
|
|
|
return fichier;
|
|
}
|
|
|
|
|
|
/**
|
|
* Trouve le node parent de chaque node.</br>
|
|
* @param suitenodes
|
|
* @return
|
|
*/
|
|
public static node attributLesParentsAuxNodes(node nod){
|
|
for(int i = 0 ; i<nod.getNodes().size();i++) {
|
|
nod.getNodes().get(i).setParent(nod);
|
|
// nod = attributLesParentsAuxNodes(nod.getNodes().get(i));
|
|
for(int j = 0 ; j<nod.getNodes().get(i).getNodes().size();j++) {
|
|
if(nod.getNodes().get(i).getNodes().get(j)!=null) {
|
|
node A = nod.getNodes().get(i).getNodes().get(j);
|
|
A.setParent(nod.getNodes().get(i));
|
|
A = PlaceLePere(A);
|
|
}
|
|
}
|
|
}
|
|
return nod;
|
|
}
|
|
|
|
/**
|
|
* Place le père (le node parent) à tous les enfants.</br>
|
|
* @param nod
|
|
* @return
|
|
*/
|
|
private static node PlaceLePere(node nod) {
|
|
for(int i = 0 ; i<nod.getNodes().size();i++) {
|
|
if(nod.getNodes().get(i)!=null) {
|
|
node B = nod.getNodes().get(i);
|
|
B.setParent(nod);
|
|
B = PlaceLePere(B);
|
|
}
|
|
}
|
|
return nod;
|
|
}
|
|
|
|
/**
|
|
* Chargement du sujet.<br>
|
|
* Retourne l'ensemble des nodes qui possédent l'attribut evaluer="true".
|
|
* <br>
|
|
* @param a
|
|
* @return le node du sujet qui contient les partie à analyser
|
|
* @throws IOException
|
|
* @throws CloneNotSupportedException
|
|
*/
|
|
public static node chargementFichierAnalyse(String nameSujet, Boolean sansNodeEvaluer) throws CloneNotSupportedException, IOException {
|
|
String targetString = "";
|
|
//read file into stream, try-with-resources
|
|
|
|
String cheminVerFichierAnalyse = Run.path + "/" + nameSujet;
|
|
if(!commandes.console) cheminVerFichierAnalyse = commandes.PathFilenameAnalysis;
|
|
|
|
try {
|
|
BufferedReader br = new BufferedReader(
|
|
new InputStreamReader(
|
|
new FileInputStream(cheminVerFichierAnalyse), "UTF-8"));
|
|
|
|
String line;
|
|
while ((line = br.readLine()) != null) {
|
|
targetString = targetString + line;
|
|
}
|
|
br.close();
|
|
}catch (Exception e) {
|
|
System.out.println();
|
|
System.out.println("** Le fichier \"" + nameSujet + "\" n'est pas dans le dossier courant.");
|
|
System.out.println("** Le dossier courant de l'application est : " + commandes.path);
|
|
System.out.println();
|
|
}
|
|
|
|
|
|
node LeNodeSujet = new node();
|
|
if(!targetString.isEmpty()) {
|
|
// ! Important nettoyage du fichier avant lecture avec cXML
|
|
targetString = targetString.replace("\r", "");
|
|
targetString = targetString.replace("\n", "");
|
|
targetString = targetString.replace("\t", "");
|
|
// supprime les espaces multiples au-delà de deux espaces après un guillemets
|
|
Pattern p = Pattern.compile(" {2,}");
|
|
targetString = p.matcher(targetString).replaceAll(" ");
|
|
|
|
// supprime les espaces entre " et >
|
|
p = Pattern.compile("\" {1,}>");
|
|
targetString = p.matcher(targetString).replaceAll("\">");
|
|
|
|
LeNodeSujet = Run.XMLContent(targetString);
|
|
|
|
//Supprime l'historique des modifications
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:tracked-changes");
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:change-start");
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:change-end");
|
|
commandes.sujet.supprimeTousLesNodesEnfantWithThisName("text:deletion");
|
|
|
|
commandes.sujetSauvegarde = commandes.sujet.clone();
|
|
}
|
|
|
|
if(sansNodeEvaluer) {
|
|
LeNodeSujet = Run.NodesAyantAttributEvaluerTRUEavecComplement(LeNodeSujet);
|
|
}
|
|
|
|
|
|
|
|
return LeNodeSujet;
|
|
}
|
|
|
|
/**
|
|
* Chargement des paramètres du fichier d'analyse
|
|
*/
|
|
public static void chargementParametresFichierAnalyse() {
|
|
|
|
try {
|
|
|
|
//** Chargement du titre de l'exercice
|
|
if(commandes.sujet.getAttributs().get("titre")!=null) {
|
|
commandes.analyse_titre=commandes.sujet.getAttributs().get("titre");
|
|
}
|
|
|
|
// Chargement de la progression
|
|
if(commandes.sujet.getAttributs().get("progression")!=null) {
|
|
commandes.analyse_progression= Double.valueOf(commandes.sujet.getAttributs().get("progression"));
|
|
}
|
|
|
|
// Chargement de la notefrom
|
|
if(commandes.sujet.getAttributs().get("notefrom")!=null) {
|
|
commandes.analyse_notefrom= Double.valueOf(commandes.sujet.getAttributs().get("notefrom"));
|
|
}
|
|
|
|
// Chargement de la date de creation
|
|
if(commandes.sujet.getAttributs().get("creationDate")!=null) {
|
|
commandes.analyse_creationDate= commandes.sujet.getAttributs().get("creationDate");
|
|
}
|
|
|
|
// Chargement de la version
|
|
if(commandes.sujet.getAttributs().get("version")!=null) {
|
|
commandes.analyse_version= commandes.sujet.getAttributs().get("version");
|
|
}
|
|
|
|
// Chargement du link_sujet
|
|
if(commandes.sujet.getAttributs().get("link_sujet")!=null) {
|
|
commandes.analyse_link_sujet= commandes.sujet.getAttributs().get("link_sujet");
|
|
}
|
|
|
|
// Chargement du link_help
|
|
if(commandes.sujet.getAttributs().get("link_help")!=null) {
|
|
commandes.analyse_link_help= commandes.sujet.getAttributs().get("link_help");
|
|
}
|
|
|
|
// Chargement du controleDateCreation
|
|
if(commandes.sujet.getAttributs().get("controleDateCreation")!=null) {
|
|
commandes.analyse_controleDateCreation = Boolean.valueOf(commandes.sujet.getAttributs().get("controleDateCreation"));
|
|
}
|
|
|
|
// Chargement du presenceMetaSujet
|
|
if(commandes.sujet.getAttributs().get("presenceMetaSujet")!=null) {
|
|
commandes.analyse_presenceMetaSujet = Boolean.valueOf(commandes.sujet.getAttributs().get("presenceMetaSujet"));
|
|
}
|
|
|
|
// Chargement du historiquePresent
|
|
if(commandes.sujet.getAttributs().get("historiquePresent")!=null) {
|
|
commandes.analyse_historiquePresent = Boolean.valueOf(commandes.sujet.getAttributs().get("historiquePresent"));
|
|
}
|
|
|
|
// Chargement du baremeABC
|
|
if(commandes.sujet.getAttributs().get("baremeABC")!=null) {
|
|
commandes.analyse_baremeABC = Boolean.valueOf(commandes.sujet.getAttributs().get("baremeABC"));
|
|
}
|
|
|
|
// Chargement du controle_Initial_Creator
|
|
if(commandes.sujet.getAttributs().get("controle_Initial_Creator")!=null) {
|
|
commandes.analyse_controle_Initial_Creator = Boolean.valueOf(commandes.sujet.getAttributs().get("controle_Initial_Creator"));
|
|
}
|
|
|
|
// Chargement du metaSujet
|
|
if(commandes.sujet.getAttributs().get("metaSujet")!=null) {
|
|
commandes.analyse_metaSujet= commandes.sujet.getAttributs().get("metaSujet");
|
|
}
|
|
|
|
// Chargement du auteur
|
|
if(commandes.sujet.getAttributs().get("auteur")!=null) {
|
|
commandes.analyse_auteur= commandes.sujet.getAttributs().get("auteur");
|
|
}
|
|
|
|
// Chargement du Initial_Creator
|
|
if(commandes.sujet.getAttributs().get("Initial_Creator")!=null) {
|
|
commandes.analyse_Initial_Creator= commandes.sujet.getAttributs().get("Initial_Creator");
|
|
}
|
|
|
|
|
|
// Chargement du date
|
|
if(commandes.sujet.getAttributs().get("date")!=null) {
|
|
commandes.analyse_date= commandes.sujet.getAttributs().get("date");
|
|
}
|
|
|
|
//Charge le hash
|
|
if(commandes.sujet.getAttributs().get("hash")!=null) {
|
|
commandes.analyse_hash= commandes.sujet.getAttributs().get("hash");
|
|
}
|
|
|
|
//Charge le analysis_filename
|
|
if(commandes.sujet.getAttributs().get("analysis_filename")!=null) {
|
|
commandes.analysis_filename= commandes.sujet.getAttributs().get("analysis_filename");
|
|
}
|
|
|
|
|
|
//*****************************************************************
|
|
//** chargement de la culture qui se trouve dans le node setting **
|
|
//*****************************************************************
|
|
if(commandes.sujet.retourneFirstEnfantsByName("setting").isHasAttributs()) {
|
|
if(commandes.sujet.retourneFirstEnfantsByName("setting").getAttributs().get("culture")!=null) {
|
|
commandes.culture = commandes.sujet.retourneFirstEnfantsByName("setting").getAttributs().get("culture"); //récupère la culture de l'utilisateur
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
//** Charge pour la taille et le nom de l'archive de l'archive ZIP **
|
|
//*******************************************************************
|
|
if(commandes.sujet.containElementByName("zip")) {
|
|
node zip = commandes.sujet.retourneFirstEnfantsByName("zip");
|
|
if(zip.getAttributs().get("size")!=null) commandes.analyse_size = Long.valueOf(zip.getAttributs().get("size"));
|
|
if(zip.getAttributs().get("nameZip")!=null) commandes.analyse_nameZip = zip.getAttributs().get("nameZip");
|
|
}
|
|
|
|
|
|
//***********************************************************************
|
|
//** chargement du node translation qui se trouve dans le node setting **
|
|
//***********************************************************************
|
|
evaluation.chargeTraduction(commandes.sujet.retourneFirstEnfantsByName("translation"));
|
|
|
|
//************************************************
|
|
//** Charge les nouvelles tolérances pour texte **
|
|
//************************************************
|
|
if(commandes.sujet.containElementByName("text:similarity")) {
|
|
node similarity = commandes.sujet.retourneFirstEnfantsByName("text:similarity");
|
|
if(similarity.getAttributs().get("tolerance_characters")!=null) commandes.tolerance_characters = Integer.valueOf(similarity.getAttributs().get("tolerance_characters"));
|
|
if(similarity.getAttributs().get("tolerance_text")!=null) commandes.tolerance_text = Double.valueOf(similarity.getAttributs().get("tolerance_text"));
|
|
}
|
|
|
|
//***********************************************************
|
|
//** Charge le nombre de match limite et le nombre minimal **
|
|
//***********************************************************
|
|
if(commandes.sujet.containElementByName("plagiarism")) {
|
|
node plagiarism = commandes.sujet.retourneFirstEnfantsByName("plagiarism");
|
|
if(plagiarism.getAttributs().get("number_match") != null) commandes.number_match = Integer.valueOf(plagiarism.getAttributs().get("number_match"));
|
|
if(plagiarism.getAttributs().get("mini_number_modification") != null) commandes.mini_number_modification = Integer.valueOf(plagiarism.getAttributs().get("mini_number_modification"));
|
|
if(plagiarism.getAttributs().get("nombres_modifications_simultané_maxi") != null) commandes.nombres_modifications_simultané_maxi = Integer.valueOf(plagiarism.getAttributs().get("nombres_modifications_simultané_maxi"));
|
|
}
|
|
|
|
//**************************************
|
|
//** Charge tolerance pour la couleur **
|
|
//**************************************
|
|
if(commandes.sujet.containElementByName("color")) {
|
|
node color = commandes.sujet.retourneFirstEnfantsByName("color");
|
|
if(color.getAttributs().get("tolerance_rouge") != null) commandes.tolerance_rouge= Integer.valueOf(color.getAttributs().get("tolerance_rouge"));
|
|
if(color.getAttributs().get("tolerance_vert") != null) commandes.tolerance_vert= Integer.valueOf(color.getAttributs().get("tolerance_vert"));
|
|
if(color.getAttributs().get("tolerance_bleu") != null) commandes.tolerance_bleu= Integer.valueOf(color.getAttributs().get("tolerance_bleu"));
|
|
}
|
|
|
|
}catch (Exception e) {
|
|
System.out.println(e);
|
|
}
|
|
|
|
|
|
|
|
//** Adéquation par les valeurs par défaut si pas dans le fichier d'analyse
|
|
commandes.analyse_culture = commandes.culture;
|
|
commandes.analyse_tolerance_characters = commandes.tolerance_characters;
|
|
commandes.analyse_tolerance_text = commandes.tolerance_text;
|
|
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Parcour l'ensemble des fichiers des étudiants, verification, analyse, création des feedbacks et CSV.
|
|
* @throws IOException
|
|
* @throws ParserConfigurationException
|
|
* @throws SAXException
|
|
* @throws CloneNotSupportedException
|
|
*/
|
|
public static void analyseVerifieHistoriqueLesFichiersEtudiantsEtExportNoteCSV(JEditorPane txt) throws IOException, ParserConfigurationException, SAXException, CloneNotSupportedException {
|
|
|
|
commandes.message = new StringBuilder();
|
|
commandes.message.append("\n *** LES FICHIERS ANALYSES & EVALUES ***\n");
|
|
commandes.message.append("\n");
|
|
commandes.message.append("\n Dossier contenant les fichiers des étudiants.");
|
|
commandes.message.append("\n " + commandes.path + "\n");
|
|
commandes.message.append("\n Les fichiers des étudiants ne sont pas dans des dossiers nominatifs ?");
|
|
commandes.message.append(" " + commandes.fichierStudentMoodle+"\n");
|
|
|
|
Run a = new Run(commandes.path,commandes.Profil, commandes.fichierStudentMoodle);
|
|
|
|
|
|
//**********************************************
|
|
//** Chargement et verification du CVS fourni **
|
|
//**********************************************
|
|
if(commandes.fourniCSV) {
|
|
commandes.nodeCSV = chargementFichierCSV();
|
|
}
|
|
|
|
|
|
//*****************************************
|
|
//** Nombre de fichier writer à analyser **
|
|
//*****************************************
|
|
int nbFichierWriter = a.getLectDossiers().getEC().getListeContentWriter().size();
|
|
commandes.analyse_Nbre_Fichier_Student = nbFichierWriter;
|
|
commandes.message.append("\nNombre de fichier à analyser et évaluer : " + Integer.valueOf(nbFichierWriter) + "\n");
|
|
|
|
|
|
//***************************************
|
|
//** -verif ou -use file.xml -verifcsv **
|
|
//***************************************
|
|
node verif = new node();
|
|
if(commandes.verifHisto || commandes.verifHisto2) {
|
|
node verification = new node();
|
|
verification.setNomElt("verification");
|
|
verification.getAttributs().put("nombre_fichier", String.valueOf(a.getLectDossiers().getEC().getListeFichierodt().size()));
|
|
for(int i = 0 ; i < nbFichierWriter ; i++) {
|
|
node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
|
|
node nodStudent = meptl.LectureFichierEtudiantPourVerification(nod,a,i);
|
|
verification.getNodes().add(nodStudent);
|
|
}
|
|
//a.ecritureNodeEnXML(verification, "VerificationHistorique","",false); //écriture du node de l'étudiant
|
|
verif = meptl.verificationHistorique(verification, a); // vérification des correspondances entre les fichiers
|
|
|
|
//********************************
|
|
//** Ecriture du node verif.xml **
|
|
//********************************
|
|
Run.ecritureNodeEnXML(verif, "Verif",commandes.path, Run.TypeFile.Verif); //écriture du node de vérification
|
|
commandes.message.append("\n*******************************************************");
|
|
commandes.message.append("\nEcriture du fichier Verif.xml dans le dossier d'analyse");
|
|
commandes.message.append("\n*******************************************************");
|
|
if(!commandes.analyse) {
|
|
//** bye bye analyseWriter
|
|
commandes.clotureApplication();
|
|
}
|
|
}
|
|
|
|
//*********************************************************
|
|
//** Node contenant l'ensemble des analyses des étudiants **
|
|
//*********************************************************
|
|
node ensembleanalyse = new node();
|
|
ensembleanalyse.setNomElt("analyses");
|
|
|
|
//*****************************************************
|
|
//** Parcours l'ensemble des fichiers des étudiants ***
|
|
//*****************************************************
|
|
for(int i = 0 ; i < nbFichierWriter ; i++) {
|
|
|
|
//index de l'étudiant
|
|
commandes.analyse_index_Fichier_Student = i;
|
|
|
|
//** Ne prends pas en compte le dossier destination créé par la commande -dest
|
|
//** Si pas d'analyse alors le nom doit contenir le caractère $ dans le nom du dossier.
|
|
if(commandes.fourniDossierDestination) if(a.getLectDossiers().getEC().getListeNomDossier().get(i).equals(commandes.pathDestination)) continue;
|
|
|
|
//***********************************************************
|
|
//** Lecture et transformation en node du fichier étudiant **
|
|
//***********************************************************
|
|
node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
|
|
node nodStudent = meptl.LectureFichierEtudiantSousFormeDeNode(nod,a,i);
|
|
//a.ecritureNodeEnXML(nodStudent, a.getLectDossiers().getEC().getListeNomDossier().get(i),"",false,""); //écriture du node de l'étudiant
|
|
|
|
//**********************************
|
|
//** Analyse des fichiers student **
|
|
//**********************************
|
|
if(commandes.analyse||commandes.ecritNodeAnalyse) {
|
|
// Run.ecritureNodeEnXML(nodStudent, "fichier student","",false,""); //écriture du node nodStudent de l'étudiant
|
|
node ana = analyseFichier.analyse(nodStudent, commandes.sujet, i, a, txt, String.valueOf(nbFichierWriter));
|
|
|
|
//**************************************************
|
|
//** Ecriture des fichiers d'analyse des students **
|
|
//**************************************************
|
|
if(commandes.ecritNodeAnalyse) {
|
|
Run.ecritureNodeEnXML(ana, "nodana"+ana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"),commandes.path,Run.TypeFile.Analyse); //écriture du node analyse de l'étudiant
|
|
}
|
|
|
|
//****************************
|
|
//** Création des feedbacks **
|
|
//****************************
|
|
if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
|
|
if(!commandes.zipfeedback) {
|
|
//feedback(ana, verif); //classique directement dans le répertoire
|
|
feedbacks.feedback(ana,verif, false,false);
|
|
}
|
|
if(commandes.zipfeedback) { // Dans une archive pour Moodle
|
|
try {
|
|
a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
|
|
} catch (ZipException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
//********************************************************************************
|
|
//** Ajoute au node ensembleanalyse lorsque -csv file.csv ou -verifcsv file.scv **
|
|
//********************************************************************************
|
|
if(commandes.ecritNoteCSV) ensembleanalyse.addNode(ana);
|
|
|
|
//*********************************************************
|
|
//** Message dans la console sur l'analyse de l'étudiant **
|
|
//*********************************************************
|
|
commandes.message.append(meptl.messageSystem(ana).toString());
|
|
}
|
|
}
|
|
|
|
|
|
//*****************************************************
|
|
//** Exportation au format CSV si -csv ou -verifcsv **
|
|
//*****************************************************
|
|
if(commandes.ecritNoteCSV && !commandes.fourniCSV) {
|
|
if(!commandes.verifHisto2) ecritureCSV(ensembleanalyse);
|
|
if(commandes.verifHisto2) ecritureCSV(ensembleanalyse,verif,a,commandes.sujet.retourneFirstEnfantsByName("setting"));
|
|
//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
|
|
}
|
|
|
|
//***********************************************************************
|
|
//** Exportation au format CSV si -csv file.csv ou -verifcsv file.csv **
|
|
//***********************************************************************
|
|
if(commandes.ecritNoteCSV && commandes.fourniCSV) {
|
|
ecritureCSV(ensembleanalyse,verif,a,commandes.nodeCSV, commandes.sujet.retourneFirstEnfantsByName("setting"));
|
|
//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
|
|
}
|
|
|
|
//**************************************
|
|
//** Mise à jour du fichier d'analyse **
|
|
//**************************************
|
|
if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
|
|
verificationFichierAnalyse.MiseAJourFichierAnalyse();
|
|
verificationFichierAnalyse.messagMiseAJourFichierAnalyseAprèsAnalyse();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Les erreurs dans le fichier étudiant : erreur de métadonnées Sujet, date de création pour identifier le fichier à analyser.
|
|
* <br>Il y a une erreur si pas d'historique de modification dans le fichier de l'étudiant.
|
|
* <br>Il y a une erreur si le premier auteur ne correspond pas.
|
|
* <br>Les erreurs sont dans les attributs du node <b>Erreurs</b>.
|
|
* <br><b> oneError</b> si VRAI, il y a au moins une erreur.
|
|
* <br><b> manqueMetaSujet</b> si VRAI, il n'y a pas de méta données <b>Sujet</b>.
|
|
* <br><b> manqueValeurMetaSujet</b> si VRAI, la valeur de la méta données <b>Sujet</b> n'est pas la bonne.
|
|
* <br><b> manqueCreationDate</b> si VRAI, il n'y a pas de méta données <b>creationDate</b>.
|
|
* <br><b> manqueValeurCreationDate</b> si VRAI, la date de la méta données <b>creationDate</b> n'est pas la bonne.
|
|
* <br><b> manqueHistorique</b> si VRAI, il n'y a pas d'historique des modifications.<br>
|
|
* <br><b> manqueInitialCreator</b> si VRAI, il n'y a pas de premier auteur ou qu'il ne correspond pas.<br>
|
|
* @param nodStudent : node de l'étudiants.
|
|
* @param nodSujet : node du sujet.
|
|
* @param a : objet Run de cXML.
|
|
* @return retourn le node erreurs.
|
|
*/
|
|
public static node retourneNodeErreur(node nodStudent, node nodSujet, Run a) {
|
|
node erreurs = new node();
|
|
erreurs.setNomElt("erreurs");
|
|
boolean manqueMetaSujet = false;
|
|
boolean manqueValeurMetaSujet = false;
|
|
boolean manqueCreationDate = false;
|
|
boolean manqueValeurCreationDate = false;
|
|
boolean manqueHistorique = false;
|
|
boolean manqueInitialCreator = false;
|
|
|
|
node b = null;
|
|
|
|
if(nodSujet.getAttributs().get("presenceMetaSujet")!=null) {
|
|
if(nodSujet.getAttributs().get("presenceMetaSujet").equals("true")) {
|
|
b = a.retourneFirstNodeByNameAttributValue(nodStudent, "meta:user-defined", "meta:name", "Sujet");
|
|
if(b==null) {
|
|
manqueMetaSujet=true;
|
|
}else {
|
|
if(!nodSujet.getAttributs().get("metaSujet").equals(b.getContenu().get(0))) {
|
|
manqueValeurMetaSujet=true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
b = nodStudent.retourneFirstEnfantsByName("meta:creation-date");
|
|
|
|
if(!b.getNomElt().equals("meta:creation-date")) {
|
|
manqueValeurCreationDate=true;
|
|
}
|
|
|
|
if(nodSujet.getAttributs().get("creationDate")!=null) {
|
|
if(!(b.getContenu().contains(nodSujet.getAttributs().get("creationDate")))) { //nodSujet.getAttributs().get("creationDate").contains(b.getContenu())
|
|
manqueValeurCreationDate = true;
|
|
}
|
|
}
|
|
|
|
if(nodSujet.getAttributs().get("controleDateCreation")!=null) if(nodSujet.getAttributs().get("controleDateCreation").equals("false")) {
|
|
manqueValeurCreationDate = false;
|
|
}
|
|
|
|
if(nodSujet.getAttributs().get("controle_Initial_Creator")!=null) {
|
|
if(nodSujet.getAttributs().get("controle_Initial_Creator").equalsIgnoreCase("true")) {
|
|
b = nodStudent.retourneFirstEnfantsByName("meta:initial-creator");
|
|
if(b.getNomElt().equals("meta:initial-creator")) {
|
|
if(nodSujet.getAttributs().get("Initial_Creator")!=null) {
|
|
if( !b.getContenu().get(0).equals(nodSujet.getAttributs().get("Initial_Creator"))) {
|
|
manqueInitialCreator = true;
|
|
}
|
|
}else {
|
|
System.out.println("ERROR. There is no Initial_Creator.");
|
|
}
|
|
}else {
|
|
manqueInitialCreator = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
b = nodStudent.retourneFirstEnfantsByName("historique");
|
|
if(b.getNomElt().equals("historique")) {
|
|
if(Integer.valueOf(b.getAttributs().get("nbrModif"))<1) {
|
|
manqueHistorique =true;
|
|
}
|
|
}
|
|
|
|
|
|
erreurs.getAttributs().put("manqueMetaSujet", String.valueOf(manqueMetaSujet));
|
|
erreurs.getAttributs().put("manqueValeurMetaSujet", String.valueOf(manqueValeurMetaSujet));
|
|
erreurs.getAttributs().put("manqueCreationDate", String.valueOf(manqueCreationDate));
|
|
erreurs.getAttributs().put("manqueValeurCreationDate", String.valueOf(manqueValeurCreationDate));
|
|
erreurs.getAttributs().put("manqueInitialCreator", String.valueOf(manqueInitialCreator));
|
|
|
|
if(nodSujet.getAttributs().get("historiquePresent")!=null) {
|
|
if(nodSujet.getAttributs().get("historiquePresent").equalsIgnoreCase("true")) {
|
|
if(manqueHistorique) {
|
|
erreurs.getAttributs().put("manqueHistorique", "true");
|
|
}else {
|
|
erreurs.getAttributs().put("manqueHistorique", "false");
|
|
}
|
|
}else {
|
|
erreurs.getAttributs().put("manqueHistorique", "false");
|
|
manqueHistorique = false;
|
|
}
|
|
}else {
|
|
erreurs.getAttributs().put("manqueHistorique", "false");
|
|
manqueHistorique = false;
|
|
}
|
|
|
|
if( manqueMetaSujet == false && manqueValeurMetaSujet == false && manqueCreationDate == false && manqueValeurCreationDate == false
|
|
&& manqueHistorique == false && manqueInitialCreator == false) {
|
|
erreurs.getAttributs().put("oneError", "false");
|
|
}else {
|
|
erreurs.getAttributs().put("oneError", "true");
|
|
}
|
|
|
|
erreurs.setClose(true);
|
|
|
|
return erreurs;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Retourne le nom du fichier de l'étudiant pour le Zip pour Moodle.<br>
|
|
* </br>
|
|
* @param filename
|
|
* @param nodana
|
|
* @return
|
|
*/
|
|
public static String retourneLeNomDuFeedback( String filename,node nodana, node verif) {
|
|
System.getProperty("file.encoding","UTF-8");
|
|
|
|
int number_match = 2;
|
|
int mini_modification = 0;
|
|
boolean plagiat = false;
|
|
boolean copiercoller = false;
|
|
boolean pasAssezDeModification =false;
|
|
|
|
node verifStudent = null;
|
|
if((commandes.verifHisto||commandes.verifHisto2)) { //&&commandes.ecritNoteCSV&&commandes.fourniCSV
|
|
if(verif.getAttributs().get("number_match") != null) number_match = Integer.valueOf(verif.getAttributs().get("number_match"));
|
|
if(verif.getAttributs().get("mini_number_modification") != null) mini_modification = Integer.valueOf(verif.getAttributs().get("mini_number_modification"));
|
|
|
|
|
|
//verification du plagiat
|
|
verifStudent = verif.retourneFirstNodeByNameAndAttributValue("fichier", "dossier", nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"));
|
|
if(verifStudent != null) {
|
|
if(verifStudent.getAttributs().get("filename").equals(nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("filename"))) {
|
|
if(Integer.valueOf(verifStudent.getAttributs().get("nombre_correspondances_consecutives"))>number_match) plagiat=true;
|
|
if(!verifStudent.getAttributs().get("first_modification_identique").equals("null") && Integer.valueOf(verifStudent.getAttributs().get("nombre_correspondances_consecutives"))>=number_match) plagiat=true;
|
|
if(verifStudent.getAttributs().get("copier_coller")!=null) copiercoller=true;
|
|
if(Integer.valueOf(verifStudent.getAttributs().get("nombre_modification"))<=mini_modification) pasAssezDeModification=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//nom du fichier feedback
|
|
String metaS = nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("metaSujet");
|
|
if(metaS.equals("?")) metaS = "metaSujet-inconnu";
|
|
if(metaS.isEmpty()) metaS = "metaSujet-inconnu";
|
|
String cheminFeedBack = nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier") +"-"+metaS; //+ "-DateLong" + aujourdhui.getTime()
|
|
|
|
boolean baremeABC = false;
|
|
if(nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("baremeABC")!=null) {
|
|
try {
|
|
baremeABC = Boolean.valueOf(nodana.retourneFirstEnfantsByName("ouverture").getAttributs().get("baremeABC"));
|
|
}catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
|
|
if(!baremeABC) {
|
|
if(!commandes.noNote) {
|
|
if(!plagiat) cheminFeedBack = cheminFeedBack + "-" + nodana.retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("note") + ".html";
|
|
if(plagiat) cheminFeedBack = cheminFeedBack + "-Plagiat.html";
|
|
if(copiercoller) cheminFeedBack = cheminFeedBack + "-Copier-Coller.html";
|
|
if(pasAssezDeModification) cheminFeedBack = cheminFeedBack + "-Pas assez de modification.html";
|
|
}else {
|
|
cheminFeedBack = cheminFeedBack + ".html";
|
|
}
|
|
}else {
|
|
if(!commandes.noNote) {
|
|
if(!plagiat) cheminFeedBack = cheminFeedBack + "-" + nodana.retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("noteABC") + ".html";
|
|
if(plagiat) cheminFeedBack = cheminFeedBack + "-Plagiat.html";
|
|
if(copiercoller) cheminFeedBack = cheminFeedBack + "-Copier-Coller.html";
|
|
if(pasAssezDeModification) cheminFeedBack = cheminFeedBack + "-Pas assez de modification.html";
|
|
}else {
|
|
cheminFeedBack = cheminFeedBack + ".html";
|
|
}
|
|
}
|
|
|
|
|
|
return filename + cheminFeedBack;
|
|
}
|
|
|
|
|
|
/**
|
|
* Affichage uniquement dans la console Les erreurs.
|
|
* @param nod
|
|
*/
|
|
public static StringBuilder messageSystem(node nod) {
|
|
StringBuilder Text = new StringBuilder();
|
|
|
|
node ouverture = nod.retourneFirstEnfantsByName("ouverture");
|
|
node notation = nod.retourneFirstEnfantsByName("bodyetnotation");
|
|
node erreurs = nod.retourneFirstEnfantsByName("erreurs");
|
|
|
|
boolean flagError = Boolean.valueOf(erreurs.getAttributs().get("oneError"));
|
|
Text.append("<br>");
|
|
if(!commandes.fichierStudentMoodle) {
|
|
Text.append("<p>Dossier analysé : <b>" + ouverture.getAttributs().get("dossier") + "</b></p>");
|
|
System.out.println("\nDossier analysé : " + ouverture.getAttributs().get("dossier"));}
|
|
else {
|
|
Text.append("<p>Fichier analysé : <b>" + ouverture.getAttributs().get("dossier")+"</b></p>");
|
|
System.out.println("\nFichier analysé : " + ouverture.getAttributs().get("dossier"));}
|
|
|
|
if(notation.getAttributs().get("baremeABC").equals("true")) {
|
|
Text.append("<p> Note : <b><span style=\"color:blue\">" + notation.getAttributs().get("noteABC")+"</span></b></p>");
|
|
System.out.println("\nNote : " + notation.getAttributs().get("noteABC"));
|
|
}else {
|
|
Text.append("<p>Note : <b><span style=\"color:blue\">" + notation.getAttributs().get("note") + "</span>/" + ouverture.getAttributs().get("notefrom")+"</b></p>");
|
|
System.out.println("\nNote : " + notation.getAttributs().get("note") + "/" + ouverture.getAttributs().get("notefrom"));
|
|
}
|
|
|
|
if(flagError) {
|
|
Text.append("<p>ERREUR dans le fichier de l'étudiant.</p>");
|
|
System.out.println("\t ERREUR dans le fichier de l'étudiant.");
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueHistorique"))) {
|
|
Text.append("<p>Erreur : Il n'y a pas d'historique dans le fichier.Peut être que le fichier n'a pas été modifié ou il a été réïnitialisé par l'étudiant.</p>");
|
|
System.out.println("\t Erreur : Il n'y a pas d'historique dans le fichier.Peut être que le fichier n'a pas été modifié ou il a été réïnitialisé par l'étudiant.");
|
|
}
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueCreationDate"))) {
|
|
Text.append("<p>Erreur : Ce n'est pas la bonne date de création du fichier. Le fichier a été réïnitialisé ou ce n'est pas le fichier de l'évaluation.</p>");
|
|
System.out.println("\t Erreur : Ce n'est pas la bonne date de création du fichier. Le fichier a été réïnitialisé ou ce n'est pas le fichier de l'évaluation.");
|
|
}
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueValeurCreationDate"))) {
|
|
Text.append("<p>Erreur : Ce n'est pas la bonne date de création du fichier.</p>");
|
|
System.out.println("\t Erreur : Ce n'est pas la bonne date de création du fichier.");
|
|
}
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueMetaSujet"))) {
|
|
Text.append("<p>Erreur : La propriété personnalisé \"Sujet\" a été supprimé dans le fichier de l'étudiant.</p>");
|
|
System.out.println("\t Erreur : La propriété personnalisé \"Sujet\" a été supprimé dans le fichier de l'étudiant.");
|
|
}
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueValeurMetaSujet"))) {
|
|
Text.append("<p>Erreur : La propriété personnalisé \"Sujet \" a été modifié par l'étudiant.\nLa valeur de cette propriété personnalisé dans le fichier de l'étudiant est \"" + ouverture.getAttributs().get("metaSujet")+"\".\nCe n'est pas la valeur correct.</p>");
|
|
System.out.println("\t Erreur : La propriété personnalisé \"Sujet \" a été modifié par l'étudiant.\nLa valeur de cette propriété personnalisé dans le fichier de l'étudiant est \"" + ouverture.getAttributs().get("metaSujet")+"\".\nCe n'est pas la valeur correct.");
|
|
}
|
|
|
|
if(Boolean.valueOf(erreurs.getAttributs().get("manqueInitialCreator"))) {
|
|
Text.append("<p>Erreur : Le créateur initial ne correspond pas au créateur initial du fichier fourni à l'étudiant.</p>");
|
|
System.out.println("\t Erreur : Le créateur initial n'est pas correct.");
|
|
}
|
|
}
|
|
Text.append("<br><hr>");
|
|
System.out.println();
|
|
|
|
return Text;
|
|
}
|
|
|
|
|
|
/**
|
|
* Ajoute dans le node nodanalyse.</br>
|
|
* Le node saut et son attribut titre</br>
|
|
* Et place un titre, ou titre1, ou titre2, ou titre3</br>
|
|
* <br>
|
|
* @param nod
|
|
* @return
|
|
*/
|
|
public static node addNodeSautTitre(node nodSujet, node nodanalyse, node nodmenu, Run a) {
|
|
if(nodSujet.getAttributs().get("marquenode")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("marquenode", nodSujet.getAttributs().get("marquenode"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
}
|
|
if(nodSujet.getAttributs().get("titre")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("titre", nodSujet.getAttributs().get("titre"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
if(nodSujet.getAttributs().get("addmenu")!=null) if(nodSujet.getAttributs().get("addmenu").equalsIgnoreCase("true")) {
|
|
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre"))!=null) {
|
|
N.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre")).getAttributs().get("id"));
|
|
N.getAttributs().put("addmenu", "true");
|
|
}
|
|
}
|
|
}
|
|
if(nodSujet.getAttributs().get("titre1")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("titre1", nodSujet.getAttributs().get("titre1"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
if(nodSujet.getAttributs().get("addmenu")!=null) if(nodSujet.getAttributs().get("addmenu").equalsIgnoreCase("true")) {
|
|
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre1"))!=null) {
|
|
N.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre1")).getAttributs().get("id"));
|
|
N.getAttributs().put("addmenu", "true");
|
|
}
|
|
}
|
|
}
|
|
if(nodSujet.getAttributs().get("titre2")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("titre2", nodSujet.getAttributs().get("titre2"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
if(nodSujet.getAttributs().get("addmenu")!=null) if(nodSujet.getAttributs().get("addmenu").equalsIgnoreCase("true")) {
|
|
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre2"))!=null) {
|
|
N.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre2")).getAttributs().get("id"));
|
|
N.getAttributs().put("addmenu", "true");
|
|
}
|
|
}
|
|
}
|
|
if(nodSujet.getAttributs().get("titre3")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("titre3", nodSujet.getAttributs().get("titre3"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
if(nodSujet.getAttributs().get("addmenu")!=null) if(nodSujet.getAttributs().get("addmenu").equalsIgnoreCase("true")) {
|
|
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre3"))!=null) {
|
|
N.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "titre", nodSujet.getAttributs().get("titre3")).getAttributs().get("id"));
|
|
N.getAttributs().put("addmenu", "true");
|
|
}
|
|
}
|
|
}
|
|
if(nodSujet.getAttributs().get("information")!=null) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
N.getAttributs().put("information", nodSujet.getAttributs().get("information"));
|
|
N.setParent(nodanalyse);
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
}
|
|
return nodanalyse;
|
|
}
|
|
|
|
/**
|
|
* Ajoute un saut de ligne.</br>
|
|
* @param nodSujet
|
|
* @param nodanalyse
|
|
* @return
|
|
*/
|
|
public static node addSaut(node nodSujet, node nodanalyse) {
|
|
if(nodSujet.getAttributs().get("saut")!=null) {
|
|
if(nodSujet.getAttributs().get("saut").equals("true")) {
|
|
node N = new node();
|
|
N.setNomElt("saut");
|
|
//N.getAttributs().put("titre", "");
|
|
N.setClose(true);
|
|
nodanalyse.getNodes().add(N);
|
|
}
|
|
}
|
|
|
|
return nodanalyse;
|
|
}
|
|
|
|
/**
|
|
* Vérirication des historiques
|
|
* @param verification
|
|
* @param a
|
|
* @return le node verif
|
|
*/
|
|
public static node verificationHistorique(node verification, Run a) {
|
|
|
|
|
|
node verif = new node();
|
|
verif.setNomElt("verification");
|
|
verif.setAttributs(verification.getAttributs());
|
|
verif.getAttributs().put("number_match", String.valueOf(commandes.number_match));
|
|
verif.getAttributs().put("mini_number_modification", String.valueOf(commandes.mini_number_modification));
|
|
verif.getAttributs().put("nombres_modifications_simultané_maxi", String.valueOf(commandes.nombres_modifications_simultané_maxi));
|
|
|
|
ArrayList<node> LesFichiers = verification.retourneLesEnfantsByName("fichier", new ArrayList<node>());
|
|
|
|
System.out.println();
|
|
System.out.println("***** DEBUT VERIFICATION DES HISTORIQUES DES MODIFICATION ****");
|
|
System.out.println();
|
|
|
|
commandes.message.append("\n\n***** DEBUT VERIFICATION DES HISTORIQUES DES MODIFICATION ****\n");
|
|
|
|
|
|
for(int i = 0 ; i < LesFichiers.size() ; i++) {
|
|
node nodStudent = new node();
|
|
nodStudent.setNomElt("fichier");
|
|
nodStudent.setAttributs(LesFichiers.get(i).getAttributs());
|
|
|
|
//String nameStudent1 = LesFichiers.get(i).getAttributs().get("dossier");
|
|
|
|
ArrayList<node> HitoriqueDuFichier = LesFichiers.get(i).retourneEnfantsByName("text:changed-region", new ArrayList<node>());
|
|
int nombreModifications = HitoriqueDuFichier.size();
|
|
|
|
nodStudent.getAttributs().put("nombre_modification", String.valueOf(nombreModifications));
|
|
|
|
int compteurnombreCorrespondance = 0 ;
|
|
int compteurnombreCorrespondancesSuivi = 0;
|
|
int compteurnombreCorrespondancesconsecutive = 0;
|
|
|
|
System.out.println(LesFichiers.get(i).getAttributs().get("dossier") + " - number of modifications : " + nombreModifications);
|
|
commandes.message.append("\n"+LesFichiers.get(i).getAttributs().get("dossier") + " - number of modifications : " + nombreModifications);
|
|
|
|
@SuppressWarnings("unchecked")
|
|
ArrayList<node> LesFichiers2 = (ArrayList<node>) LesFichiers.clone();
|
|
LesFichiers2.remove(i);
|
|
Dictionary<String, Integer> lesdates = new Hashtable<String, Integer>();
|
|
|
|
Date DateMini = null; //Première date de modification
|
|
|
|
// Parcours toutes les modifications dans l'historique
|
|
for(int j = 0 ; j < HitoriqueDuFichier.size(); j++) {
|
|
|
|
node nodDate = null;
|
|
node nodDateCreator = null;
|
|
String dcdate1 ="";
|
|
@SuppressWarnings("unused")
|
|
String dccreator ="";
|
|
nodDate = HitoriqueDuFichier.get(j).retourneFirstEnfantsByName("dc:date");
|
|
nodDateCreator = HitoriqueDuFichier.get(j).retourneFirstEnfantsByName("dc:creator");
|
|
if(nodDate!=null) {
|
|
dcdate1 = nodDate.getContenu().get(0);
|
|
}
|
|
if(nodDate!=null) {
|
|
dccreator = nodDateCreator.getContenu().get(0);
|
|
}
|
|
|
|
Date DcDate1 = formatDateWriter.DateLibreOffice(dcdate1);
|
|
|
|
if(DateMini==null) DateMini = DcDate1; // Amorçage de la date premère date de modification
|
|
if(DateMini!=null && DateMini.after(DcDate1)) DateMini = DcDate1; //recherche la première date de modification
|
|
|
|
|
|
if(lesdates.get(dcdate1)==null) {
|
|
lesdates.put(dcdate1, 1);
|
|
}else {
|
|
int compteur = lesdates.get(dcdate1) + 1;
|
|
lesdates.put(dcdate1, compteur);
|
|
}
|
|
|
|
|
|
node N1 = HitoriqueDuFichier.get(j).getNodes().get(0);
|
|
|
|
|
|
for(int i2 = 0 ; i2 < LesFichiers2.size(); i2++) {
|
|
String nameStudent2 = LesFichiers2.get(i2).getAttributs().get("dossier");
|
|
ArrayList<node> HitoriqueDuFichier2 = LesFichiers2.get(i2).retourneEnfantsByName("text:changed-region", new ArrayList<node>());
|
|
for(int j2 = 0 ; j2 <HitoriqueDuFichier2.size(); j2++ ) {
|
|
String dcdate2 = HitoriqueDuFichier2.get(j2).retourneFirstEnfantsByName("dc:date").getContenu().get(0);
|
|
String dccreator2 = HitoriqueDuFichier2.get(j2).retourneFirstEnfantsByName("dc:creator").getContenu().get(0);
|
|
node N2 = HitoriqueDuFichier2.get(j2).retourneFirstEnfantsByName(N1.getNomElt());
|
|
|
|
if(Run.equalNode(N1, N2)) { //Verification des deux nodes de l'historique identiques
|
|
// if(dcdate1.equals(dcdate2) && N1.getNomElt().equals(N2.getNomElt()) && dccreator.equals(dccreator2)) { //cette ligne est redondante
|
|
|
|
if(nodStudent.retourneFirstNodeByNameAndAttributValueExactStrict("correspondance", "date", dcdate2)==null) {
|
|
//affinage du match
|
|
compteurnombreCorrespondance++;
|
|
if(compteurnombreCorrespondancesSuivi==0) {
|
|
compteurnombreCorrespondancesSuivi++;
|
|
}else {
|
|
ArrayList<node> correspondances = nodStudent.retourneEnfantsByName("correspondance", new ArrayList<node>());
|
|
node c = correspondances.get(correspondances.size()-1);
|
|
if(c.getAttributs().get("Avec_etudiant").equals(nameStudent2)&&c.getAttributs().get("dc:creator").equals(dccreator2)) {
|
|
compteurnombreCorrespondancesSuivi++;
|
|
if(compteurnombreCorrespondancesconsecutive+1>compteurnombreCorrespondancesconsecutive) compteurnombreCorrespondancesconsecutive++;
|
|
}else {
|
|
compteurnombreCorrespondancesSuivi=0;
|
|
}
|
|
}
|
|
|
|
node correspondance = new node();
|
|
correspondance.getNodes().add(N2);
|
|
|
|
correspondance.setNomElt("correspondance");
|
|
correspondance.getAttributs().put("date", dcdate1);
|
|
correspondance.getAttributs().put("type",N1.getNomElt());
|
|
correspondance.getAttributs().put("Avec_etudiant", nameStudent2);
|
|
correspondance.getAttributs().put("dc:creator", dccreator2);
|
|
nodStudent.getNodes().add(correspondance);
|
|
System.out.println("\t** Trouve une correspondance ** " + dcdate1);
|
|
commandes.message.append("\n\t** Trouve une correspondance ** " + dcdate1);
|
|
break;
|
|
}
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Enumeration<String> key = lesdates.keys();
|
|
while(key.hasMoreElements()) {
|
|
String k = key.nextElement();
|
|
if(lesdates.get(k)>1) {
|
|
node modificationsMemeDate = new node();
|
|
modificationsMemeDate.setNomElt("memeinstant");
|
|
modificationsMemeDate.getAttributs().put("date", k);
|
|
modificationsMemeDate.getAttributs().put("nombres_modifications_simultané", String.valueOf(lesdates.get(k)));
|
|
if(commandes.nombres_modifications_simultané_maxi<lesdates.get(k)) {
|
|
modificationsMemeDate.getAttributs().put("copier_coller", "true");
|
|
nodStudent.getAttributs().put("copier_coller", "true");
|
|
}else {
|
|
modificationsMemeDate.getAttributs().put("copier_coller", "false");
|
|
}
|
|
nodStudent.getNodes().add(modificationsMemeDate);
|
|
}
|
|
}
|
|
|
|
node modificationsMemeDate = new node();
|
|
modificationsMemeDate.setNomElt("memeinstant");
|
|
|
|
|
|
|
|
if(compteurnombreCorrespondancesconsecutive>0)compteurnombreCorrespondancesconsecutive++; //C'est histoire des arbres et des intervalles entre les arbres. Il faut ajouter plus 1 au nombre de correspondances consecutives.
|
|
|
|
nodStudent.getAttributs().put("nombre_correspondance", String.valueOf(compteurnombreCorrespondance));
|
|
nodStudent.getAttributs().put("nombre_modifications_date_unique", String.valueOf(lesdates.size()));
|
|
nodStudent.getAttributs().put("nombre_correspondances_consecutives", String.valueOf(compteurnombreCorrespondancesconsecutive));
|
|
nodStudent.getAttributs().put("first_modification_date", String.valueOf(DateMini));
|
|
|
|
verif.getNodes().add(nodStudent);
|
|
System.out.println("\tDate de modification date unique " + String.valueOf(lesdates.size()));
|
|
commandes.message.append("\n\tDate de modification date unique " + String.valueOf(lesdates.size()));
|
|
}
|
|
|
|
// Ci-dessous le code pour vérifier la première date de modification dans le fichier.
|
|
// Recherche dans le node verif
|
|
int lastIndex = verif.getNodes().size();
|
|
for(int i = 0 ; i < lastIndex;i++) {
|
|
String D1 = verif.getNodes().get(i).getAttributs().get("first_modification_date");
|
|
boolean trouve =false;
|
|
for(int j = 0; j < lastIndex; j++) {
|
|
if(i!=j) {
|
|
String D2 = verif.getNodes().get(j).getAttributs().get("first_modification_date");
|
|
if(!D1.equals("null") && D1.equals(D2)) {
|
|
if(verif.getNodes().get(i).getAttributs().get("")==null) {
|
|
verif.getNodes().get(i).getAttributs().put("first_modification_identique", verif.getNodes().get(j).getAttributs().get("dossier"));
|
|
}else {
|
|
verif.getNodes().get(i).getAttributs().put("first_modification_identique_2", verif.getNodes().get(j).getAttributs().get("dossier"));
|
|
}
|
|
if(verif.getNodes().get(j).getAttributs().get("")==null) {
|
|
verif.getNodes().get(j).getAttributs().put("first_modification_identique", verif.getNodes().get(i).getAttributs().get("dossier"));
|
|
}else {
|
|
verif.getNodes().get(j).getAttributs().put("first_modification_identique_2", verif.getNodes().get(i).getAttributs().get("dossier"));
|
|
}
|
|
trouve=true;
|
|
}
|
|
}
|
|
}
|
|
if(!trouve) {
|
|
verif.getNodes().get(i).getAttributs().put("first_modification_identique","null");
|
|
}else {
|
|
verif.getNodes().get(i).getAttributs().put("plagiat", "probable");
|
|
System.out.println("\t\t ************************");
|
|
System.out.println("\t\t ** Plagiat PROBABLE **");
|
|
System.out.println("\t\t ************************");
|
|
|
|
commandes.message.append("\n\t\t ************************");
|
|
commandes.message.append("\n\t\t Plagiat PROBABLE ");
|
|
commandes.message.append("\n\t\t ************************");
|
|
}
|
|
}
|
|
|
|
System.out.println();
|
|
System.out.println("** FIN DE LA VERIFIACTION **");
|
|
System.out.println();
|
|
|
|
commandes.message.append("\n** FIN DE LA VERIFICATION **\n");
|
|
|
|
|
|
return verif;
|
|
|
|
}
|
|
|
|
/**
|
|
* Ecriture de l'ensemble des notes brutes sans vérification et sans rechercher les identifiants des étudiants
|
|
* @param nodesana
|
|
* @throws IOException
|
|
*/
|
|
public static void ecritureCSV(node ana) throws IOException{
|
|
Date aujourdhui = new Date();
|
|
Path outputFilePath = Paths.get(commandes.path + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) outputFilePath = Paths.get(commandes.path +"/"+ commandes.pathDestination + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
if(!commandes.fourniDossierDestination) System.out.println(commandes.path +"\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) System.out.println(commandes.path +"\\"+ commandes.pathDestination + "\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
BufferedWriter fichier = Files.newBufferedWriter(outputFilePath, StandardCharsets.UTF_8);
|
|
fichier.write("prénom nom;date modification;producteur;durée edition;sujet;note\n");
|
|
|
|
|
|
for (int i = 0 ; i < ana.getNodes().size() ; i++) {
|
|
node nodouverture = ana.getNodes().get(i).retourneFirstEnfantsByName("ouverture");
|
|
String identification = nodouverture.getAttributs().get("dossier");
|
|
String sujet = nodouverture.getAttributs().get("metaSujet");
|
|
String dateModif = nodouverture.getAttributs().get("dateModification");
|
|
String producteur = nodouverture.getAttributs().get("producteur");
|
|
String dureeEdition = nodouverture.getAttributs().get("dureeEdition");
|
|
String note = ana.getNodes().get(i).retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("note");
|
|
if(nodouverture.getAttributs().get("baremeABC")!=null) {
|
|
try {
|
|
if(Boolean.valueOf(nodouverture.getAttributs().get("baremeABC"))) {
|
|
note = ana.getNodes().get(i).retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("noteABC");
|
|
}
|
|
}catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
fichier.write(identification + ";" + dateModif + ";" + producteur + ";" + traitementDureeEdition(dureeEdition) + ";"+ sujet + ";" + traitementNote(note) + "\n");
|
|
|
|
}
|
|
fichier.close();
|
|
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*************************");
|
|
commandes.message.append("\n");
|
|
commandes.message.append("\nLe fichier au format CSV a été généré.");
|
|
commandes.message.append("\n" + outputFilePath.toString());
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*************************");
|
|
|
|
}
|
|
|
|
/**
|
|
* Ecriture du fichier CSV avec vérification.<br>
|
|
* Mais sans rechercher les identifiants des étudiants.
|
|
* @param ana
|
|
* @param verif
|
|
* @param a
|
|
* @throws IOException
|
|
*/
|
|
public static void ecritureCSV(node ana, node verif, Run a, node setting) throws IOException{
|
|
String separator =";"; //valeur par défaut du séparteur
|
|
|
|
|
|
Date aujourdhui = new Date();
|
|
Path outputFilePath = Paths.get(commandes.path + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) outputFilePath = Paths.get(commandes.path +"/"+ commandes.pathDestination + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
if(!commandes.fourniDossierDestination) System.out.println(commandes.path +"\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) System.out.println(commandes.path +"\\"+ commandes.pathDestination + "\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
|
|
|
|
BufferedWriter fichier = Files.newBufferedWriter(outputFilePath, StandardCharsets.UTF_8);
|
|
fichier.write("prénom nom;date modification;producteur;durée edition;sujet;nbr modification;nbr modification date unique;nbr match;note\n");
|
|
|
|
for (int i = 0 ; i < ana.getNodes().size() ; i++) {
|
|
node nodouverture = ana.getNodes().get(i).retourneFirstEnfantsByName("ouverture");
|
|
String identification = nodouverture.getAttributs().get("dossier");
|
|
String sujet = nodouverture.getAttributs().get("metaSujet");
|
|
String dateModif = nodouverture.getAttributs().get("dateModification");
|
|
String producteur = nodouverture.getAttributs().get("producteur");
|
|
String dureeEdition = nodouverture.getAttributs().get("dureeEdition");
|
|
|
|
node verifStudent = a.retourneNodeByNameAttributValueAttributValueExact(verif, "fichier", "dossier", identification, "dateModification", dateModif);
|
|
String note = "plagiat";
|
|
if(verifStudent!=null) {
|
|
int nbreCorrespondance = Integer.valueOf(verifStudent.getAttributs().get("nombre_correspondance"));
|
|
int nbrDateModificationUnique = Integer.valueOf(verifStudent.getAttributs().get("nombre_modifications_date_unique"));
|
|
|
|
if(nbreCorrespondance<=commandes.number_match) {
|
|
note = ana.getNodes().get(i).retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("note");
|
|
if(nodouverture.getAttributs().get("baremeABC")!=null) {
|
|
try {
|
|
if(Boolean.valueOf(nodouverture.getAttributs().get("baremeABC"))) {
|
|
note = ana.getNodes().get(i).retourneFirstEnfantsByName("bodyetnotation").getAttributs().get("noteABC");
|
|
}
|
|
}catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
}
|
|
if(nbrDateModificationUnique<commandes.mini_number_modification) {
|
|
note = note + separator + "copy";
|
|
}
|
|
|
|
String nbrModification = verifStudent.getAttributs().get("nombre_modification");
|
|
String nombre_modifications_date_unique = verifStudent.getAttributs().get("nombre_modifications_date_unique");
|
|
|
|
|
|
fichier.write(identification + separator + dateModif + separator + producteur + separator + traitementDureeEdition(dureeEdition) + separator + sujet + separator + nbrModification + separator + nombre_modifications_date_unique + separator + nbreCorrespondance + separator + traitementNote(note) + "\n");
|
|
}
|
|
|
|
}
|
|
fichier.close();
|
|
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*************************");
|
|
commandes.message.append("\n");
|
|
commandes.message.append("\nLe fichier au format CSV a été généré.");
|
|
commandes.message.append("\n" + outputFilePath.toString());
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*************************");
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Ecriture du fichier CSV avec ou sans vérification.<br>
|
|
* Mais avec rechercher des identifiants des étudiants.<br>
|
|
* @param ana
|
|
* @param verif
|
|
* @param a
|
|
* @param nodeCVS
|
|
* @param verification
|
|
* @throws IOException
|
|
*/
|
|
public static void ecritureCSV(node ana, node verif, Run a, node nodeCVS, node setting) throws IOException {
|
|
|
|
String separator =";"; //valeur par défaut du séparteur
|
|
Charset encoding = StandardCharsets.UTF_8; //valeur par défaut
|
|
String champMoodleEmail = "adresse";
|
|
String champMoodleNumeroEtudiant = "identification";
|
|
String champPrenom = "prenom";
|
|
String champNom= "nom";
|
|
|
|
if(setting.getNomElt().equals("setting")) {
|
|
if(setting.containElementByName("csv")){
|
|
node csv = setting.retourneFirstEnfantsByName("csv");
|
|
if(csv.getAttributs().get("separator")!=null)separator = csv.getAttributs().get("separator");
|
|
if(csv.getAttributs().get("encoding")!=null) {
|
|
if(csv.getAttributs().get("encoding").equals("UFT-8")) encoding = StandardCharsets.UTF_8;
|
|
if(csv.getAttributs().get("encoding").equals("ISO-8859-1")) encoding = StandardCharsets.ISO_8859_1;
|
|
if(csv.getAttributs().get("encoding").equals("US-ASCII")) encoding = StandardCharsets.US_ASCII;
|
|
if(csv.getAttributs().get("encoding").equals("UTF-16")) encoding = StandardCharsets.UTF_16;
|
|
if(csv.getAttributs().get("encoding").equals("UTF-16BE")) encoding = StandardCharsets.UTF_16BE;
|
|
if(csv.getAttributs().get("encoding").equals("UTF-16LE")) encoding = StandardCharsets.UTF_16LE;
|
|
if(csv.containElementByName("import_moodle")) {
|
|
node import_moodle = csv.retourneFirstEnfantsByName("import_moodle");
|
|
if(import_moodle.getAttributs().get("email")!=null) champMoodleEmail=import_moodle.getAttributs().get("email");
|
|
if(import_moodle.getAttributs().get("id")!=null) champMoodleNumeroEtudiant=import_moodle.getAttributs().get("id");
|
|
if(import_moodle.getAttributs().get("firstname")!=null) champPrenom=import_moodle.getAttributs().get("firstname");
|
|
if(import_moodle.getAttributs().get("name")!=null) champNom=import_moodle.getAttributs().get("name");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
Date aujourdhui = new Date();
|
|
Path outputFilePath = Paths.get(commandes.path + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) outputFilePath = Paths.get(commandes.path +"/"+ commandes.pathDestination + "/DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
if(!commandes.fourniDossierDestination) System.out.println(commandes.path +"\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
if(commandes.fourniDossierDestination) System.out.println(commandes.path +"\\"+ commandes.pathDestination + "\\DateLong" + aujourdhui.getTime()+ "-Notes.csv");
|
|
|
|
BufferedWriter fichier = Files.newBufferedWriter(outputFilePath, encoding);
|
|
fichier.write("prénom nom"+separator+"email"+separator+"identifiant"+separator+"date modification"+separator+"producteur"+separator+"durée edition"+separator+"sujet"+separator+"nbr modification" + separator + "nbr modifications date unique" + separator+ "nbr match consecutif" + separator +"note" + separator +"commentaire\n");
|
|
|
|
for (int i = 0 ; i < ana.getNodes().size() ; i++) {
|
|
node nodouverture = ana.getNodes().get(i).retourneFirstEnfantsByName("ouverture");
|
|
node bodyetnotation = ana.getNodes().get(i).retourneFirstEnfantsByName("bodyetnotation");
|
|
String identification = nodouverture.getAttributs().get("dossier");
|
|
String sujet = nodouverture.getAttributs().get("metaSujet");
|
|
String dateModif = nodouverture.getAttributs().get("dateModification");
|
|
String producteur = nodouverture.getAttributs().get("producteur");
|
|
String dureeEdition = nodouverture.getAttributs().get("dureeEdition");
|
|
String mail = "-";
|
|
String numeroEtudiant = "-";
|
|
|
|
node verifStudent = null;
|
|
|
|
if(commandes.verifHisto2) verifStudent = a.retourneNodeByNameAttributValueAttributValueExact(verif, "fichier", "dossier", identification, "dateModification", dateModif);
|
|
String note = "";
|
|
|
|
//** rechercher les correspondances avec le prénom et le nom de l'étudiant
|
|
String[] ident = identification.split(" "); //séparateur entre le prénom et le nom par un espace
|
|
node A=null;
|
|
if(ident.length==2) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, ident[0], champNom, ident[1]);
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
}
|
|
if(ident.length==3) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, "\"" + ident[0] + " " + ident[1] +"\"", champNom, ident[2]);
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
if(A==null) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, ident[0], champNom, "\"" +ident[1] + " " + ident[2] + "\"");
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
}
|
|
}
|
|
if(ident.length==4) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, ident[0], champNom, "\"" + ident[1] + " " + ident[2] + " " + ident[3] + "\"");
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
if(A==null) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, "\"" + ident[0] + " " + ident[1] +"\"", champNom, "\"" + ident[2] + " " + ident[3] + "\"");
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
}
|
|
if(A==null) {
|
|
A = a.retourneNodeByNameAttributValueAttributValueExact(nodeCVS, "student", champPrenom, "\"" + ident[0] + " " + ident[1] + ident[2] + "\"", champNom, ident[3]);
|
|
if(A!=null) {
|
|
mail = A.getAttributs().get("\"" + champMoodleEmail + "\"");
|
|
if(mail==null) mail = A.getAttributs().get("'"+ champMoodleEmail +"'");
|
|
if(mail==null) mail = A.getAttributs().get(champMoodleEmail);
|
|
numeroEtudiant = A.getAttributs().get("\"" + champMoodleNumeroEtudiant + "\"");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get("'" + champMoodleNumeroEtudiant + "'");
|
|
if(numeroEtudiant==null) numeroEtudiant = A.getAttributs().get(champMoodleNumeroEtudiant);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if(commandes.verifHisto2) if(verifStudent!=null) {
|
|
int nbreCorrespondanceConsecutive = Integer.valueOf(verifStudent.getAttributs().get("nombre_correspondances_consecutives"));
|
|
int nbrDateModificationUnique = Integer.valueOf(verifStudent.getAttributs().get("nombre_modifications_date_unique"));
|
|
note = bodyetnotation.getAttributs().get("note");
|
|
if(bodyetnotation.getAttributs().get("baremeABC")!=null) {
|
|
try {
|
|
if(Boolean.valueOf(bodyetnotation.getAttributs().get("baremeABC"))) {
|
|
note = bodyetnotation.getAttributs().get("noteABC");
|
|
}
|
|
}catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
if(nbreCorrespondanceConsecutive>commandes.number_match) {
|
|
bodyetnotation.getAttributs().put("commentaire","Echange de fichier - plagiat");
|
|
note = "0" ;
|
|
}
|
|
if(nbrDateModificationUnique<=commandes.mini_number_modification) {
|
|
bodyetnotation.getAttributs().put("commentaire","pas assez de modification.");
|
|
note="0";
|
|
}
|
|
if(!verifStudent.getAttributs().get("first_modification_identique").equals("null") && nbreCorrespondanceConsecutive>=commandes.number_match) {
|
|
note = "0" ;
|
|
bodyetnotation.getAttributs().put("commentaire","Echange de fichier - plagiat");
|
|
}
|
|
if(verifStudent.getAttributs().get("copier_coller")!=null){
|
|
bodyetnotation.getAttributs().put("commentaire","des copiés et des collés");
|
|
}
|
|
String nbrModification = verifStudent.getAttributs().get("nombre_modification");
|
|
String nombre_modifications_date_unique = verifStudent.getAttributs().get("nombre_modifications_date_unique");
|
|
|
|
fichier.write(identification + separator + mail + separator + numeroEtudiant + separator + dateModif + separator + producteur + separator + traitementDureeEdition(dureeEdition) + separator + sujet + separator + nbrModification +separator + nombre_modifications_date_unique + separator + nbreCorrespondanceConsecutive + separator + traitementNote(note) + separator + bodyetnotation.getAttributs().get("commentaire")+"\n");
|
|
}
|
|
|
|
if(!commandes.verifHisto2) {
|
|
note = bodyetnotation.getAttributs().get("note");
|
|
if(bodyetnotation.getAttributs().get("baremeABC")!=null) {
|
|
try {
|
|
if(Boolean.valueOf(bodyetnotation.getAttributs().get("baremeABC"))) {
|
|
note = bodyetnotation.getAttributs().get("noteABC");
|
|
}
|
|
}catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
fichier.write(identification + separator + mail + separator + numeroEtudiant + separator + dateModif + separator + producteur + separator + traitementDureeEdition(dureeEdition) + separator + sujet + separator + "" + separator + "" + "" + separator + "" + separator + traitementNote(note) + separator + bodyetnotation.getAttributs().get("commentaire")+"\n");
|
|
}
|
|
|
|
|
|
}
|
|
fichier.close();
|
|
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*-***********************");
|
|
commandes.message.append("\n");
|
|
commandes.message.append("\nLe fichier au format CSV a été généré.");
|
|
commandes.message.append("\n" + outputFilePath.toString());
|
|
commandes.message.append("\n");
|
|
commandes.message.append("*************************");
|
|
}
|
|
|
|
/**
|
|
* Traitement de la durée d'édition.<br>
|
|
* <br>
|
|
* @param dureeEdition
|
|
* @return
|
|
*/
|
|
public static String traitementDureeEdition(String dureeEdition) {
|
|
dureeEdition = dureeEdition.replace("P", "");
|
|
dureeEdition = dureeEdition.replace("D", " j ");
|
|
dureeEdition = dureeEdition.replace("T", " ");
|
|
dureeEdition = dureeEdition.replace("H", " h ");
|
|
dureeEdition = dureeEdition.replace("M", " min ");
|
|
dureeEdition = dureeEdition.replace("S", " s");
|
|
return dureeEdition;
|
|
}
|
|
|
|
/**
|
|
* Remplace la virgule par un point.<br>
|
|
* <br>
|
|
* @param note
|
|
* @return
|
|
*/
|
|
private static String traitementNote(String note) {
|
|
if(note==null) return note;
|
|
note = note.replace(",", ".");
|
|
return note;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Chargement dans un node du fichier CSV de la liste des étudiants.<br>
|
|
* La liste des étudiants doit contenir les champs Prénom, Nom, Numéro d'identification, Adresse de courriel
|
|
* Le séparateur doit être le point-virgule et l'encodage UTF-8.
|
|
* @param a
|
|
* @param nameCSV
|
|
* @return
|
|
* @throws IOException
|
|
*/
|
|
public static node chargementFichierCSV() {
|
|
String targetString = "";
|
|
|
|
String cheminVersLeFichierCSV = "";
|
|
|
|
if(commandes.console) cheminVersLeFichierCSV = commandes.path + "/" + commandes.nameCSV;
|
|
|
|
if(!commandes.console) {
|
|
commandes.nameCSV = commandes.nameCSV.replace("\\", "/");
|
|
cheminVersLeFichierCSV = commandes.nameCSV;
|
|
}
|
|
|
|
try {
|
|
BufferedReader br = new BufferedReader(
|
|
new InputStreamReader(
|
|
new FileInputStream(cheminVersLeFichierCSV), "UTF-8"));
|
|
|
|
String line;
|
|
while ((line = br.readLine()) != null) {
|
|
targetString = targetString + line + "\n";
|
|
}
|
|
|
|
br.close();
|
|
} catch (IOException e) {
|
|
commandes.clotureWithErrorFile(cheminVersLeFichierCSV);
|
|
e.printStackTrace();
|
|
}
|
|
|
|
|
|
String[] target = targetString.split("\\n");
|
|
node nodeCVS = new node();
|
|
nodeCVS.setNomElt("fileCSV");
|
|
String[] line1 = target[0].split(";");
|
|
for(int i = 1 ; i < target.length ; i++) {
|
|
node nodeEtudiant = new node();
|
|
nodeEtudiant.setNomElt("student");
|
|
for(int j = 0 ; j < line1.length; j++) {
|
|
nodeEtudiant.getAttributs().put(line1[j], target[i].split(";")[j]);
|
|
}
|
|
nodeCVS.getNodes().add(nodeEtudiant);
|
|
}
|
|
|
|
//a.ecritureNodeEnXML(nodeCVS, "nodeCVS"); //écriture du node du node CSV
|
|
return nodeCVS;
|
|
}
|
|
|
|
/**
|
|
* Charge le fichier SVG pour le nouveau Logo dans les feedbacks
|
|
* @param a
|
|
* @param nameSVG
|
|
* @return
|
|
*/
|
|
public static String chargementFichierSVG() {
|
|
String targetString = "";
|
|
String cheminVersFichier = commandes.nameSVG;
|
|
if(commandes.console) cheminVersFichier =commandes.path + "/" + commandes.nameSVG;
|
|
|
|
try {
|
|
BufferedReader br = new BufferedReader(
|
|
new InputStreamReader(
|
|
new FileInputStream(cheminVersFichier), "UTF-8"));
|
|
|
|
String line;
|
|
while ((line = br.readLine()) != null) {
|
|
targetString = targetString + line + "\n";
|
|
}
|
|
|
|
br.close();
|
|
} catch (IOException e) {
|
|
commandes.clotureWithErrorFile(commandes.nameSVG);
|
|
e.printStackTrace();
|
|
}
|
|
return targetString;
|
|
}
|
|
|
|
|
|
public static node ajouteValeurParDefautAuStyleParagraph(node ensembleDesParagraphes ) {
|
|
node LesStyleDefaut = null;
|
|
|
|
if(ensembleDesParagraphes.retourneEnfantsByNameExist("style:default-style")) {
|
|
LesStyleDefaut = ensembleDesParagraphes.retourneFirstEnfantsByName("style:default-style");
|
|
}
|
|
|
|
for(int i =0 ; i < ensembleDesParagraphes.getNodes().size(); i++) {
|
|
|
|
node nodStyle = ensembleDesParagraphes.getNodes().get(i);
|
|
//le paragarph properties
|
|
node nodeStyleParDefautParagraphProperties = LesStyleDefaut.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
node LesNodesStyleParagraph = nodStyle.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
Enumeration<String > K = nodeStyleParDefautParagraphProperties.getAttributs().keys();
|
|
while(K.hasMoreElements()){
|
|
String Key = K.nextElement();
|
|
if(LesNodesStyleParagraph.getNomElt().equals("style:paragraph-properties")) {
|
|
if(LesNodesStyleParagraph.getAttributs().get(Key)==null) {
|
|
LesNodesStyleParagraph.getAttributs().put(Key, nodeStyleParDefautParagraphProperties.getAttributs().get(Key));
|
|
}
|
|
}else {
|
|
node n = new node();
|
|
n.setNomElt("style:paragraph-properties");
|
|
n.setAttributs(nodeStyleParDefautParagraphProperties.getAttributs());
|
|
nodStyle.getNodes().add(n);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//le text properties
|
|
node nodeStyleParDefautTextProperties = LesStyleDefaut.retourneFirstEnfantsByName("style:text-properties");
|
|
node LesNodesStyleText = nodStyle.retourneFirstEnfantsByName("style:text-properties");
|
|
K = nodeStyleParDefautTextProperties.getAttributs().keys();
|
|
while(K.hasMoreElements()){
|
|
String Key = K.nextElement();
|
|
if(LesNodesStyleText.getNomElt().equals("style:text-properties")) {
|
|
if(LesNodesStyleText.getAttributs().get(Key)==null) {
|
|
LesNodesStyleText.getAttributs().put(Key, nodeStyleParDefautTextProperties.getAttributs().get(Key));
|
|
}
|
|
}else {
|
|
node n = new node();
|
|
n.setNomElt("style:text-properties");
|
|
n.setAttributs(nodeStyleParDefautTextProperties.getAttributs());
|
|
nodStyle.getNodes().add(n);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return ensembleDesParagraphes;
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param ensembleDesParagraphes
|
|
* @return
|
|
*/
|
|
public static node ajouteValeurLesValeursDuStyleParagraphParent(node ensembleDesParagraphes) {
|
|
|
|
for(int i = 0 ; i < ensembleDesParagraphes.getNodes().size(); i++) {
|
|
|
|
node nodStyle = ensembleDesParagraphes.getNodes().get(i);
|
|
|
|
|
|
node parent = null;
|
|
if(nodStyle.getAttributs().get("style:parent-style-name")!=null) {
|
|
String nameStyleParent = nodStyle.getAttributs().get("style:parent-style-name");
|
|
if(ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nameStyleParent)!=null) {
|
|
parent = ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nameStyleParent);
|
|
}
|
|
}
|
|
|
|
|
|
if(parent!=null) {
|
|
|
|
addStyleParent(parent, nodStyle, ensembleDesParagraphes);
|
|
// //le paragraph properties
|
|
// node nodeStyleParentParagraphProperties = parent.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
// node LesNodesStyleParagraph = nodStyle.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
// Enumeration<String > K = nodeStyleParentParagraphProperties.getAttributs().keys();
|
|
// while(K.hasMoreElements()){
|
|
// String Key = K.nextElement();
|
|
// if(LesNodesStyleParagraph.getNomElt().equals("style:paragraph-properties")) {
|
|
// if(LesNodesStyleParagraph.getAttributs().get(Key)==null) {
|
|
// LesNodesStyleParagraph.getAttributs().put(Key, nodeStyleParentParagraphProperties.getAttributs().get(Key));
|
|
// }
|
|
// }else {
|
|
// node n = new node();
|
|
// n.setNomElt("style:paragraph-properties");
|
|
// n.setAttributs(nodeStyleParentParagraphProperties.getAttributs());
|
|
// nodStyle.getNodes().add(n);
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// //le text properties
|
|
// node nodeStyleParDefautTextProperties = parent.retourneFirstEnfantsByName("style:text-properties");
|
|
// node LesNodesStyleText = nodStyle.retourneFirstEnfantsByName("style:text-properties");
|
|
// K = nodeStyleParDefautTextProperties.getAttributs().keys();
|
|
// while(K.hasMoreElements()){
|
|
// String Key = K.nextElement();
|
|
// if(LesNodesStyleText.getNomElt().equals("style:text-properties")) {
|
|
// if(LesNodesStyleText.getAttributs().get(Key)==null) {
|
|
// LesNodesStyleText.getAttributs().put(Key, nodeStyleParDefautTextProperties.getAttributs().get(Key));
|
|
// }
|
|
// }else {
|
|
// node n = new node();
|
|
// n.setNomElt("style:text-properties");
|
|
// n.setAttributs(nodeStyleParDefautTextProperties.getAttributs());
|
|
// nodStyle.getNodes().add(n);
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ensembleDesParagraphes;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Ajout les informations du style parent
|
|
private static void addStyleParent(node parent, node nodStyle, node ensembleDesParagraphes) {
|
|
|
|
|
|
if(parent.getAttributs().get("style:parent-style-name")!=null) {
|
|
String nameStyleParent = nodStyle.getAttributs().get("style:parent-style-name");
|
|
if(ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nameStyleParent)!=null) {
|
|
node parent2 = ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValueExactStrict("style:style", "style:name", nameStyleParent);
|
|
if(parent!=null) addStyleParent(parent2, parent, ensembleDesParagraphes);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//le paragraph properties
|
|
node nodeStyleParentParagraphProperties = parent.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
node LesNodesStyleParagraph = nodStyle.retourneFirstEnfantsByName("style:paragraph-properties");
|
|
Enumeration<String > K = nodeStyleParentParagraphProperties.getAttributs().keys();
|
|
while(K.hasMoreElements()){
|
|
String Key = K.nextElement();
|
|
if(LesNodesStyleParagraph.getNomElt().equals("style:paragraph-properties")) {
|
|
if(LesNodesStyleParagraph.getAttributs().get(Key)==null) {
|
|
LesNodesStyleParagraph.getAttributs().put(Key, nodeStyleParentParagraphProperties.getAttributs().get(Key));
|
|
}
|
|
}else {
|
|
node n = new node();
|
|
n.setNomElt("style:paragraph-properties");
|
|
n.setAttributs(nodeStyleParentParagraphProperties.getAttributs());
|
|
nodStyle.getNodes().add(n);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//le text properties
|
|
node nodeStyleParDefautTextProperties = parent.retourneFirstEnfantsByName("style:text-properties");
|
|
node LesNodesStyleText = nodStyle.retourneFirstEnfantsByName("style:text-properties");
|
|
K = nodeStyleParDefautTextProperties.getAttributs().keys();
|
|
while(K.hasMoreElements()){
|
|
String Key = K.nextElement();
|
|
if(LesNodesStyleText.getNomElt().equals("style:text-properties")) {
|
|
if(LesNodesStyleText.getAttributs().get(Key)==null) {
|
|
LesNodesStyleText.getAttributs().put(Key, nodeStyleParDefautTextProperties.getAttributs().get(Key));
|
|
}
|
|
}else {
|
|
node n = new node();
|
|
n.setNomElt("style:text-properties");
|
|
n.setAttributs(nodeStyleParDefautTextProperties.getAttributs());
|
|
nodStyle.getNodes().add(n);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|