analyseWriter/src/MEPTL/meptl.java

3803 lines
179 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.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
//import java.time.LocalDateTime;
//import java.time.format.DateTimeFormatter;
//import java.time.format.FormatStyle;
import java.util.ArrayList;
import java.util.Date;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;
//import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
import cXML.node;
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;
/**
* 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);
//** Node pour le chargement du node sujet (fichier d'analyse)
node nodeSujet = new node();
//** Nouveau node qui permet de convertir le fichier contenant la liste des étudiants en node.
node nodeCSV = null;
//** Initialisation des varaibles
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),"",false,""); //é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),"",false,"Sujet");
}
//** bye bye analyseWriter
commandes.clotureApplication();
}
//***********************************************************************************
//** PREPARATION du node Sujet pour analyse -use file.xml ou -use file.xml -sujet **
//***********************************************************************************
if(commandes.analyse) {
nodeSujet = chargementsujet(commandes.nameSujet, true);
//** Chargement de la culture **
commandes.culture = nodeSujet.retourneFirstEnfantsByName("setting").getAttributs().get("culture"); //récupère la culture de l'utilisateur
//** La méthode verificationFichier Analyse permet de détecter des erreurs dans le fichier d'analyse
new verificationFichierAnalyse(nodeSujet);
if(verificationFichierAnalyse.erreur==true) verificationFichierAnalyse.clotureWithErrorInanalyzeFile();
//a.ecritureNodeEnXML(nodeSujet, "sujet","",false); // ecriture du node sujet
//** Nouvelle ecriture du fichier si MAJ fichier**
if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
nodeSujet.getAttributs().put("hash", commandes.hash);
nodeSujet.getAttributs().put("analysis_filename", commandes.nameSujet);
}
try {
//***********************
//** -newlogo file.svg **
//***********************
if(commandes.newLogo && !commandes.nameSVG.isEmpty()) {
commandes.contenuFichierSVG= chargementFichierSVG(a,commandes.nameSVG);
}
//***********************************************************************
//** chargement du node translation qui se trouve dans le node setting **
//***********************************************************************
outils.chargeTraduction(nodeSujet.retourneFirstEnfantsByName("translation"));
//************************************************
//** Charge les nouvelles tolérances pour texte **
//************************************************
if(nodeSujet.containElementByName("text:similarity")) {
node similarity = nodeSujet.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(nodeSujet.containElementByName("plagiarism")) {
node plagiarism = nodeSujet.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(nodeSujet.containElementByName("color")) {
node color = nodeSujet.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"));
}
//**********************************************
//** Chargement et verification du CVS fourni **
//**********************************************
if(commandes.fourniCSV) {
nodeCSV = chargementFichierCSV(a, commandes.nameCSV);
}
}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.pathDestination,commandes.fourniDossierDestination, "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 **
//**********************************
if(commandes.analyse) {
node init = InitialisationAvantAnalyse(nodeSujet);
if(!Boolean.valueOf(init.getAttributs().get("erreur"))) {
// a.ecritureNodeEnXML(nodStudent, "fichier student",patch,false,""); //écriture du node analyse de l'étudiant
node ana = analyse(nodStudent, nodeSujet, i, a);
// a.ecritureNodeEnXML(ana, "nodana"+ana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"),"",false,""); //écriture du node analyse de l'étudiant
//****************************
//** Création des feedbacks **
//****************************
if(!commandes.sansFeeback) {
if(!commandes.zipfeedback) {
//feedback(ana, verif); //classique directement dans le répertoire
feedbacks.feedback(ana,verif, false);
}
if(commandes.zipfeedback) { // Dans une archive pour Moodle
try {
long size = 48000000; //valeur par défaut
String nameZip = "feedbackMoodle"; //nom zip par défaut
node zip = nodeSujet.retourneFirstEnfantsByName("zip");
if(zip!=null) {
if(zip.getAttributs().get("size")!=null)size = Long.valueOf(zip.getAttributs().get("size"));
if(zip.getAttributs().get("name")!=null)nameZip = zip.getAttributs().get("name");
}
//a.AddStreamToZip(feedbackForZip(ana, verif), retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),size,nameZip);
a.AddStreamToZip(feedbacks.feedback(ana, verif, true), retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),size,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 {
}
}
}
//*****************************************************
//** 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,nodeSujet.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, nodeSujet.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.<br>
* <br>
* @param nod node
* @param a
* @param i
* @return
*/
private 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");
fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().get(0));
fichier.getAttributs().put("dateModification", nodmeta.retourneFirstEnfantsByName("dc:date").getContenu().get(0));
fichier.getAttributs().put("dureeEdition", nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().get(0));
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;
}
/**
* Lecture du fichier Writer des étudiants et fournir tous les nodes de la lecture dans un node nommé "fichier".
* @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")
private 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(!commandes.ecritCode) {
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"));
// // le node des styles de formatage direct
// node nodstyleformatage = new node();
// nodstyleformatage.setNomElt("style:formatagedirect");
// nodstyleformatage.addNode(a.NodesAyantAttribut(nodstyle, "style:family","text")); //c'est redondant puisque déjà présent dans style:paragraph
//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"));
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 paragraphe
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) {
for(int k = 0 ; k < nods1.size();k++) {
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(nods1.get(k));
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));
p.getNodes().add(nodstructure.getNodes().get(j));
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"));
p.getNodes().add(nodstructure.getNodes().get(j));
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"));
}
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 graphique 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.setNodes(nodpage);
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));
}
fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfantsByName("meta:generator").getContenu().get(0));
fichier.getAttributs().put("dureeEdition", nodmeta.retourneFirstEnfantsByName("meta:editing-duration").getContenu().get(0));
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 attrinuts
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,"0"); //ajoute les numéros d'index et des attributs
fichier.getNodes().add(structurePage);
fichier.getNodes().add(nodhistorique);
return fichier;
}
/**
* 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 chargementsujet(String nameSujet, Boolean sansNodeEvaluer) throws CloneNotSupportedException, IOException {
String targetString = "";
//read file into stream, try-with-resources
try {
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream(Run.path + "/" + nameSujet), "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);
}
if(sansNodeEvaluer) {
LeNodeSujet = Run.NodesAyantAttributEvaluerTRUEavecComplement(LeNodeSujet);
}
return LeNodeSujet;
}
/**
* Vérification du node sujet (premier node <b>fichier</b> et des paramètres.<br>
* <br>
* @param nodSujet
* @return
*/
private static node InitialisationAvantAnalyse(node nodSujet) {
node initSujet = new node();
initSujet.setNomElt("init");
boolean erreur=false;
boolean erreurNomPremierNodeFichier=false;
boolean erreurManqueAttributEvaluerPremierNodeFichier=false;
boolean erreurValeurAttributEvaluerPremierNodeFichier=false;
boolean erreurPasNodesEnfantsAuPremierNodeFichier=false;
boolean erreurPasAttributMetaSujetAuPremierNodeFichier=false;
boolean erreurValeurVideAttributMetaSujetAuPremierNodeFichier=false;
boolean erreurValeurAttributProgressionNonConvertibleEnDouble=false;
boolean erreurValeurAttributNoteFromNonConvertibleEnDouble=false;
if(!nodSujet.getNomElt().equals("fichier")) {
erreur=true;
erreurNomPremierNodeFichier = true;
}
if(nodSujet.getAttributs().get("evaluer")==null) {
erreur=true;
erreurManqueAttributEvaluerPremierNodeFichier = true;
}
if(!nodSujet.getAttributs().get("evaluer").equals("true")) {
erreur=true;
erreurValeurAttributEvaluerPremierNodeFichier=true;
}
if(nodSujet.getNodes().size()==0) {
erreur=true;
erreurPasNodesEnfantsAuPremierNodeFichier=true;
}
if(nodSujet.getAttributs().get("metaSujet")==null) {
erreur=true;
erreurPasAttributMetaSujetAuPremierNodeFichier=true;
}
if(nodSujet.getAttributs().get("metaSujet")!=null) {
if(nodSujet.getAttributs().get("metaSujet").isEmpty()) {
erreur=true;
erreurValeurVideAttributMetaSujetAuPremierNodeFichier=true;
}
}
if(nodSujet.getAttributs().get("progression")!=null) {
String p = nodSujet.getAttributs().get("progression");
try {
Double.valueOf(p);
} catch (Exception e) {
erreur=true;
erreurValeurAttributProgressionNonConvertibleEnDouble=true;
}
}
if(nodSujet.getAttributs().get("notefrom")!=null) {
String p = nodSujet.getAttributs().get("notefrom");
try {
Double.valueOf(p);
} catch (Exception e) {
erreur=true;
erreurValeurAttributNoteFromNonConvertibleEnDouble=true;
}
}
initSujet.getAttributs().put("erreur",String.valueOf(erreur));
initSujet.getAttributs().put("erreurNomPremierNodeFichier",String.valueOf(erreurNomPremierNodeFichier));
initSujet.getAttributs().put("erreurManqueAttributEvaluerPremierNodeFichier",String.valueOf(erreurManqueAttributEvaluerPremierNodeFichier));
initSujet.getAttributs().put("erreurValeurAttributEvaluerPremierNodeFichier",String.valueOf(erreurValeurAttributEvaluerPremierNodeFichier));
initSujet.getAttributs().put("erreurPasNodesEnfantsAuPremierNodeFichier",String.valueOf(erreurPasNodesEnfantsAuPremierNodeFichier));
initSujet.getAttributs().put("erreurPasAttributMetaSujetAuPremierNodeFichier",String.valueOf(erreurPasAttributMetaSujetAuPremierNodeFichier));
initSujet.getAttributs().put("erreurValeurVideAttributMetaSujetAuPremierNodeFichier",String.valueOf(erreurValeurVideAttributMetaSujetAuPremierNodeFichier));
initSujet.getAttributs().put("erreurValeurAttributProgressionNonConvertibleEnDouble",String.valueOf(erreurValeurAttributProgressionNonConvertibleEnDouble));
initSujet.getAttributs().put("erreurValeurAttributNoteFromNonConvertibleEnDouble",String.valueOf(erreurValeurAttributNoteFromNonConvertibleEnDouble));
return initSujet;
}
/**
* Début de l'analyse par comparaison du node étudiant avec le node sujet.
* @param nodStudent, le node étudiant.
* @param nodSujet, le node sujet.
* @param indexStudent, index de l'étudiant
* @param a, objet Run de la class cXML
* @return le node analyse contenant toute l'analyse.
*/
private static node analyse(node nodStudent, node nodSujet, Integer indexStudent, Run a) {
// initialisation des nodes d'analyse
node erreurs = new node();
node nodmeta = new node();
node nodpage = new node();
node nodparagraph = new node();
node nodsequence = new node();
node nodnumerochapitre = new node();
node nodframes = new node();
node nodsections = new node();
node nodtableaux = new node();
node nodbiblio = new node();
node nodtablematieres = new node();
node nodtableillustrations = new node();
node nodstructurepage = new node();
// ouverture
node nodouverture = new node();
nodouverture.setNomElt("ouverture");
nodouverture.setAttributs(nodSujet.getAttributs());
nodouverture.getAttributs().put("dossier",a.getLectDossiers().getEC().getListeNomDossier().get(indexStudent));
nodouverture.getAttributs().put("filename", a.getLectDossiers().getEC().getListeFichierodt().get(indexStudent));
nodouverture.getAttributs().put("filenameAnalyse", nodSujet.getAttributs().get("filename"));
nodouverture.getAttributs().put("producteur", nodStudent.getAttributs().get("producteur"));
nodouverture.getAttributs().put("dureeEdition", nodStudent.getAttributs().get("dureeEdition"));
nodouverture.getAttributs().put("dateModification", nodStudent.getAttributs().get("dateModification"));
nodouverture.getAttributs().put("patch", a.getPatch());
if(nodSujet.getAttributs().get("historiquePresent")!=null) nodouverture.getAttributs().put("historiquePresent", nodSujet.getAttributs().get("historiquePresent"));
if(nodSujet.getAttributs().get("controleDateCreation")!=null) nodouverture.getAttributs().put("controleDateCreation", nodSujet.getAttributs().get("controleDateCreation"));
if(nodSujet.getAttributs().get("presenceMetaSujet")!=null) nodouverture.getAttributs().put("presenceMetaSujet", nodSujet.getAttributs().get("presenceMetaSujet"));
if(nodSujet.getAttributs().get("baremeABC")!=null) nodouverture.getAttributs().put("baremeABC", nodSujet.getAttributs().get("baremeABC"));
nodouverture.setClose(true);
//Body et note (par défaut valeur nulle)
node nodbodyetnotation = new node();
nodbodyetnotation.setNomElt("bodyetnotation");
nodbodyetnotation.getAttributs().put("note", "0");
nodbodyetnotation.getAttributs().put("commentaire", "");
nodbodyetnotation.getAttributs().put("proportioncorrect", "0");
nodbodyetnotation.getAttributs().put("baremeABC", "false");
if(nodSujet.getAttributs().get("baremeABC")!=null) nodbodyetnotation.getAttributs().put("baremeABC", nodSujet.getAttributs().get("baremeABC"));
nodbodyetnotation.setClose(true);
//Le menu
node nodmenu = new node();
nodmenu.setNomElt("menu");
nodmenu = a.retourneNodeMenu(nodSujet, nodmenu, 0, 0);
nodmenu.setClose(true);
// verification de la métadonnées Sujet
erreurs = retourneNodeErreur(nodStudent, nodSujet, a);
// verification si au moins une erreur alors l'analyse est terminée
if(Boolean.valueOf(erreurs.getAttributs().get("oneError"))){
return clotureNodeAnalyse(nodouverture, nodbodyetnotation, nodmenu, erreurs, nodmeta, nodpage, nodparagraph, nodsequence, nodnumerochapitre, nodframes, nodsections, nodtableaux, nodbiblio, nodtablematieres, nodtableillustrations, nodstructurepage, nodSujet.getContenu().get(0));
}
// analyse Meta
if(nodSujet.retourneFirstEnfantsByName("office:meta").getNomElt().equals("office:meta")) {
nodmeta = analyseLesMeta(nodStudent.retourneFirstEnfantsByName("office:meta"), nodSujet.retourneFirstEnfantsByName("office:meta"), a, nodmenu);
}
// analyse les pages (nécessaire d'avoir aussi les styles de paragraphes)
if(nodSujet.retourneFirstEnfantsByName("style:page").getNomElt().equals("style:page")) {
if(nodSujet.containElementByName("style:paragraph")) {
nodpage = analysePage(nodStudent.retourneFirstEnfantsByName("style:page"), nodSujet.retourneFirstEnfantsByName("style:page"), a, nodmenu,nodSujet.retourneFirstEnfantsByName("style:paragraph"),nodStudent.retourneFirstEnfantsByName("style:paragraph"));
}else {
nodpage = analysePage(nodStudent.retourneFirstEnfantsByName("style:page"), nodSujet.retourneFirstEnfantsByName("style:page"), a, nodmenu,null,null);
}
}
// analyse les paragraphes
if(nodSujet.retourneFirstEnfantsByName("style:paragraph").getNomElt().equals("style:paragraph")) {
nodparagraph = analyseParagraph(nodStudent.retourneFirstEnfantsByName("style:paragraph"), nodSujet.retourneFirstEnfantsByName("style:paragraph"), a, nodmenu);
}
// analyse les variables de séquence
if(nodSujet.retourneFirstEnfantsByName("sequences").getNomElt().equals("sequences")) {
nodsequence = analyseLesSequences(nodStudent.retourneFirstEnfantsByName("sequences"), nodSujet.retourneFirstEnfantsByName("sequences"), a, nodmenu);
}
// analyse de la numérotation des chapitres
if(nodSujet.retourneFirstEnfantsByName("numerotationchapitre").getNomElt().equals("numerotationchapitre")) {
nodnumerochapitre = analyseLaNumerotationChapitre(nodStudent.retourneFirstEnfantsByName("numerotationchapitre"), nodSujet.retourneFirstEnfantsByName("numerotationchapitre"), a, nodmenu);
}
// analyse les frames
if(nodSujet.retourneFirstEnfantsByName("frames").getNomElt().equals("frames")) {
nodframes = analyseLesFrames(nodStudent.retourneFirstEnfantsByName("frames"), nodSujet.retourneFirstEnfantsByName("frames"), a, nodmenu);
}
// analyse des sections
if(nodSujet.retourneFirstEnfantsByName("sections").getNomElt().equals("sections")) {
nodsections = analyseLesSections(nodStudent.retourneFirstEnfantsByName("sections"), nodSujet.retourneFirstEnfantsByName("sections"), a, nodmenu);
}
// analyse les tableaux
if(nodSujet.retourneFirstEnfantsByName("tableaux").getNomElt().equals("tableaux")) {
nodtableaux = analyseLesTableaux(nodStudent.retourneFirstEnfantsByName("tableaux"), nodSujet.retourneFirstEnfantsByName("tableaux"), a, nodmenu);
}
// analyse la bibliographie de LibreOffice
if(nodSujet.retourneFirstEnfantsByName("biblio").getNomElt().equals("biblio")) {
nodbiblio = analyseLaBiblio(nodStudent.retourneFirstEnfantsByName("biblio"), nodSujet.retourneFirstEnfantsByName("biblio"), a, nodmenu);
}
// analyse des tables des matières
if(nodSujet.retourneFirstEnfantsByName("tablematieres").getNomElt().equals("tablematieres")) {
nodtablematieres = analyseLesTablesMatieres(nodStudent.retourneFirstEnfantsByName("tablematieres"), nodSujet.retourneFirstEnfantsByName("tablematieres"), a, nodmenu);
}
// analyse des tables illustrations
if(nodSujet.retourneFirstEnfantsByName("tableillustrations").getNomElt().equals("tableillustrations")) {
nodtableillustrations = analyseLesTablesIllustrations(nodStudent.retourneFirstEnfantsByName("tableillustrations"), nodSujet.retourneFirstEnfantsByName("tableillustrations"), a, nodmenu);
}
// analyse la structure du document
if(nodSujet.retourneFirstEnfantsByName("structurepage").getNomElt().equals("structurepage")) {
node nodSujetParagraphs = null;
if(nodSujet.retourneFirstEnfantsByName("style:paragraph").getNomElt().equals("style:paragraph")) nodSujetParagraphs = nodSujet.retourneFirstEnfantsByName("style:paragraph");
node nodStudentParagraphs = nodStudent.retourneFirstEnfantsByName("style:paragraph");
nodstructurepage = analyseStructurePage(nodStudent.retourneFirstEnfantsByName("structurepage"), nodSujet.retourneFirstEnfantsByName("structurepage"), a, nodmenu,nodSujetParagraphs, nodStudentParagraphs );
}
// retourne le node analyse assemblé et calcul de la note avec le barème
return clotureNodeAnalyse(nodouverture, nodbodyetnotation, nodmenu, erreurs, nodmeta, nodpage, nodparagraph, nodsequence, nodnumerochapitre, nodframes, nodsections, nodtableaux, nodbiblio, nodtablematieres, nodtableillustrations, nodstructurepage,nodSujet.getContenu().get(0));
}
/**
* <br>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.
*/
@SuppressWarnings("unlikely-arg-type")
private 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;
}
}
}else {
}
}else {
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().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;
}
/**
* Assemblage du node annalyse à partir des différents nodes de l'analyse.<br>
* <br>
* @param nodouverture
* @param nodbodyetnotation
* @param nodmenu
* @param erreurs
* @param nodmeta
* @param nodpage
* @param nodparagraph
* @param nodsequence
* @param nodnumerochapitre
* @param nodframes
* @param nodsections
* @param nodtableaux
* @param nodbiblio
* @param nodtablematieres
* @param nodtableillustrations
* @param nodstructurepage
* @return
*/
private static node clotureNodeAnalyse(node nodouverture, node nodbodyetnotation, node nodmenu, node erreurs, node nodmeta, node nodpage,
node nodparagraph, node nodsequence, node nodnumerochapitre, node nodframes, node nodsections, node nodtableaux, node nodbiblio, node nodtablematieres,
node nodtableillustrations, node nodstructurepage, String texteCommentaire) {
node nodanalyse = new node();
//recalcul les points pour les placer dans le node nodbodyetnotation
double notefrom = 20; // valeur par défaut
double progression = 1; // valeur par défaut
boolean baremeABC = false;
if(nodouverture!=null) if(nodouverture.isClose()) {
if(nodouverture.getAttributs().get("notefrom")!=null) {
try {
notefrom = Math.abs(Double.valueOf(nodouverture.getAttributs().get("notefrom")));
}catch (Exception e) {
System.out.println("The \"noteFrom\" attribute of the analyze file cannot be converted to a \"double\".");
System.out.println("Value of notefrom = 20.");
}
}
if(nodouverture.getAttributs().get("progression")!=null) {
try {
progression = Math.abs(Double.valueOf(nodouverture.getAttributs().get("progression")));
}catch (Exception e) {
System.out.println("The \"progression\" attribute of the analyze file cannot be converted to \"double\".");
System.out.println("Value of progression = 1.");
}
}
if(nodouverture.getAttributs().get("baremeABC")!=null) {
try {
baremeABC = Boolean.valueOf(nodouverture.getAttributs().get("baremeABC"));
}catch (Exception e) {
System.out.println("The \"baremeABC\" attribute of the analyze file cannot be converted to \"boolean\".");
System.out.println("Value of baremeABC = false.");
}
}
}
double pointmeta = 0; double pointmetatotal = 0 ; double poidsmeta = 0;
if(nodmeta!=null) if(nodmeta.isClose()) {
if(nodmeta.getAttributs().get("pointgagner")!=null) pointmeta = Double.valueOf(nodmeta.getAttributs().get("pointgagner"));
if(nodmeta.getAttributs().get("pointtotal")!=null) pointmetatotal = Double.valueOf(nodmeta.getAttributs().get("pointtotal"));
if(nodmeta.getAttributs().get("poids")!=null) try{poidsmeta = Math.abs(Double.valueOf(nodmeta.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointpage = 0; double pointpagetotal = 0 ; double poidspage = 0;
if(nodpage!=null) if(nodpage.isClose()) {
if(nodpage.getAttributs().get("pointgagner")!=null) pointpage = Double.valueOf(nodpage.getAttributs().get("pointgagner"));
if(nodpage.getAttributs().get("pointtotal")!=null) pointpagetotal = Double.valueOf(nodpage.getAttributs().get("pointtotal"));
if(nodpage.getAttributs().get("poids")!=null) try{poidspage = Math.abs(Double.valueOf(nodpage.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointparagraph = 0; double pointparagraphtotal = 0 ; double poidsparagraph = 0;
if(nodparagraph!=null) if(nodparagraph.isClose()) {
if(nodparagraph.getAttributs().get("pointgagner")!=null) pointparagraph = Double.valueOf(nodparagraph.getAttributs().get("pointgagner"));
if(nodparagraph.getAttributs().get("pointtotal")!=null) pointparagraphtotal = Double.valueOf(nodparagraph.getAttributs().get("pointtotal"));
if(nodparagraph.getAttributs().get("poids")!=null) try{Math.abs(poidsparagraph = Double.valueOf(nodparagraph.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointsequence = 0; double pointsequencetotal = 0 ; double poidssequence = 0;
if(nodsequence!=null) if(nodsequence.isClose()) {
if(nodsequence.getAttributs().get("pointgagner")!=null) pointsequence = Double.valueOf(nodsequence.getAttributs().get("pointgagner"));
if(nodsequence.getAttributs().get("pointtotal")!=null) pointsequencetotal = Double.valueOf(nodsequence.getAttributs().get("pointtotal"));
if(nodsequence.getAttributs().get("poids")!=null) try{poidssequence = Math.abs(Double.valueOf(nodsequence.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointnumerotation = 0; double pointnumerotationtotal = 0 ; double poidsnumerotation = 0;
if(nodnumerochapitre!=null) if(nodnumerochapitre.isClose()) {
if(nodnumerochapitre.getAttributs().get("pointgagner")!=null) pointnumerotation = Double.valueOf(nodnumerochapitre.getAttributs().get("pointgagner"));
if(nodnumerochapitre.getAttributs().get("pointtotal")!=null) pointnumerotationtotal = Double.valueOf(nodnumerochapitre.getAttributs().get("pointtotal"));
if(nodnumerochapitre.getAttributs().get("poids")!=null) try{poidsnumerotation = Math.abs(Double.valueOf(nodnumerochapitre.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointframe = 0; double pointframetotal = 0 ; double poidsframe = 0;
if(nodframes!=null) if(nodframes.isClose()) {
if(nodframes.getAttributs().get("pointgagner")!=null) pointframe = Double.valueOf(nodframes.getAttributs().get("pointgagner"));
if(nodframes.getAttributs().get("pointtotal")!=null) pointframetotal = Double.valueOf(nodframes.getAttributs().get("pointtotal"));
if(nodframes.getAttributs().get("poids")!=null) try{poidsframe = Math.abs(Double.valueOf(nodframes.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointsection = 0; double pointsectiontotal = 0 ; double poidssection = 0;
if(nodsections!=null) if(nodsections.isClose()) {
if(nodsections.getAttributs().get("pointgagner")!=null) pointsection = Double.valueOf(nodsections.getAttributs().get("pointgagner"));
if(nodsections.getAttributs().get("pointtotal")!=null) pointsectiontotal = Double.valueOf(nodsections.getAttributs().get("pointtotal"));
if(nodsections.getAttributs().get("poids")!=null) try{poidssection = Math.abs(Double.valueOf(nodsections.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointtableau = 0; double pointtableautotal = 0 ; double poidstableau = 0;
if(nodtableaux!=null) if(nodtableaux.isClose()) {
if(nodtableaux.getAttributs().get("pointgagner")!=null) pointsection = Double.valueOf(nodtableaux.getAttributs().get("pointgagner"));
if(nodtableaux.getAttributs().get("pointtotal")!=null) pointsectiontotal = Double.valueOf(nodtableaux.getAttributs().get("pointtotal"));
if(nodtableaux.getAttributs().get("poids")!=null) try{poidssection = Math.abs(Double.valueOf(nodtableaux.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointbiblio = 0; double pointbibliototal = 0 ; double poidsbiblio = 0;
if(nodbiblio!=null) if(nodbiblio.isClose()) {
if(nodbiblio.getAttributs().get("pointgagner")!=null) pointbiblio = Double.valueOf(nodbiblio.getAttributs().get("pointgagner"));
if(nodbiblio.getAttributs().get("pointtotal")!=null) pointbibliototal = Double.valueOf(nodbiblio.getAttributs().get("pointtotal"));
if(nodbiblio.getAttributs().get("poids")!=null) try{poidsbiblio = Math.abs(Double.valueOf(nodbiblio.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointtablematieres = 0; double pointtablematierestotal = 0 ; double poidstablematieres = 0;
if(nodtablematieres!=null) if(nodtablematieres.isClose()) {
if(nodtablematieres.getAttributs().get("pointgagner")!=null) pointtablematieres = Double.valueOf(nodtablematieres.getAttributs().get("pointgagner"));
if(nodtablematieres.getAttributs().get("pointtotal")!=null) pointtablematierestotal = Double.valueOf(nodtablematieres.getAttributs().get("pointtotal"));
if(nodtablematieres.getAttributs().get("poids")!=null) try{poidstablematieres = Math.abs(Double.valueOf(nodtablematieres.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointtableillustration = 0; double pointtableillustrationtotal = 0 ; double poidstableillustration = 0;
if(nodtableillustrations!=null) if(nodtableillustrations.isClose()) {
if(nodtableillustrations.getAttributs().get("pointgagner")!=null) pointtableillustration = Double.valueOf(nodtableillustrations.getAttributs().get("pointgagner"));
if(nodtableillustrations.getAttributs().get("pointtotal")!=null) pointtableillustrationtotal = Double.valueOf(nodtableillustrations.getAttributs().get("pointtotal"));
if(nodtableillustrations.getAttributs().get("poids")!=null) try{poidstableillustration = Math.abs(Double.valueOf(nodtableillustrations.getAttributs().get("poids")));}catch (Exception e) { };
}
double pointstructure = 0; double pointstructuretotal = 0 ; double poidsstructure = 0;
if(nodstructurepage!=null) if(nodstructurepage.isClose()) {
if(nodstructurepage.getAttributs().get("pointgagner")!=null) pointstructure = Double.valueOf(nodstructurepage.getAttributs().get("pointgagner"));
if(nodstructurepage.getAttributs().get("pointtotal")!=null) pointstructuretotal = Double.valueOf(nodstructurepage.getAttributs().get("pointtotal"));
if(nodstructurepage.getAttributs().get("poids")!=null) try{poidsstructure = Math.abs(Double.valueOf(nodstructurepage.getAttributs().get("poids")));}catch (Exception e) { };
}
double proportionCorrect = 0 ;
double poidsTotal = 0;
double pointsTotal = 0;
double pointgagner = 0;
double note = 0 ;
proportionCorrect = (poidsmeta*pointmeta + poidspage*pointpage + poidsparagraph*pointparagraph + poidssequence*pointsequence + poidsnumerotation*pointnumerotation + poidsframe*pointframe + poidsbiblio*pointbiblio + poidstablematieres*pointtablematieres + poidstableillustration*pointtableillustration + poidsstructure*pointstructure + poidssection*pointsection + poidstableau*pointtableau)
/ (poidsmeta*pointmetatotal + poidspage*pointpagetotal + poidsparagraph*pointparagraphtotal + poidssequence*pointsequencetotal + poidsnumerotation*pointnumerotationtotal + poidsframe*pointframetotal + poidsbiblio*pointbibliototal + poidstablematieres*pointtablematierestotal + poidstableillustration*pointtableillustrationtotal + poidsstructure*pointstructuretotal + poidssection*pointsectiontotal + poidstableau*pointtableautotal);
poidsTotal = poidsmeta + poidspage + poidsparagraph + poidssequence + poidsnumerotation + poidsframe + poidsbiblio + poidstablematieres + poidstableillustration + poidsstructure + poidssection + poidstableau;
pointsTotal = pointmetatotal + pointpagetotal + pointparagraphtotal + pointsequencetotal + pointnumerotationtotal + pointframetotal + pointbibliototal + pointtablematierestotal + pointtableillustrationtotal + pointstructuretotal + pointsectiontotal;
pointgagner = pointmeta + pointpage + pointparagraph + pointsequence + pointnumerotation + pointframe + pointsection + pointtableau + pointbiblio + pointtablematieres + pointtableillustration + pointstructure;
note = Math.pow(proportionCorrect, progression)*notefrom;
DecimalFormat df = new DecimalFormat("###.##");
nodbodyetnotation.getAttributs().put("proportioncorrect", df.format(proportionCorrect*100) + "%");
nodbodyetnotation.getAttributs().put("note", df.format(note));
nodbodyetnotation.getAttributs().put("pointstotal", String.valueOf(pointsTotal));
nodbodyetnotation.getAttributs().put("poidstotal", String.valueOf(poidsTotal));
nodbodyetnotation.getAttributs().put("pointgagner", String.valueOf(pointgagner));
if(Boolean.valueOf(erreurs.getAttributs().get("oneError"))) {
nodbodyetnotation.getAttributs().put("proportioncorrect", "0%");
nodbodyetnotation.getAttributs().put("note", "0.00");
proportionCorrect = 0.00;
}
// si bareme ABC (5 intervalles A, B, C, D, E de 20%)
if(baremeABC) {
double intervalle1 = Math.pow(0.2, 1/progression) ;
double intervalle2 = Math.pow(0.4, 1/progression) ;
double intervalle3 = Math.pow(0.6, 1/progression) ;
double intervalle4 = Math.pow(0.8, 1/progression) ;
nodbodyetnotation.getAttributs().put("BorneE", String.valueOf(intervalle1));
nodbodyetnotation.getAttributs().put("BorneD", String.valueOf(intervalle2));
nodbodyetnotation.getAttributs().put("BorneC", String.valueOf(intervalle3));
nodbodyetnotation.getAttributs().put("BorneB", String.valueOf(intervalle4));
nodbodyetnotation.getAttributs().put("BorneA", "1.00");
if(proportionCorrect<intervalle1) nodbodyetnotation.getAttributs().put("noteABC", "E");
if(proportionCorrect>=intervalle1 && proportionCorrect<intervalle2) nodbodyetnotation.getAttributs().put("noteABC", "D");
if(proportionCorrect>=intervalle2 && proportionCorrect<intervalle3) nodbodyetnotation.getAttributs().put("noteABC", "C");
if(proportionCorrect>=intervalle3 && proportionCorrect<intervalle4) nodbodyetnotation.getAttributs().put("noteABC", "B");
if(proportionCorrect>=intervalle4) nodbodyetnotation.getAttributs().put("noteABC", "A");
}
nodanalyse.ajouteEnfant(nodouverture);
nodanalyse.ajouteEnfant(nodbodyetnotation);
nodanalyse.ajouteEnfant(nodmenu);
nodanalyse.ajouteEnfant(erreurs);
nodanalyse.ajouteEnfant(nodmeta);
nodanalyse.ajouteEnfant(nodpage);
nodanalyse.ajouteEnfant(nodparagraph);
nodanalyse.ajouteEnfant(nodsequence);
nodanalyse.ajouteEnfant(nodnumerochapitre);
nodanalyse.ajouteEnfant(nodframes);
nodanalyse.ajouteEnfant(nodsections);
nodanalyse.ajouteEnfant(nodtableaux);
nodanalyse.ajouteEnfant(nodbiblio);
nodanalyse.ajouteEnfant(nodtablematieres);
nodanalyse.ajouteEnfant(nodtableillustrations);
nodanalyse.ajouteEnfant(nodstructurepage);
node nodfermeturebodyHTML = new node();
nodfermeturebodyHTML.setNomElt("fermeture");
nodfermeturebodyHTML.setClose(true);
nodanalyse.getNodes().add(nodfermeturebodyHTML);
nodanalyse.setNomElt("analyse");
nodanalyse.setContenu(texteCommentaire);
nodanalyse.setClose(true);
return nodanalyse;
}
/**
* Analyse du node <b>office:meta</b>.
* @param nodStudentMeta
* @param nodSujetMeta
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesMeta(node nodStudentMeta, node nodSujetMeta, Run a, node nodmenu) {
node nodmeta = new node();
nodmeta.setNomElt("meta");
nodmeta.setAttributs(nodSujetMeta.getAttributs());
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "office:meta")!=null) {
nodmeta.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "office:meta").getAttributs().get("id"));
}
//Applatir le node sujetMeta
ArrayList<node> sujet = a.Applatir(nodSujetMeta.getNodes(), new ArrayList<node>());
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < sujet.size(); i++) {
String namenode = sujet.get(i).getNomElt();
// parcours les attributs du node "meta:user-defined"
if(namenode.equals("meta:user-defined")) {
Enumeration<String> key = sujet.get(i).getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(sujet.get(i).getAttributs().get(k).contains("")){
String valueOfAttribut = sujet.get(i).getAttributs().get(k);
node nod2 = a.retourneFirstNodeByNameAttributContainsValueNetTexte(nodStudentMeta, namenode,k,outils.withoutCodeAndPointPourRechercheContenuExact(valueOfAttribut));
nodmeta = analyseLesAttributEtContenuDuNode(nod2, sujet.get(i), nodmeta, "ana:meta", namenode);
}
}
}else {
ArrayList<node> NStudent = a.retourneNames(nodStudentMeta, namenode);
if(NStudent!=null) {
if(!NStudent.isEmpty()) {
nodmeta = analyseLesAttributEtContenuDuNode(NStudent.get(0), sujet.get(i), nodmeta, "ana:meta", namenode);
}else {
nodmeta = analyseLesAttributEtContenuDuNode(null, sujet.get(i), nodmeta, "ana:meta", namenode);
}
}else {
nodmeta = analyseLesAttributEtContenuDuNode(null, sujet.get(i), nodmeta, "ana:meta", namenode);
}
}
}
nodmeta.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodmeta.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodmeta.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodmeta.setClose(true);
return nodmeta;
}
/**
* Analyse du node <b>style:page</b>.
* @param nodStudentPage
* @param nodSujetPage
* @param a
* @param nodmenu
* @return
*/
private static node analysePage(node nodStudentPage, node nodSujetPage, Run a, node nodmenu, node nodSujetParagraphes, node nodStudentParagraphes) {
node nodpages = new node();
nodpages.setNomElt("pages");
nodpages.setAttributs(nodSujetPage.getAttributs());
//***************************************
//** Ajoute l'identifiant pour le menu **
//***************************************
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "style:page")!=null) {
nodpages.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "style:page").getAttributs().get("id"));
}
//***************************
//** initialise les points **
//***************************
outils.initiliseLesPoints();
//****************************************
//** Analyse tous les style:master-page **
//****************************************
for(int i = 0 ; i < nodSujetPage.getNodes().size(); i++) {
if(nodSujetPage.getNodes().get(i).getNomElt().equals("style:master-page")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String nomDeLaPage = outils.withoutCodeAndPoint(nodSujetPage.getNodes().get(i).getAttributs().get("style:name"));
node page = new node();
page.setNomElt("page");
page.getAttributs().put("name", nomDeLaPage);
if(nodSujetPage.getNodes().get(i).getAttributs().get("titre")!=null) page.getAttributs().put("titre", nodSujetPage.getNodes().get(i).getAttributs().get("titre"));
node pageStudent = a.retourneFirstNodeByNameAttributValue(nodStudentPage, "style:master-page", "style:name", nomDeLaPage);
node pageSujet = nodSujetPage.getNodes().get(i);
// analyse les attributs du node style:master-page
page = analyseLesAttributEtContenuDuNode(pageStudent, pageSujet, page, "ana:page",pageSujet.getNomElt());
//**********************************************
//** Analyse de tous les autres nodes enfants **
//**********************************************
page=analyseLesNodesEnants.nodeNext(page, "ana:page", pageStudent, null, null, pageSujet, nodSujetParagraphes, nodStudentParagraphes, a);
page.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
page.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodpages.getNodes().add(page);
}
}
nodpages.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodpages.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodpages.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodpages.setClose(true);
return nodpages;
}
/**
* Analyse du node <b>style:paragraph</b>.
* @param nodStudentParagraph
* @param nodSujetParagraph
* @param a
* @param nodmenu
* @return
*/
private static node analyseParagraph(node nodStudentParagraph, node nodSujetParagraph, Run a, node nodmenu) {
node nodparagraphs = new node();
nodparagraphs.setNomElt("paragraphs");
nodparagraphs.setAttributs(nodSujetParagraph.getAttributs());
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "style:paragraph")!=null) {
nodparagraphs.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "style:paragraph").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetParagraph.getNodes().size(); i++) {
if(nodSujetParagraph.getNodes().get(i).getNomElt().equals("style:style")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
node paragraphSujet = nodSujetParagraph.getNodes().get(i);
String nomDuParagraph = outils.withoutCodeAndPoint(paragraphSujet.getAttributs().get("style:name"));
node paragraph = new node();
paragraph.setNomElt("paragraph");
paragraph.getAttributs().put("name", nomDuParagraph);
if(paragraphSujet.getAttributs().get("titre")!=null) paragraph.getAttributs().put("titre", nodSujetParagraph.getNodes().get(i).getAttributs().get("titre"));
// trouve le node de l'étudiant
node paragraphStudent = a.retourneFirstNodeByNameAttributValue(nodStudentParagraph, "style:style", "style:name", nomDuParagraph);
// ajoute les valeurs par héritage
if(paragraphStudent!=null) paragraphStudent = ajouteValeurLesValeursDuStyleParagraphParent(nodStudentParagraph, paragraphStudent);
// ajoute les valeurs par défauts
if(paragraphStudent!=null) paragraphStudent = ajouteValeurParDefautAuStyleParagraph(nodStudentParagraph, paragraphStudent);
// analyse les attributs du node
paragraph = analyseLesAttributEtContenuDuNode(paragraphStudent, paragraphSujet, paragraph, "ana:paragraph",paragraphSujet.getNomElt());
// les enfants du premier niveau du node
for(int j = 0 ; j < paragraphSujet.getNodes().size();j++ ) {
node nodSujet = paragraphSujet.getNodes().get(j);
String nameNode = nodSujet.getNomElt();
node nodStudent = null;
if(paragraphStudent!=null) {
if(paragraphStudent.retourneFirstEnfantsByName(nameNode).getNomElt().equals(nameNode)) {
nodStudent = paragraphStudent.retourneFirstEnfantsByName(nameNode);
}
}
//insère un saut si titre pas vide et saut=true
paragraph = addNodeSautTitre(nodSujet, paragraph);
// analyse attribut et contenu des enfants du premier niveau
paragraph = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, paragraph, "ana:paragraph",nodSujet.getNomElt());
for(int k = 0 ; k < nodSujet.getNodes().size();k++) {
node nod2Sujet = nodSujet.getNodes().get(k);
String nameNode2 = nod2Sujet.getNomElt();
node nod2Student = null;
if(nodStudent!=null) if(nodStudent.retourneFirstEnfantsByName(nameNode2).getNomElt().equals(nameNode2)) {
nod2Student = paragraphStudent.retourneFirstEnfantsByName(nameNode2);
}
//insère un saut si titre pas vide et saut=true
paragraph = addNodeSautTitre(nod2Sujet, paragraph);
// analyse attribut et contenu des enfants du second niveau
paragraph = analyseLesAttributEtContenuDuNode(nod2Student, nod2Sujet, paragraph, "ana:paragraph",nod2Sujet.getNomElt() );
for(int l = 0 ; l < nod2Sujet.getNodes().size();l++) {
node nod3Sujet = nod2Sujet.getNodes().get(l);
String nameNode3 = nod3Sujet.getNomElt();
node nod3Student = null;
if(nod2Student!=null) if(nod2Student.retourneFirstEnfantsByName(nameNode3).getNomElt().equals(nameNode3)) {
nod3Student = paragraphStudent.retourneFirstEnfantsByName(nameNode3);
}
//insère un saut si titre pas vide et saut=true
paragraph = addNodeSautTitre(nod3Sujet, paragraph);
// analyse attribut et contenu des enfants du troisième niveau
paragraph = analyseLesAttributEtContenuDuNode(nod3Student, nod3Sujet, paragraph, "ana:paragraph", nod3Sujet.getNomElt());
}
}
}
paragraph.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
paragraph.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodparagraphs.getNodes().add(paragraph);
}
}
nodparagraphs.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodparagraphs.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodparagraphs.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodparagraphs.setClose(true);
return nodparagraphs;
}
/**
* Analyse du node <b>sequences</b>.
* @param nodStudentSequence
* @param nodSujetSequence
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesSequences(node nodStudentSequence, node nodSujetSequence, Run a, node nodmenu) {
node nodseq = new node();
nodseq.setNomElt("sequences");
nodseq.setAttributs(nodSujetSequence.getAttributs());
nodseq.setContenu(nodSujetSequence.getContenu()); //ajoute le commantire
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "sequences")!=null) {
nodseq.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "sequences").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetSequence.getNodes().size(); i++) {
if(nodSujetSequence.getNodes().get(i).getNomElt().equals("text:sequence-decl")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String nomSequence = outils.withoutCodeAndPoint(nodSujetSequence.getNodes().get(i).getAttributs().get("text:name"));
node seq = new node();
seq.setNomElt("sequence");
seq.getAttributs().put("name", nomSequence);
if(nodSujetSequence.getNodes().get(i).getAttributs().get("titre")!=null) seq.getAttributs().put("titre", nodSujetSequence.getNodes().get(i).getAttributs().get("titre"));
node seqStudent = a.retourneFirstNodeByNameAttributValue(nodStudentSequence, "text:sequence-decl", "text:name", nomSequence);
node seqSujet = nodSujetSequence.getNodes().get(i);
//insère un saut si titre pas vide et saut=true
seq = addNodeSautTitre(seqSujet, seq);
// analyse les attributs du node
seq = analyseLesAttributEtContenuDuNode(seqStudent, seqSujet, seq, "ana:seq",seqSujet.getNomElt());
seq.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
seq.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodseq.getNodes().add(seq);
}
}
nodseq.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodseq.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodseq.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodseq.setClose(true);
return nodseq;
}
/**
* Analyse du node <b>numerotationchapitre</b>.
* @param nodStudentNumerotation
* @param nodSujetNumerotation
* @param a
* @param nodmenu
* @return
*/
private static node analyseLaNumerotationChapitre(node nodStudentNumerotation, node nodSujetNumerotation, Run a, node nodmenu) {
node nodnumerotations = new node();
nodnumerotations.setNomElt("numerotationchapitre");
nodnumerotations.setAttributs(nodSujetNumerotation.getAttributs());//ajoute tous les attributs du sujet
nodnumerotations.setContenu(nodSujetNumerotation.getContenu()); //ajoute le commantaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "numerotationchapitre")!=null) {
nodnumerotations.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "numerotationchapitre").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetNumerotation.getNodes().size(); i++) {
if(nodSujetNumerotation.getNodes().get(i).getNomElt().equals("text:outline-level-style")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String levelnumrotation = outils.withoutCodeAndPoint(nodSujetNumerotation.getNodes().get(i).getAttributs().get("text:level"));
node numerotation = new node();
numerotation.setNomElt("numerotation");
numerotation.getAttributs().put("level", levelnumrotation);
if(nodSujetNumerotation.getNodes().get(i).getAttributs().get("titre")!=null) numerotation.getAttributs().put("titre", nodSujetNumerotation.getNodes().get(i).getAttributs().get("titre"));
node numerotationStudent = a.retourneFirstNodeByNameAttributValue(nodStudentNumerotation, "text:outline-level-style", "text:level", levelnumrotation);
node numerotationSujet = nodSujetNumerotation.getNodes().get(i);
// analyse les attributs du node
numerotation = analyseLesAttributEtContenuDuNode(numerotationStudent, numerotationSujet, numerotation, "ana:numerotation",numerotationSujet.getNomElt());
// les enfants du premier niveau du node
for(int j = 0 ; j < numerotationSujet.getNodes().size();j++ ) {
node nodSujet = numerotationSujet.getNodes().get(j);
String nameNode = nodSujet.getNomElt();
node nodStudent = null;
if(numerotationStudent!=null) if(numerotationStudent.retourneFirstEnfantsByName(nameNode).getNomElt().equals(nameNode)) {
nodStudent = numerotationStudent.retourneFirstEnfantsByName(nameNode);
}
//insère un saut si titre pas vide et saut=true
numerotation=addNodeSautTitre(nodSujet, numerotation);
// analyse attribut et contenu des enfants du premier niveau
numerotation = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, numerotation, "ana:numerotation",numerotationSujet.getNodes().get(j).getNomElt());
for(int k = 0 ; k < nodSujet.getNodes().size();k++) {
node nod2Sujet = nodSujet.getNodes().get(k);
String nameNode2 = nod2Sujet.getNomElt();
node nod2Student = null;
if(nodStudent!=null) if(nodStudent.retourneFirstEnfantsByName(nameNode2).getNomElt().equals(nameNode2)) {
nod2Student = numerotationStudent.retourneFirstEnfantsByName(nameNode2);
}
//insère un saut si titre pas vide et saut=true
numerotation=addNodeSautTitre(nod2Sujet, numerotation);
// analyse attribut et contenu des enfants du second niveau
numerotation = analyseLesAttributEtContenuDuNode(nod2Student, nod2Sujet, numerotation, "ana:numerotation",nod2Sujet.getNomElt() );
for(int l = 0 ; l < nod2Sujet.getNodes().size();l++) {
node nod3Sujet = nod2Sujet.getNodes().get(l);
String nameNode3 = nod3Sujet.getNomElt();
node nod3Student = null;
if(nod2Student!=null) if(nod2Student.retourneFirstEnfantsByName(nameNode3).getNomElt().equals(nameNode3)) {
nod3Student = numerotationStudent.retourneFirstEnfantsByName(nameNode3);
}
//insère un saut si titre pas vide et saut=true
numerotation=addNodeSautTitre(nod3Sujet, numerotation);
// analyse attribut et contenu des enfants du troisième niveau
numerotation = analyseLesAttributEtContenuDuNode(nod3Student, nod3Sujet, numerotation, "ana:paragraph", nod3Sujet.getNomElt());
}
}
}
numerotation.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
numerotation.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodnumerotations.getNodes().add(numerotation);
}
}
nodnumerotations.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodnumerotations.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodnumerotations.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodnumerotations.setClose(true);
return nodnumerotations;
}
/**
* Analyse du node <b>frames</b>.
* @param nodStudentFrames
* @param nodSujetframes
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesFrames(node nodStudentFrames, node nodSujetFrames, Run a, node nodmenu) {
node nodframes = new node();
nodframes.setNomElt("frames");
nodframes.setAttributs(nodSujetFrames.getAttributs()); //ajoute tous les attributs du sujet
nodframes.setContenu(nodSujetFrames.getContenu()); //ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "frames")!=null) {
nodframes.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "frames").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetFrames.getNodes().size(); i++) { //niveau 1
if(nodSujetFrames.getNodes().get(i).getNomElt().equals("draw:frame")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String nomDuFrame = outils.withoutCodeAndPoint(nodSujetFrames.getNodes().get(i).getAttributs().get("draw:name"));
node frame = new node();
frame.setNomElt("frame");
frame.getAttributs().put("nameframe", nomDuFrame);
if(nodSujetFrames.getNodes().get(i).getAttributs().get("titre")!=null) frame.getAttributs().put("titre", nodSujetFrames.getNodes().get(i).getAttributs().get("titre"));
node frameStudent = a.retourneFirstNodeByNameAttributValue(nodStudentFrames, "draw:frame", "draw:name", nomDuFrame);
node frameSujet = nodSujetFrames.getNodes().get(i);
// analyse les attributs du node
frame = analyseLesAttributEtContenuDuNode(frameStudent, frameSujet, frame, "ana:frame",frameSujet.getNomElt());
// les enfants du premier niveau du node
for(int j = 0 ; j < frameSujet.getNodes().size();j++ ) { //niveau 2
node nodSujet = frameSujet.getNodes().get(j);
String nameNode = nodSujet.getNomElt();
node nodStudent = null;
if(frameStudent!=null) if(frameStudent.retourneFirstEnfantsByName(nameNode).getNomElt().equals(nameNode)) {
nodStudent = frameStudent.retourneFirstEnfantsByName(nameNode);
}
if(frameStudent!=null) if(nameNode.equals("text:p")) {
if(nodSujet.getAttributs().get("index")!=null) {
nodStudent = a.retourneFirstNodeByNameAttributValue(frameStudent, nameNode, "text:p", frameSujet.getNodes().get(j).getAttributs().get("index"));
}
if(nodStudent==null)if(nodSujet.retourneLesContenusEnfants("").isEmpty()) { //si il n'y a pas de contenu, passe par l'index
nodStudent = a.retourneFirstNodeByNameAttributValue(frameStudent, nameNode, "index", outils.withoutCodeAndPoint(nodSujet.getAttributs().get("index")));
}else {
nodStudent = a.retourneFirstNodeByFindContent2(frameStudent.getNodes(), nodSujet.retourneLesContenusEnfants(""), commandes.tolerance_characters,commandes.tolerance_text);
}
}
//insère un saut si titre pas vide et saut=true
frame=addNodeSautTitre(nodSujet, frame);
// analyse attribut et contenu des enfants du premier niveau
frame = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, frame, "ana:frame",nodSujet.getNomElt());
for(int k = 0 ; k < nodSujet.getNodes().size();k++) { //niveau 3
node nod2Sujet = nodSujet.getNodes().get(k);
String nameNode2 = nod2Sujet.getNomElt();
node nod2Student = null;
if(nodStudent!=null) if(nodStudent.retourneFirstEnfantsByName(nameNode2).getNomElt().equals(nameNode2)) {
nod2Student = nodStudent.retourneFirstEnfantsByName(nameNode2);
}
if(nodStudent!=null) if(nameNode2.equals("text:p")) {
if(nod2Sujet.getAttributs().get("index")!=null) {
nod2Student = a.retourneFirstNodeByNameAttributValue(nodStudent, nameNode2, "index", nod2Sujet.getAttributs().get("index"));
}
}
if(nodStudent!=null) if(nameNode2.equals("text:database-display")) {
if(nod2Sujet.getAttributs().get("text:column-name")!=null) {
nod2Student = a.retourneFirstNodeByNameAttributValue(nodStudent, nameNode2, "text:column-name", outils.withoutCodeAndPoint(nod2Sujet.getAttributs().get("text:column-name")));
}
}
//insère un saut si titre pas vide et saut=true
frame=addNodeSautTitre(nod2Sujet, frame);
// analyse attribut et contenu des enfants du second niveau
frame = analyseLesAttributEtContenuDuNode(nod2Student, nod2Sujet, frame, "ana:frame",nod2Sujet.getNomElt() );
for(int l = 0 ; l < nod2Sujet.getNodes().size();l++) { //niveau 4
node nod3Sujet = nod2Sujet.getNodes().get(l);
String nameNode3 = nod3Sujet.getNomElt();
node nod3Student = null;
if(nod2Student!=null) if(nod2Student.retourneFirstEnfantsByName(nameNode3).getNomElt().equals(nameNode3)) {
nod3Student = nod2Student.retourneFirstEnfantsByName(nameNode3);
}
if(nod2Student!=null) if(nameNode3.equals("text:database-display")) {
if(nod3Sujet.getAttributs().get("text:column-name")!=null) {
nod3Student = a.retourneFirstNodeByNameAttributValue(nod2Student, nameNode3, "text:column-name", outils.withoutCodeAndPoint(nod3Sujet.getAttributs().get("text:column-name")));
}
}
// analyse attribut et contenu des enfants du troisième niveau
if(nod3Student!=null) if(nod3Sujet.getNomElt().equals("text:sequence") && nod3Student.getNomElt().equals("text:sequence")) {
ArrayList<node> changements = nod2Student.retourneEnfantsByName("text:change", new ArrayList<node>());
nod3Student.setNodes(changements);
}
//insère un saut si titre pas vide et saut=true
frame=addNodeSautTitre(nod3Sujet, frame);
// analyse attribut et contenu des enfants du second niveau
frame = analyseLesAttributEtContenuDuNode(nod3Student, nod3Sujet, frame, "ana:frame", nod3Sujet.getNomElt());
}
}
}
frame.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
frame.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodframes.getNodes().add(frame);
}
}
nodframes.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodframes.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodframes.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodframes.setClose(true);
return nodframes;
}
/**
* Analyse du node <b>sections</b>
* @param nodStudentSections
* @param nodSujetSections
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesSections(node nodStudentSections, node nodSujetSections, Run a, node nodmenu) {
node nodsections = new node();
nodsections.setNomElt("sections");
nodsections.setAttributs(nodSujetSections.getAttributs()); //ajoute tous les attributs du sujet
nodsections.setContenu(nodSujetSections.getContenu()); //ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "sections")!=null) {
nodsections.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "sections").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetSections.getNodes().size(); i++) { //niveau 1
if(nodSujetSections.getNodes().get(i).getNomElt().equals("text:section")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
node sectionSujet = nodSujetSections.getNodes().get(i);
String nomDeLaSection = outils.withoutCodeAndPoint(sectionSujet.getAttributs().get("text:name"));
node section = new node();
section.setNomElt("section");
section.getAttributs().put("namesection", nomDeLaSection);
if(nodSujetSections.getNodes().get(i).getAttributs().get("titre")!=null) section.getAttributs().put("titre", nodSujetSections.getNodes().get(i).getAttributs().get("titre"));
node sectionStudent = a.retourneFirstNodeByNameAttributValue(nodStudentSections, "text:section", "text:name", nomDeLaSection);
// analyse les attributs du node
section = analyseLesAttributEtContenuDuNode(sectionStudent, sectionSujet, section, "ana:section",sectionSujet.getNomElt());
// les enfants du premier niveau du node
for(int j = 0 ; j < sectionSujet.getNodes().size();j++ ) { //niveau 2
node nodSujet = sectionSujet.getNodes().get(j);
String nameNode = nodSujet.getNomElt();
node nodStudent = null;
if(sectionStudent!=null) nodStudent = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode,nodSujet,null,null,sectionStudent,a);
//insère un saut si titre pas vide et saut=true
section=addNodeSautTitre(nodSujet, section);
// analyse attribut et contenu des enfants du premier niveau
section = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, section, "ana:section",nameNode);
for(int k = 0 ; k < nodSujet.getNodes().size();k++) { //niveau 3
node nod2Sujet = nodSujet.getNodes().get(k);
String nameNode2 = nod2Sujet.getNomElt();
node nod2Student = null;
if(sectionStudent!=null) nod2Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode2,nod2Sujet,null,sectionStudent,nodStudent,a);
//insère un saut si titre pas vide et saut=true
section=addNodeSautTitre(nod2Sujet, section);
// analyse attribut et contenu des enfants du second niveau
section = analyseLesAttributEtContenuDuNode(nod2Student, nod2Sujet, section, "ana:section",nameNode2 );
for(int l = 0 ; l < nod2Sujet.getNodes().size();l++) { //niveau 4
node nod3Sujet = nod2Sujet.getNodes().get(l);
String nameNode3 = nod3Sujet.getNomElt();
node nod3Student = null;
if(sectionStudent!=null) nod3Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode3,nod3Sujet,sectionStudent,nodStudent,nod2Student,a);
//insère un saut si titre pas vide et saut=true
section=addNodeSautTitre(nod3Sujet, section);
// analyse attribut et contenu des enfants du second niveau
section = analyseLesAttributEtContenuDuNode(nod3Student, nod3Sujet, section, "ana:section", nameNode3);
for(int m = 0 ; m < nod3Sujet.getNodes().size();m++) { //niveau 5
node nod4Sujet = nod3Sujet.getNodes().get(m);
String nameNode4 = nod4Sujet.getNomElt();
node nod4Student = null;
if(sectionStudent!=null) nod4Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode4,nod4Sujet,nodStudent,nod2Student,nod3Student,a);
//insère un saut si titre pas vide et saut=true
section=addNodeSautTitre(nod4Sujet, section);
// analyse attribut et contenu des enfants du second niveau
section = analyseLesAttributEtContenuDuNode(nod4Student, nod4Sujet, section, "ana:section", nameNode4);
}
}
}
}
section.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
section.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodsections.getNodes().add(section);
}
}
nodsections.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodsections.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodsections.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodsections.setClose(true);
return nodsections;
}
/**
* Analyse du node <b>sections</b>
* @param nodStudentSections
* @param nodSujetSections
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesTableaux(node nodStudentTableaux, node nodSujetTableaux, Run a, node nodmenu) {
node nodtableaux = new node();
nodtableaux.setNomElt("tableaux");
nodtableaux.setAttributs(nodSujetTableaux.getAttributs()); //ajoute tous les attributs du sujet
nodtableaux.setContenu(nodSujetTableaux.getContenu()); //ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tableau")!=null) {
nodtableaux.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tableau").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetTableaux.getNodes().size(); i++) { //niveau 1
if(nodSujetTableaux.getNodes().get(i).getNomElt().equals("table:table")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
node tableSujet = nodSujetTableaux.getNodes().get(i);
String nomDeLaTable = outils.withoutCodeAndPoint(tableSujet.getAttributs().get("table:name"));
node tableau = new node();
tableau.setNomElt("tableau");
tableau.getAttributs().put("nametableau", nomDeLaTable);
if(nodSujetTableaux.getNodes().get(i).getAttributs().get("titre")!=null) tableau.getAttributs().put("titre", nodSujetTableaux.getNodes().get(i).getAttributs().get("titre"));
node tableauStudent = a.retourneFirstNodeByNameAttributValue(nodStudentTableaux, "table:table", "table:name", nomDeLaTable);
// analyse les attributs du node
tableau = analyseLesAttributEtContenuDuNode(tableauStudent, tableSujet, tableau, "ana:tableau",tableSujet.getNomElt());
// les enfants du premier niveau du node
for(int j = 0 ; j < tableSujet.getNodes().size();j++ ) { //niveau 2
node nodSujet = tableSujet.getNodes().get(j);
String nameNode = nodSujet.getNomElt();
node nodStudent = null;
if(tableauStudent!=null) nodStudent = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode,nodSujet,null,null,tableauStudent,a);
//insère un saut si titre pas vide et saut=true
tableau=addNodeSautTitre(nodSujet, tableau);
// analyse attribut et contenu des enfants du premier niveau
tableau = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, tableau, "ana:tableau",nameNode);
for(int k = 0 ; k < nodSujet.getNodes().size();k++) { //niveau 3
node nod2Sujet = nodSujet.getNodes().get(k);
String nameNode2 = nod2Sujet.getNomElt();
node nod2Student = null;
if(tableauStudent!=null) nod2Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode2,nod2Sujet,null,tableauStudent,nodStudent,a);
//insère un saut si titre pas vide et saut=true
tableau=addNodeSautTitre(nod2Sujet, tableau);
// analyse attribut et contenu des enfants du second niveau
tableau = analyseLesAttributEtContenuDuNode(nod2Student, nod2Sujet, tableau, "ana:tableau",nameNode2 );
for(int l = 0 ; l < nod2Sujet.getNodes().size();l++) { //niveau 4
node nod3Sujet = nod2Sujet.getNodes().get(l);
String nameNode3 = nod3Sujet.getNomElt();
node nod3Student = null;
if(tableauStudent!=null) nod3Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode3,nod3Sujet,tableauStudent,nodStudent,nod2Student,a);
//insère un saut si titre pas vide et saut=true
tableau=addNodeSautTitre(nod3Sujet, tableau);
// analyse attribut et contenu des enfants du second niveau
tableau = analyseLesAttributEtContenuDuNode(nod3Student, nod3Sujet, tableau, "ana:tableau", nameNode3);
for(int m = 0 ; m < nod3Sujet.getNodes().size();m++) { //niveau 5
node nod4Sujet = nod3Sujet.getNodes().get(m);
String nameNode4 = nod4Sujet.getNomElt();
node nod4Student = null;
if(tableauStudent!=null) nod4Student = rechercherUnNodeStudent.rechercheLeNodeEnCascade(nameNode4,nod4Sujet,nodStudent,nod2Student,nod3Student,a);
//insère un saut si titre pas vide et saut=true
tableau=addNodeSautTitre(nod4Sujet, tableau);
// analyse attribut et contenu des enfants du second niveau
tableau = analyseLesAttributEtContenuDuNode(nod4Student, nod4Sujet, tableau, "ana:tableau", nameNode4);
}
}
}
}
tableau.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
tableau.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodtableaux.getNodes().add(tableau);
}
}
nodtableaux.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodtableaux.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodtableaux.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodtableaux.setClose(true);
return nodtableaux;
}
/**
* Analyse du node <b>bibliographies</b>.
* @param nodStudentBiblio
* @param nodSujetBiblio
* @param a
* @param nodmenu
* @return
*/
private static node analyseLaBiblio(node nodStudentBiblio, node nodSujetBiblio, Run a, node nodmenu) {
node nodbiblio = new node();
nodbiblio.setNomElt("bibliographies");
nodbiblio.setAttributs(nodSujetBiblio.getAttributs());//ajoute tous les attributs du sujet
nodbiblio.setContenu(nodSujetBiblio.getContenu());//ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "biblio")!=null) {
nodbiblio.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "biblio").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
// node biblio
node biblio = new node();
for(int i = 0 ; i < nodSujetBiblio.getNodes().size(); i++) {
if(nodSujetBiblio.getNodes().get(i).getNomElt().equals("text:bibliography")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String nomDeLaBiblio = outils.withoutCodeAndPoint(nodSujetBiblio.getNodes().get(i).getAttributs().get("text:name"));
biblio.setNomElt("biblio");
biblio.getAttributs().put("namebiblio", nomDeLaBiblio);
if(nodSujetBiblio.getNodes().get(i).getAttributs().get("titre")!=null) biblio.getAttributs().put("titre", nodSujetBiblio.getNodes().get(i).getAttributs().get("titre"));
String TitreTable = outils.withoutCodeAndPoint(nodSujetBiblio.getNodes().get(i).retourneFirstEnfantsByName("text:index-title").retourneLesContenusEnfants(""));
node nodSujet = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodSujetBiblio, "text:index-body"), TitreTable);
node nodStudent = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodStudentBiblio, "text:index-body"), TitreTable);
biblio = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, biblio, "ana:biblio", nodSujet.getNomElt());
for(int j =0 ; j < nodSujet.getNodes().size();j++) {
if(nodStudent!=null) {
if(j<nodStudent.getNodes().size()) {
biblio = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j), nodSujet.getNodes().get(j), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
if(k<nodStudent.getNodes().get(j).getNodes().size()) {
biblio = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j).getNodes().get(k), nodSujet.getNodes().get(j).getNodes().get(k), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}else {
biblio = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}else {
biblio = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNomElt());
}
}else {
biblio = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
biblio = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), biblio, "ana:biblio", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}
biblio.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
biblio.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodbiblio.getNodes().add(biblio);
}
}
nodbiblio.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodbiblio.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodbiblio.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodbiblio.setClose(true);
return nodbiblio;
}
/**
* Analyse du node <b>tablematieres</b>.
* @param nodStudentTableM
* @param nodSujetTableM
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesTablesMatieres(node nodStudentTableM, node nodSujetTableM, Run a, node nodmenu) {
node nodTablesMs = new node();
nodTablesMs.setNomElt("tablematieres");
nodTablesMs.setAttributs(nodSujetTableM.getAttributs());//ajoute tous les attributs du sujet
nodTablesMs.setContenu(nodSujetTableM.getContenu());//ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tablematieres")!=null) {
nodTablesMs.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tablematieres").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetTableM.getNodes().size(); i++) {
if(nodSujetTableM.getNodes().get(i).getNomElt().equals("text:table-of-content")) {
node table = new node();
table.setNomElt("tablematiere");
if(nodSujetTableM.getNodes().get(i).getAttributs().get("titre")!=null) {
String titre = nodSujetTableM.getNodes().get(i).getAttributs().get("titre");
if(!titre.isEmpty()) table.getAttributs().put("titre", titre);
}
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String TitreTable = outils.withoutCodeAndPoint(nodSujetTableM.getNodes().get(i).retourneFirstEnfantsByName("text:index-title").retourneLesContenusEnfants(""));
node nodSujet = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodSujetTableM, "text:index-body"), TitreTable);
node nodStudent = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodStudentTableM, "text:index-body"), TitreTable);
table = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, table, "ana:tablematiere", nodSujet.getNomElt());
for(int j =0 ; j < nodSujet.getNodes().size();j++) {
if(nodStudent!=null) {
if(j<nodStudent.getNodes().size()) {
table = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j), nodSujet.getNodes().get(j), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
if(k<nodStudent.getNodes().get(j).getNodes().size()) {
table = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j).getNodes().get(k), nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNomElt());
}
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tablematiere", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}
table.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
table.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodTablesMs.getNodes().add(table);
}
}
nodTablesMs.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodTablesMs.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodTablesMs.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodTablesMs.setClose(true);
return nodTablesMs;
}
/**
* Analyse du node <b>tableillustrations</b>.
* @param nodStudentTableI
* @param nodSujetTableI
* @param a
* @param nodmenu
* @return
*/
private static node analyseLesTablesIllustrations(node nodStudentTableI, node nodSujetTableI, Run a, node nodmenu) {
node nodTablesMs = new node();
nodTablesMs.setNomElt("tableillustrations");
nodTablesMs.setAttributs(nodSujetTableI.getAttributs());//ajoute tous les attributs du sujet
nodTablesMs.setContenu(nodSujetTableI.getContenu());//ajoute le commentaire du sujet
//ajoute l'identifiant pour le menu
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tableillustrations")!=null) {
nodTablesMs.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "tableillustrations").getAttributs().get("id"));
}
//initialise les points
outils.initiliseLesPoints();
for(int i = 0 ; i < nodSujetTableI.getNodes().size(); i++) {
if(nodSujetTableI.getNodes().get(i).getNomElt().equals("text:illustration-index")) {
node table = new node();
table.setNomElt("tableillustrations");
if(nodSujetTableI.getNodes().get(i).getAttributs().get("titre")!=null) {
String titre = nodSujetTableI.getNodes().get(i).getAttributs().get("titre");
if(!titre.isEmpty()) table.getAttributs().put("titre", titre);
}
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String TitreTable = outils.withoutCodeAndPoint(nodSujetTableI.getNodes().get(i).retourneFirstEnfantsByName("text:index-title").retourneLesContenusEnfants(""));
node nodSujet = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodSujetTableI, "text:index-body"), TitreTable);
node nodStudent = a.retourneFirstNodeParagrapheContain(a.retourneNames(nodStudentTableI, "text:index-body"), TitreTable);
table = analyseLesAttributEtContenuDuNode(nodStudent, nodSujet, table, "ana:tableillustration", nodSujet.getNomElt());
for(int j =0 ; j < nodSujet.getNodes().size();j++) {
if(nodStudent!=null) {
if(j<nodStudent.getNodes().size()) {
table = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j), nodSujet.getNodes().get(j), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
if(k<nodStudent.getNodes().get(j).getNodes().size()) {
table = analyseLesAttributEtContenuDuNode(nodStudent.getNodes().get(j).getNodes().get(k), nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNomElt());
}
}else {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNomElt());
for(int k=0; k<nodSujet.getNodes().get(j).getNodes().size();k++) {
table = analyseLesAttributEtContenuDuNode(null, nodSujet.getNodes().get(j).getNodes().get(k), table, "ana:tableillustration", nodSujet.getNodes().get(j).getNodes().get(k).getNomElt());
}
}
}
table.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
table.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodTablesMs.getNodes().add(table);
}
}
nodTablesMs.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodTablesMs.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodTablesMs.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodTablesMs.setClose(true);
return nodTablesMs;
}
/**
* Cette méthode permet d'analyse la structure du document.</br>
* La structure de l'étudiant est comparé avec la structure du sujet.</br>
* Le node d'analyse est retourné.</br>
* Le nom du node analysé pour cette partie est <page> puis <ana:page>.</br>
* <br>
* @param nodStudentS : node de la structure de l'étudiant.
* @param nodSujetS : node de la structure du sujet.
* @param a : Objet de la class cXML
* @param nodmenu : node menu.
* @param nodSujetParagraphs : node contenant l'ensemble des styles de paragraphe du sujet.
* @param nodStudentParagraphs : node contenant l'ensemble des styles de paragraphe de l'étudiant.
* @return : le node d'analyse de la structure.
*/
private static node analyseStructurePage(node nodStudentS, node nodSujetS, Run a, node nodmenu, node nodSujetParagraphs, node nodStudentParagraphs) {
node nodSpages = new node();
nodSpages.setNomElt("structurepage");
nodSpages.setAttributs(nodSujetS.getAttributs());
nodSpages.setContenu(nodSujetS.getContenu()); //ajoute le commentaire du sujet
//***************************************
//** Ajoute l'identifiant pour le menu **
//***************************************
if(a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "structurepage")!=null) {
nodSpages.getAttributs().put("id", a.retourneFirstNodeByNameAttributValue(nodmenu, "item", "name", "structurepage").getAttributs().get("id"));
}
//***************************
//** initialise les points **
//***************************
outils.initiliseLesPoints();
//********************************************************
//** Parcours les nodes enfants du node <structurepage> **
//********************************************************
for(int i = 0 ; i < nodSujetS.getNodes().size(); i++) {
if(nodSujetS.getNodes().get(i).getNomElt().equals("page")) {
int pointDebut = outils.getPointsClass();
int pointTotalDebut = outils.getPointTotal();
String nomDeLaPage = outils.withoutCodeAndPoint(nodSujetS.getNodes().get(i).getAttributs().get("style:master-page-name"));
if(nomDeLaPage==null) nomDeLaPage="Défaut";
String numeroabsolue = outils.withoutCodeAndPoint(nodSujetS.getNodes().get(i).getAttributs().get("numeroabsolue"));
node page = new node();
page.setNomElt("page");
page.getAttributs().put("namepage", nomDeLaPage);
page.getAttributs().put("numeroabsolue", numeroabsolue);
if(nodSujetS.getNodes().size()>0) if(nodSujetS.getNodes().get(i).getAttributs().get("titre")!=null) page.getAttributs().put("titre", nodSujetS.getNodes().get(i).getAttributs().get("titre"));
node pageStudent = a.retourneFirstNodeByNameAttributValue(nodStudentS, "page", "numeroabsolue", numeroabsolue);
node pageSujet = nodSujetS.getNodes().get(i);
//********************************************
//** analyse les attributs des nodes <page> **
//********************************************
page = analyseLesAttributEtContenuDuNode(pageStudent, pageSujet, page, "ana:page",pageSujet.getNomElt());
//************************************
//** analyse tous les nodes enfants **
//************************************
page = analyseLesNodesEnants.nodeNext(page, "ana:page", pageStudent, null, null, pageSujet, nodSujetParagraphs, nodStudentParagraphs, a);
//****************************************************************
//** Insère les attributs des points dans les node de l'analyse **
//****************************************************************
page.getAttributs().put("point", String.valueOf(outils.getPointsClass()-pointDebut));
page.getAttributs().put("pointTotal", String.valueOf(outils.getPointTotal()-pointTotalDebut));
nodSpages.getNodes().add(page);
}
}
//****************************************************************
//** Insère les attributs des points dans les node de l'analyse **
//****************************************************************
nodSpages.getAttributs().put("pointgagner",String.valueOf(outils.getPointsClass()));
nodSpages.getAttributs().put("pointtotal",String.valueOf(outils.getPointTotal()));
nodSpages.getAttributs().put("proportioncorrect",String.valueOf(outils.getProportionCorrect()));
nodSpages.setClose(true);
return nodSpages;
}
/**
* Analyse tous les attributs et les contenus d'un node.<br>
* Les attributs et les contenus doivent posséder la carcatère ‽ ou ‼.<br>
* <br>
* @param nodeStudent : le node de l'étudiant.
* @param sujet : le node du sujet
* @param retour : le node à retourner avec les enfants nommés nameItem.
* @param nameItem : le nom des nodes enfants.
* @param nameElt : le nom de l'élément (node) analysé.
* @return le node <b>retour</b> avec tous les nodes enfants <b>nameItem</b> contenant les différentes analyse.
*/
public static node analyseLesAttributEtContenuDuNode(node nodeStudent, node sujet, node retour, String nameItem, String nameElt) {
Enumeration<String> key = sujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if( sujet.getAttributs().get(k).contains("")){
if(nodeStudent!=null) {
String valueAttributStudent = nodeStudent.getAttributs().get(k);
String valueAttributSujet = sujet.getAttributs().get(k);
node item = retourneNoteAvecResultatsAnalyse(nameItem,k, valueAttributStudent, valueAttributSujet,nameElt);
retour.getNodes().add(item);
}else {
String valueAttributStudent = "null";
String valueAttributSujet = sujet.getAttributs().get(k);
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,nameElt);
retour.getNodes().add(item);
}
}
if(!sujet.getAttributs().get(k).equals("0")) {
if(k.equals("evalNameNode") && !sujet.getAttributs().get(k).equals("0")) {
if(nodeStudent!=null) {
retour = evaluNameNode(retour,nodeStudent, sujet.getNomElt(), sujet.getAttributs().get("evalNameNode"),sujet.getNomElt());
}else {
retour = evaluNameNode(retour,null, sujet.getNomElt(), sujet.getAttributs().get("evalNameNode"),sujet.getNomElt());
}
}
if(k.equals("evalNameCreator") && sujet.getNomElt().equals("dc:creator")) {
if(nodeStudent!=null) {
retour = evaluNameCreator(retour,nodeStudent, nodeStudent.getContenu().get(0), sujet.getAttributs().get("evalNameCreator"),"Editeur");
}else {
retour = evaluNameCreator(retour,null, "Editeur inconnu", sujet.getAttributs().get("evalNameCreator"),"Editeur");
}
}
if(k.equals("evalNameInitialCreator") && sujet.getNomElt().equals("meta:initial-creator")) {
if(nodeStudent!=null) {
retour = analyseNameInitialCreator(retour,nodeStudent, nodeStudent.getContenu().get(0), sujet.getAttributs().get("evalNameInitialCreator"),"Créateur");
}else {
retour = analyseNameInitialCreator(retour,null, "Créateur inconnu", sujet.getAttributs().get("evalNameInitialCreator"),"Créateur");
}
}
}
}
//avec l'attribut allContent="strict1", allContent="strictSansEspace1" et allContent="environ1" alors analyse tout le contenu du node
if(sujet.getAttributs().get("allContent")!=null) if(!sujet.getAttributs().get("allContent").isEmpty()){
String points ="‽0";
if(sujet.getAttributs().get("allContent").contains("strict")) points = sujet.getAttributs().get("allContent").replace("strict", "");
if(sujet.getAttributs().get("allContent").contains("strictSansEspace")) points = sujet.getAttributs().get("allContent").replace("strictSansEspace", "≡‽");
if(sujet.getAttributs().get("allContent").contains("environ")) points = sujet.getAttributs().get("allContent").replace("environ", "¢‽");
String testPoint = points.substring(points.indexOf("")+1, points.length());
boolean pasDeProblem = true;
boolean pointSupAUn = false;
try {
if(Integer.valueOf(testPoint)>=1) pointSupAUn=true;
}catch (Exception e) {
System.out.println("Dans le node " + sujet.getNomElt() + ".\nIl y a un problème avec la valeur de l'attribut allContent=\"" + sujet.getAttributs().get("allContent") + "\"");
System.out.println(e.toString());
pasDeProblem=false;
}
if(pasDeProblem && pointSupAUn) {
String allContentSujet = outils.withoutCodeAndPointPourRechercheContenuExact(sujet.retourneLesContenusEnfants("")) + points;
String allContentStudent = "null";
if( nodeStudent!=null) allContentStudent = nodeStudent.retourneLesContenusEnfants("");
node item = retourneNoteAvecResultatsAnalyse(nameItem,"Contenu textuel", allContentStudent, allContentSujet, nameElt);
retour.getNodes().add(item);
}
}
// analyse le contenu du node avec tous les nodes sauf "text:sequence"
if(sujet.contenuEvaluer() && !sujet.getNomElt().equals("text:sequence")) {
String contenuStudent ="";
if(nodeStudent!=null) if(nodeStudent.getContenu().size()>0) contenuStudent = nodeStudent.getContenu().get(0);
String contenuSujet = sujet.getContenu().get(0);
node item = retourneNoteAvecResultatsAnalyse(nameItem,"Contenu textuel", contenuStudent, contenuSujet, nameElt);
retour.getNodes().add(item);
}
// analyse le contenu du node text:sequence et tous les enfants text:change (lorsque les légendes sont modifiées)
if(sujet.contenuEvaluer() && sujet.getNomElt().equals("text:sequence")) {
String contenuStudent ="";
if(nodeStudent!=null) if(nodeStudent.getContenu().size()>0) contenuStudent = nodeStudent.getContenu().get(0); //contenuStudent = nodeStudent.retourneLesContenusEnfants("text:change");
String contenuSujet = sujet.getContenu().get(0);
node item = retourneNoteAvecResultatsAnalyse(nameItem,"Contenu textuel", contenuStudent, contenuSujet, nameElt);
retour.getNodes().add(item);
}
return retour;
}
/**
* Retourne le node avec les résultats de la comparaison entre les deux valeurs (étudiant et sujet).<br>
* <br>
* @param nameNode
* @param Tst (résultat de la comparaison)
* @param property
* @param valueAttributStudent
* @param valueAttributSujet
* @return
*/
private static node retourneNoteAvecResultatsAnalyse(String nameNode, String property, String valueStudent, String valueSujet, String nameElt) {
String Tst = outils.Compare(valueStudent, valueSujet);
int niveau = 3;
if(Tst.contains("Correct")) niveau = 1;
if(Tst.contains("Erreur")) niveau = 2;
valueStudent = outils.remplaceCaracteresCodageAttribut(valueStudent);
valueSujet = outils.remplaceCaracteresCodageAttribut(valueSujet);
node item = new node(nameNode, Tst, property , valueStudent, valueSujet, niveau, outils.getPointEnJeu(),nameElt);
return item;
}
/**
* Analyse tous les attributs des nodes <style:style>.<br>
* Formatage direct des styles de paragraphe.</br>
* Les attributs doivent contenir le code ‼.<br>
* <br>
* @param nodeStudent : le node de l'étudiant.
* @param sujet : le node du sujet
* @param retour : le node à retourner avec les enfants nommés nameItem.
* @param nameItem : le nom des nodes enfants.
* @param nameElt : le nom de l'élément (node) analysé.
* @return le node <b>retour</b> avec tous les nodes enfants <b>nameItem</b> contenant les différentes analyse.
*/
public static node analyseLesAttributAnalyseStyle(node nodeStyleParagraphStudent, node nodeStyleParagraphSujet, node retour, String nameItem, String nameElt) {
Enumeration<String> key = nodeStyleParagraphSujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(nodeStyleParagraphSujet.getAttributs().get(k).contains("") || nodeStyleParagraphSujet.getAttributs().get(k).contains("")){
if(nodeStyleParagraphStudent!=null) {
String valueAttributStudent = nodeStyleParagraphStudent.getAttributs().get(k);
String valueAttributSujet = nodeStyleParagraphSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem,k, valueAttributStudent, valueAttributSujet,nameElt);
retour.getNodes().add(item);
}else {
String valueAttributStudent = "null";
String valueAttributSujet = nodeStyleParagraphSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,nameElt);
retour.getNodes().add(item);
}
}
}
if(nodeStyleParagraphStudent!=null) {
if(nodeStyleParagraphSujet.retourneEnfantsByNameExist("style:paragraph-properties") && nodeStyleParagraphStudent.retourneEnfantsByNameExist("style:paragraph-properties") ) {
node propertiesSujet = nodeStyleParagraphSujet.retourneFirstEnfantsByName("style:paragraph-properties");
node propertiesStudent = nodeStyleParagraphStudent.retourneFirstEnfantsByName("style:paragraph-properties");
key = propertiesSujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(propertiesSujet.getAttributs().get(k).contains("") || propertiesSujet.getAttributs().get(k).contains("")){
if(propertiesStudent!=null) {
String valueAttributStudent = propertiesStudent.getAttributs().get(k);
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem,k, valueAttributStudent, valueAttributSujet,"style:paragraph-properties");
retour.getNodes().add(item);
}else {
String valueAttributStudent = "null";
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,"style:paragraph-properties");
retour.getNodes().add(item);
}
}
}
}
}else {
node propertiesSujet = nodeStyleParagraphSujet.retourneFirstEnfantsByName("style:paragraph-properties");
key = propertiesSujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(propertiesSujet.getAttributs().get(k).contains("") || propertiesSujet.getAttributs().get(k).contains("")){
String valueAttributStudent = "null";
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,"style:paragraph-properties");
retour.getNodes().add(item);
}
}
}
if(nodeStyleParagraphStudent!=null) {
if(nodeStyleParagraphSujet.retourneEnfantsByNameExist("style:text-properties") && nodeStyleParagraphStudent.retourneEnfantsByNameExist("style:text-properties") ) {
node propertiesSujet = nodeStyleParagraphSujet.retourneFirstEnfantsByName("style:text-properties");
node propertiesStudent = nodeStyleParagraphStudent.retourneFirstEnfantsByName("style:text-properties");
key = propertiesSujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(propertiesSujet.getAttributs().get(k).contains("") || propertiesSujet.getAttributs().get(k).contains("")){
if(propertiesStudent!=null) {
String valueAttributStudent = propertiesStudent.getAttributs().get(k);
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem,k, valueAttributStudent, valueAttributSujet,"style:text-properties");
retour.getNodes().add(item);
}else {
String valueAttributStudent = "null";
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,"style:text-properties");
retour.getNodes().add(item);
}
}
}
}
}else {
node propertiesSujet = nodeStyleParagraphSujet.retourneFirstEnfantsByName("style:text-properties");
key = propertiesSujet.getAttributs().keys();
while(key.hasMoreElements()) {
String k = key.nextElement();
if(propertiesSujet.getAttributs().get(k).contains("") || propertiesSujet.getAttributs().get(k).contains("")){
String valueAttributStudent = "null";
String valueAttributSujet = propertiesSujet.getAttributs().get(k).replace("", "");
node item = retourneNoteAvecResultatsAnalyse(nameItem, k, valueAttributStudent, valueAttributSujet,"style:text-properties");
retour.getNodes().add(item);
}
}
}
return retour;
}
/**
* Retourne le nom du fichier de l'étudiant pour le Zip de Moodle.<br>
* </br>
* @param filename
* @param nodana
* @return
*/
private 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
*/
private static void messageSystem(node nod) {
node ouverture = nod.retourneFirstEnfantsByName("ouverture");
node notation = nod.retourneFirstEnfantsByName("bodyetnotation");
node erreurs = nod.retourneFirstEnfantsByName("erreurs");
boolean flagError = Boolean.valueOf(erreurs.getAttributs().get("oneError"));
if(!commandes.fichierStudentMoodle) {System.out.println("\t Dossier analysé : " + ouverture.getAttributs().get("dossier"));}else {System.out.println("\t Fichier analysé : " + ouverture.getAttributs().get("dossier"));}
if(notation.getAttributs().get("baremeABC").equals("true")) {
System.out.println("\t Note : " + notation.getAttributs().get("noteABC"));
}else {
System.out.println("\t Note : " + notation.getAttributs().get("note") + "/" + ouverture.getAttributs().get("notefrom"));
}
if(flagError) {
System.out.println("\t ERREUR dans le fichier de l'étudiant.");
if(Boolean.valueOf(erreurs.getAttributs().get("manqueHistorique"))) 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"))) 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"))) System.out.println("\t Erreur : Ce n'est pas la bonne date de création du fichier.");
if(Boolean.valueOf(erreurs.getAttributs().get("manqueMetaSujet"))) 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"))) 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"))) System.out.println("\t Erreur : La propriété personnalisé \"Sujet\" n'est pas correct.");
}
System.out.println();
}
/**
* Ajoute dans le node nodanalyse.</br>
* Le node saut et son attribut titre</br>
* Et place un titre1, ou titre2, ou titre3</br>
* <br>
* @param nod
* @return
*/
public static node addNodeSautTitre(node nodSujet, node nodanalyse) {
if(nodSujet.getAttributs().get("saut")!=null) if(Boolean.valueOf(nodSujet.getAttributs().get("saut"))) {
if(nodSujet.getAttributs().get("titre")!=null) {
node N = new node();
N.setNomElt("saut");
N.getAttributs().put("titre", nodSujet.getAttributs().get("titre"));
N.setClose(true);
nodanalyse.getNodes().add(N);
}
if(nodSujet.getAttributs().get("titre2")!=null) {
node N = new node();
N.setNomElt("saut");
N.getAttributs().put("titre2", nodSujet.getAttributs().get("titre2"));
N.setClose(true);
nodanalyse.getNodes().add(N);
}
if(nodSujet.getAttributs().get("titre3")!=null) {
node N = new node();
N.setNomElt("saut");
N.getAttributs().put("titre3", nodSujet.getAttributs().get("titre3"));
N.setClose(true);
nodanalyse.getNodes().add(N);
}
}
return nodanalyse;
}
/**
* Vérirication des historiques
* @param verification
* @param a
* @return le node verif
*/
private 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>());
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);
@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 ="";
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 = 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(a.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** Find a match ** " + 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()));
}
// 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 ************************");
}
}
return verif;
}
/**
* Ecriture de l'ensemble des notes brutes sans vérification et sans rechercher les identifiants des étudiants
* @param nodesana
* @throws IOException
*/
private 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();
}
/**
* Ecriture du fichier CSV avec vérification.<br>
* Mais sans rechercher les identifiants des étudiants.
* @param ana
* @param verif
* @param a
* @throws IOException
*/
private 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();
}
/**
* 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
*/
private 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();
}
/**
* 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;
}
/**
*
* @param libreoffice_date
* @return
*/
private static Date DateLibreOffice(String libreoffice_date){
boolean contientHeure = false;
if(libreoffice_date.contains("T")) {
libreoffice_date=libreoffice_date.replace("T", " ");
contientHeure=true;
}
SimpleDateFormat simpledateformat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d = null;
if(!contientHeure) simpledateformat = new SimpleDateFormat("yyyy-MM-dd");
try {
d = simpledateformat.parse(libreoffice_date);
}catch(ParseException e) {
e.printStackTrace();
}
return d;
}
/**
* Chargement dans un node du fichier CSV de la liset 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
*/
private static node chargementFichierCSV(Run a, String nameCSV) {
String targetString = "";
try {
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream(a.getPatch() + "/" + nameCSV), "UTF-8"));
String line;
while ((line = br.readLine()) != null) {
targetString = targetString + line + "\n";
}
br.close();
} catch (IOException e) {
commandes.clotureWithErrorFile(nameCSV);
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
*/
private static String chargementFichierSVG(Run a, String nameSVG) {
String targetString = "";
try {
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream(a.getPatch() + "/" + nameSVG), "UTF-8"));
String line;
while ((line = br.readLine()) != null) {
targetString = targetString + line + "\n";
}
br.close();
} catch (IOException e) {
commandes.clotureWithErrorFile(nameSVG);
e.printStackTrace();
}
return targetString;
}
/**
* Ajoute les valeurs par défauts pour les styles de paragraphes.<br>
* <br>
* @param LesStyleStudents : Tous les styles de paragraphes du fichiers de l'étudiants.
* @param styleParagraph : le node dont il faut ajouter les valerus par défauts.
* @return le node styleParagraph.
*/
public static node ajouteValeurParDefautAuStyleParagraph(node ensembleDesParagraphes , node styleParagraph) {
node LesStyleDefaut = null;
if(ensembleDesParagraphes.retourneEnfantsByNameExist("style:default-style")) {
LesStyleDefaut = ensembleDesParagraphes.retourneFirstEnfantsByName("style:default-style");
}
if(LesStyleDefaut!=null && styleParagraph!=null) {
//le paragarph properties
node nodeStyleParDefautParagraphProperties = LesStyleDefaut.retourneFirstEnfantsByName("style:paragraph-properties");
node LesNodesStyleParagraph = styleParagraph.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());
styleParagraph.getNodes().add(n);
break;
}
}
//le text properties
node nodeStyleParDefautTextProperties = LesStyleDefaut.retourneFirstEnfantsByName("style:text-properties");
node LesNodesStyleText = styleParagraph.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());
styleParagraph.getNodes().add(n);
break;
}
}
}
return styleParagraph;
}
/**
* Même méthode que "ajouteValeurParDefautAuStyleParagraph".<br>
* <br>
* @param ensembleDesParagraphes
* @param styleParagraph
* @return
*/
public static node ajouteValeurLesValeursDuStyleParagraphParent(node ensembleDesParagraphes , node styleParagraph) {
node parent = null;
if(styleParagraph.getAttributs().get("style:parent-style-name")!=null) {
String nameStyleParent = styleParagraph.getAttributs().get("style:parent-style-name");
if(ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValue("style:style", "style:name", nameStyleParent)!=null) {
parent = ensembleDesParagraphes.retourneFirstNodeByNameAndAttributValue("style:style", "style:name", nameStyleParent);
}
}
if(parent!=null) {
//le paragarph properties
node nodeStyleParDefautParagraphProperties = parent.retourneFirstEnfantsByName("style:paragraph-properties");
node LesNodesStyleParagraph = styleParagraph.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());
styleParagraph.getNodes().add(n);
break;
}
}
//le text properties
node nodeStyleParDefautTextProperties = parent.retourneFirstEnfantsByName("style:text-properties");
node LesNodesStyleText = styleParagraph.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());
styleParagraph.getNodes().add(n);
break;
}
}
}
return styleParagraph;
}
/**
* Analyse le nom du node
*
* @param retour : le node retour qui contient l'item ajouté
* @param nodStudent : le node Student qui peut être null
* @param nameNode : le nom du node
* @param point : les points
* @param nameElt : le nom de l'élément
* @return
*/
private static node evaluNameNode(node retour, node nodStudent, String nameNode, String point, String nameElt) {
node item = null;
if(nodStudent!=null) {
item = retourneNoteAvecResultatsAnalyse(nameNode,"name", nodStudent.getNomElt(),nameNode + "" +point, nameElt );
}else {
outils.IncrementPointTotal(Integer.valueOf(point));
item = new node(nameNode, "Erreur", "Nom du node" , "null", nameNode, 2, outils.getPointEnJeu(),nameElt);
}
retour.getNodes().add(item);
return retour;
}
private static node evaluNameCreator(node retour, node nodStudent, String nameCreator, String point, String nameElt) {
node item = null;
if(nodStudent!=null) {
item = retourneNoteAvecResultatsAnalyse(nameCreator,"name", nodStudent.getAttributs().get("creator"),nameCreator + "↑‽" +point, nameElt );
}else {
outils.IncrementPointTotal(Integer.valueOf(point));
item = new node(nameCreator, "Erreur", "Nom du l'éditeur" , "null", nameCreator, 2, outils.getPointEnJeu(),nameElt);
}
retour.getNodes().add(item);
return retour;
}
private static node analyseNameInitialCreator(node retour, node nodStudent, String nameCreator, String point, String nameElt) {
node item = null;
if(nodStudent!=null) {
item = retourneNoteAvecResultatsAnalyse(nameCreator,"name", nodStudent.getAttributs().get("initial-creator"),nameCreator + "↑‽" +point, nameElt );
}else {
outils.IncrementPointTotal(Integer.valueOf(point));
item = new node(nameCreator, "Erreur", "Nom du créateur" , "null", nameCreator, 2, outils.getPointEnJeu(),nameElt);
}
retour.getNodes().add(item);
return retour;
}
}