maj

bin/.gitignore

@@ -7,3 +7,7 @@
 /resources/
 /evaluer/
 /outils/
+/calc/
+/baseEvaluation/
+/baseListesEtudiants/
+/calcul/

src/calc/Student.java

@@ -0,0 +1,72 @@
+package calc;
+
+import xml.EnsembleFichiers;
+import xml.LecturesDossiers;
+import xml.node;
+
+public class Student {
+
+	
+	/**
+	 * Lecture du fichier Student pour vérification des historiques.<br>
+	 * <br>
+	 * @param nod node
+	 * @param i
+	 * @return
+	 */
+	public static node LectureFichierEtudiantPourVerification(node nod, node nodHisto, Integer i) {
+		
+		node fichier = new node();
+		fichier.setNameNode("fichier");
+		fichier.getAttributs().put("filename", EnsembleFichiers.getListeFichierods().get(i));
+		fichier.getAttributs().put("dossier",  EnsembleFichiers.getListeNomDossier().get(i));
+		
+		node nodmeta = nod.retourneFirstEnfant("office:meta");
+		System.out.println(i);
+		if(nodmeta==null) return null;
+		LecturesDossiers.getEC();
+		System.out.println(EnsembleFichiers.getListeNomDossier().get(i));
+		
+		if(!nodmeta.retourneFirstEnfant("meta:generator").getContenu().isEmpty()) {
+			fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfant("meta:generator").getContenu().get(0));
+		}else {
+			fichier.getAttributs().put("producteur", "nobody");
+		}
+		if(!nodmeta.retourneFirstEnfant("meta:generator").getContenu().isEmpty()) {
+			fichier.getAttributs().put("producteur", nodmeta.retourneFirstEnfant("meta:generator").getContenu().get(0));
+		}else {
+			fichier.getAttributs().put("producteur", "unknow");
+		}
+		if(!nodmeta.retourneFirstEnfant("dc:date").getContenu().isEmpty()) {
+			fichier.getAttributs().put("dateModification", nodmeta.retourneFirstEnfant("dc:date").getContenu().get(0));
+		}else {
+			fichier.getAttributs().put("dateModification", "unknow");
+		}
+		if(!nodmeta.retourneFirstEnfant("meta:editing-duration").getContenu().isEmpty()) {
+			fichier.getAttributs().put("dureeEdition", nodmeta.retourneFirstEnfant("meta:editing-duration").getContenu().get(0));
+		}else {
+			fichier.getAttributs().put("dureeEdition", "unknow");			
+		}
+		fichier.getEnfants().add(nodmeta);
+		
+		node nodhistorique = new node();
+		nodhistorique.setNameNode("historique");
+		int nbrModif =0;
+		if(nodHisto.retourneFirstEnfant("table:tracked-changes")!=null) {
+			nodHisto = nodHisto.retourneFirstEnfant("table:tracked-changes");
+			nodHisto.setParent(null);
+			nbrModif = nodHisto.retourneFirstEnfant("table:tracked-changes").getEnfants().size();
+			nodhistorique.addEnfant(nodHisto);
+		}else {
+			node tableTrackedVide= new node("table:tracked-changes");
+			nodhistorique.addEnfant(tableTrackedVide);
+		}
+		nodhistorique.getAttributs().put("nbrModif", String.valueOf(nbrModif));
+
+//		nodhistorique.getEnfants().addAll( nod.retourneAllEnfants("office:spreadsheet")); //a.retourneNames(nod, "office:text"));
+		fichier.getEnfants().add(nodhistorique);
+		
+		return fichier;
+	}
+	
+}

src/calc/commandes.java

@@ -22,6 +22,7 @@ public class commandes {
 	public static node sujetSauvegarde = new node();
 	public static JTree tree = new JTree();
 	public static node nodeACCSV = null;
+	public static String pathApp = Paths.get("").toAbsolutePath().toString();
 	
 	//*************************
 	//**       version       **

src/evaluer/evaluerLesFichiersEtudiants.java

@@ -8,11 +8,15 @@ import javax.xml.parsers.ParserConfigurationException;
 
 import org.xml.sax.SAXException;
 
+import calc.Student;
 import calc.commandes;
 import calcul.calculIntervalleBaremeABCDE;
 import fenetres.baliseStyle;
-import net.lingala.zip4j.exception.ZipException;
+import xml.EnsembleFichiers;
+import xml.LecturesDossiers;
+import xml.ecritureFileXML;
 import xml.node;
+import xml.transformeXLMtoNode;
 
 public class evaluerLesFichiersEtudiants implements Runnable{
 	
@@ -58,28 +62,45 @@ public class evaluerLesFichiersEtudiants implements Runnable{
 		
 		commandes.message.append("<hr>");
 		
-		Run a = null;
+		if(commandes.fichierStudentMoodle) {
-		try {
+			try {
-			a = new Run(commandes.path,commandes.Profil, commandes.fichierStudentMoodle);
+				new LecturesDossiers(ecritureFileXML.LocationFile.UniquementFichier, commandes.path);
-		} catch (ParserConfigurationException e2) {
+			} catch (ParserConfigurationException e) {
-			e2.printStackTrace();
+				// TODO Auto-generated catch block
-		} catch (SAXException e2) {
+				e.printStackTrace();
-			e2.printStackTrace();
+			} catch (SAXException e) {
-		} catch (IOException e2) {
+				// TODO Auto-generated catch block
-			e2.printStackTrace();
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}else {
+			try {
+				new LecturesDossiers(ecritureFileXML.LocationFile.DansDossier, commandes.path);
+			} catch (ParserConfigurationException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (SAXException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
 		}
 		
 		
 	
-	
+		LecturesDossiers.getEC();
 		//*****************************************
 		//** Nombre de fichier writer à analyser **
 		//*****************************************
-		int nbFichierWriter = a.getLectDossiers().getEC().getListeContentWriter().size();
+		int nbClasseur = EnsembleFichiers.getListeContentTableur().size();
-		String NbFichiers = String.valueOf(nbFichierWriter);
+		String NbFichiers = String.valueOf(nbClasseur);
-		commandes.analyse_Nbre_Fichier_Student = nbFichierWriter;
+		commandes.analyse_Nbre_Fichier_Student = nbClasseur;
 		commandes.message.append("<br>");
-		commandes.message.append("<p>Nombre de fichier à analyser et évaluer : " + NbFichiers + "</p>");
+		commandes.message.append("<p>Nombre de fichier à analyser et à évaluer : " + NbFichiers + "</p>");
 		commandes.message.append("<br>");
 		commandes.message.append("<hr>");
 		
@@ -89,25 +110,35 @@ public class evaluerLesFichiersEtudiants implements Runnable{
 		node verif  = new node(); 
 		if(commandes.verifHisto || commandes.verifHisto2) {
 			node verification = new node();
-			verification.setNomElt("verification");
+			verification.setNameNode("verification");
-			verification.getAttributs().put("nombre_fichier", String.valueOf(a.getLectDossiers().getEC().getListeFichierodt().size()));
+			LecturesDossiers.getEC();
-			for(int i = 0 ; i < nbFichierWriter ; i++) {
+			verification.getAttributs().put("nombre_fichier", String.valueOf(EnsembleFichiers.getListeFichierods().size()));
-				txt.setText("\nChargement de l'historique du fichier n° " + String.valueOf(i) +" par comparaison avec les "+ String.valueOf(nbFichierWriter-1) + " autres fichiers");
+			for(int i = 0 ; i < nbClasseur ; i++) {
-				node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
+				txt.setText("\nChargement de l'historique du fichier n° " + String.valueOf(i) +" par comparaison avec les "+ String.valueOf(nbClasseur-1) + " autres fichiers");
-				node nodStudent = meptl.LectureFichierEtudiantPourVerification(nod,a,i);
+								
-				verification.getNodes().add(nodStudent);
+				new transformeXLMtoNode(EnsembleFichiers.getListeContentTableur().get(i),false,null);//Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
+				node nod = transformeXLMtoNode.getNodeRoot();
+				
+				new transformeXLMtoNode(EnsembleFichiers.getListeHistoriqueTableur().get(i),false,null);//Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
+				node nodHisto = transformeXLMtoNode.getNodeRoot();
+				
+				node nodStudent = Student.LectureFichierEtudiantPourVerification(nod,nodHisto,i);
+				
+				verification.getEnfants().add(nodStudent);		
 			}
+			
+			verification.saveNodeEnXMLinNewFile("histo", commandes.pathApp);
+			
 			//a.ecritureNodeEnXML(verification, "VerificationHistorique","",false); //écriture du node de l'étudiant
-			txt.setText("\nRecherche des concordances temporelles et d'auteur dans l'historique des modifications des " + nbFichierWriter + " fichiers."
+			txt.setText("\nRecherche des concordances temporelles et d'auteur dans l'historique des modifications des " + nbClasseur + " fichiers."
 					+ "\nPatientez, cela peut prendre quelques secondes ou minutes.");
 			
 			//********************************
 			//** Ecriture du node verif.xml **
-			//********************************
 			try {
-				verif = VerificationHistorique.verificationHistorique(verification, a,txt);
+				verif = new verificationHistorique(verification,txt).getVerif();
-				Run.ecritureNodeEnXML(verif, "Verif",commandes.path, Run.TypeFile.Verif );
+				verif.saveNodeEnXMLinNewFile("Verif", commandes.pathApp);
-			} catch (IOException | ParseException | CloneNotSupportedException e) {
+			} catch (ParseException | CloneNotSupportedException e) {
 				e.printStackTrace();
 			} //écriture du node de vérification
 			commandes.message.append("<br>");
@@ -123,172 +154,171 @@ public class evaluerLesFichiersEtudiants implements Runnable{
 		//** Node contenant l'ensemble des analyses des étudiants **
 		//*********************************************************
 		node ensembleanalyse = new node();
-		ensembleanalyse.setNomElt("analyses");
+		ensembleanalyse.setNameNode("analyses");
 		
 		//*****************************************************
 		//** Parcours l'ensemble des fichiers des étudiants ***
 		//*****************************************************
-		for(int i = 0 ; i < nbFichierWriter ; i++) {
+		for(int i = 0 ; i < nbClasseur ; i++) {
-			String texteAfficher = "\nEvaluation du fichier n° " + String.valueOf(i+1) + "/" + String.valueOf(nbFichierWriter) + " fichier(s)";
+			String texteAfficher = txt.getText() + "\nEvaluation du fichier n° " + String.valueOf(i+1) + "/" + String.valueOf(nbClasseur) + " fichier(s)";
 			txt.setText(texteAfficher);
 			
 			//index de l'étudiant
 			commandes.analyse_index_Fichier_Student = i;
 			
-			//** Ne prends pas en compte le dossier destination créé par la commande -dest
-			//** Si pas d'analyse alors le nom doit contenir le caractère $ dans le nom du dossier.
-			if(commandes.fourniDossierDestination) if(a.getLectDossiers().getEC().getListeNomDossier().get(i).equals(commandes.pathDestination)) continue;
-			
 			//***********************************************************
 			//** Lecture et transformation en node du fichier étudiant **
 			//***********************************************************
-			node nod = Run.XMLContent(a.getLectDossiers().getEC().getListeContentWriter().get(i));
+			new transformeXLMtoNode(EnsembleFichiers.getListeContentTableur().get(i),false,null);
+			node nod = transformeXLMtoNode.getNodeRoot();
 			node nodStudent=null;
-			try {
+			System.gc();   // Demande de nettoyage du GC
 			
-
-				//Création du node de l'étudiant.
-				//Permet aussi d'avoir l'historique des modifications du fichier de l'étudiant.
-				nodStudent = meptl.LectureFichierEtudiantSousFormeDeNode(nod,a,i);
-				
-				//Supprime l'historique des modifications
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:tracked-changes");
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change"); 
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change-start"); 
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change-end");
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:deletion");
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:bookmark-start");
-				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:bookmark-end");
-				
-				
-			} catch (IOException e1) {
-				e1.printStackTrace();
-			}
-
-			//Ecriture du node fichier de l'étudiant
 //			try {
-//				Run.ecritureNodeEnXML(nodStudent, a.getLectDossiers().getEC().getListeNomDossier().get(i),commandes.path,"Sujet");
+//
+//
+//				//Création du node de l'étudiant.
+//				//Permet aussi d'avoir l'historique des modifications du fichier de l'étudiant.
+//				nodStudent = meptl.LectureFichierEtudiantSousFormeDeNode(nod,a,i);
+//				
+//				//Supprime l'historique des modifications
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:tracked-changes");
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change"); 
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change-start"); 
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:change-end");
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:deletion");
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:bookmark-start");
+//				nodStudent.supprimeTousLesNodesEnfantWithThisName("text:bookmark-end");
+//				
+//				
 //			} catch (IOException e1) {
-//				// TODO Auto-generated catch block
 //				e1.printStackTrace();
 //			}
-
+//
-
+//			//Ecriture du node fichier de l'étudiant
-			//**********************************
+////			try {
-			//** Analyse des fichiers student **
+////				Run.ecritureNodeEnXML(nodStudent, a.getLectDossiers().getEC().getListeNomDossier().get(i),commandes.path,"Sujet");
-			//**********************************
+////			} catch (IOException e1) {
-			if(commandes.analyse||commandes.ecritNodeAnalyse) {
+////				// TODO Auto-generated catch block
-				
+////				e1.printStackTrace();
-//					Run.ecritureNodeEnXML(nodStudent, "fichier student","",false,""); //écriture du node nodStudent de l'étudiant
+////			}
-					node ana = analyseFichier.analyse(nodStudent, commandes.sujet, i, a, txt,texteAfficher);
+//
-//					try {
+//
-//						Run.ecritureNodeEnXML(ana, "analyse", commandes.path, Run.TypeFile.Verif);
+//			//**********************************
-//					} catch (IOException e1) {
+//			//** Analyse des fichiers student **
-//						// TODO Auto-generated catch block
+//			//**********************************
-//						e1.printStackTrace();
+//			if(commandes.analyse||commandes.ecritNodeAnalyse) {
+//				
+////					Run.ecritureNodeEnXML(nodStudent, "fichier student","",false,""); //écriture du node nodStudent de l'étudiant
+//					node ana = analyseFichier.analyse(nodStudent, commandes.sujet, i, a, txt,texteAfficher);
+////					try {
+////						Run.ecritureNodeEnXML(ana, "analyse", commandes.path, Run.TypeFile.Verif);
+////					} catch (IOException e1) {
+////						// TODO Auto-generated catch block
+////						e1.printStackTrace();
+////					}
+//					//**************************************************
+//					//** Ecriture des fichiers d'analyse des students **
+//					//**************************************************
+//					if(commandes.ecritNodeAnalyse) {
+//						try {
+//							Run.ecritureNodeEnXML(ana, "nodana"+ana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"),commandes.path,Run.TypeFile.Analyse);
+//						} catch (IOException e) {
+//							e.printStackTrace();
+//						}
 //					}
-					//**************************************************
+//					
-					//** Ecriture des fichiers d'analyse des students **
+//					//****************************
-					//**************************************************
+//					//** Création des feedbacks **
-					if(commandes.ecritNodeAnalyse) {
+//					//****************************
-						try {
+//					if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
-							Run.ecritureNodeEnXML(ana, "nodana"+ana.retourneFirstEnfantsByName("ouverture").getAttributs().get("dossier"),commandes.path,Run.TypeFile.Analyse);
+//						if(!commandes.zipfeedback) {
-						} catch (IOException e) {
+//							//feedback(ana, verif); //classique directement dans le répertoire
-							e.printStackTrace();
+//							try {
-						}
+//								feedbacks.feedback(ana,verif, false,false);
-					}
+//							} catch (IOException e) {
-					
+//								e.printStackTrace();
-					//****************************
+//							} catch (ParseException e) {
-					//** Création des feedbacks **
+//								e.printStackTrace();
-					//****************************
+//							}
-					if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
+//						}
-						if(!commandes.zipfeedback) {
+//						if(commandes.zipfeedback) { // Dans une archive pour Moodle
-							//feedback(ana, verif); //classique directement dans le répertoire
+//							try {
-							try {
+////								a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);						
-								feedbacks.feedback(ana,verif, false,false);
+//								// Modification imposé par Moodle 4
-							} catch (IOException e) {
+//								if(commandes.fichierStudentMoodle) {
-								e.printStackTrace();
+//									a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedbackMoodle4(a.getLectDossiers().getEC().getListeFichierodt().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
-							} catch (ParseException e) {
+//								}else {
-								e.printStackTrace();
+//									String nomFichiermoodle4 = a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i)+"_"+a.getLectDossiers().getEC().getListeFichierodt().get(i);
-							}
+//									a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedbackMoodle4(nomFichiermoodle4,ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
-						}
+//								}
-						if(commandes.zipfeedback) { // Dans une archive pour Moodle
+//								
-							try {
+//							} catch (ZipException e) {
-//								a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);						
+//								e.printStackTrace();
-								// Modification imposé par Moodle 4
+//							} catch (IOException e) {
-								if(commandes.fichierStudentMoodle) {
+//								e.printStackTrace();
-									a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedbackMoodle4(a.getLectDossiers().getEC().getListeFichierodt().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
+//							} catch (ParseException e) {
-								}else {
+//								e.printStackTrace();
-									String nomFichiermoodle4 = a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i)+"_"+a.getLectDossiers().getEC().getListeFichierodt().get(i);
+//							}
-									a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedbackMoodle4(nomFichiermoodle4,ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
+//						}
-								}
+//					}
-								
+//
-							} catch (ZipException e) {
+//					//********************************************************************************
-								e.printStackTrace();
+//					//** Ajoute au node ensembleanalyse lorsque -csv file.csv ou -verifcsv file.scv **
-							} catch (IOException e) {
+//					//********************************************************************************
-								e.printStackTrace();
+//					if(commandes.ecritNoteCSV) ensembleanalyse.addNode(ana);
-							} catch (ParseException e) {
+//					
-								e.printStackTrace();
+//					//*********************************************************
-							}
+//					//** Message dans la console sur l'analyse de l'étudiant **
-						}
+//					//*********************************************************
-					}
+//					commandes.message.append(meptl.messageSystem(ana).toString());
-
+//			}
-					//********************************************************************************
-					//** Ajoute au node ensembleanalyse lorsque -csv file.csv ou -verifcsv file.scv **
-					//********************************************************************************
-					if(commandes.ecritNoteCSV) ensembleanalyse.addNode(ana);
-					
-					//*********************************************************
-					//** Message dans la console sur l'analyse de l'étudiant **
-					//*********************************************************
-					commandes.message.append(meptl.messageSystem(ana).toString());
-			}
 		}
-		
+//		
-
+//
-		
+//		
-		//*****************************************************
+//		//*****************************************************
-		//** Exportation au format CSV  si -csv ou -verifcsv **
+//		//** Exportation au format CSV  si -csv ou -verifcsv **
-		//*****************************************************
+//		//*****************************************************
-		if(commandes.ecritNoteCSV && !commandes.fourniCSV) {
+//		if(commandes.ecritNoteCSV && !commandes.fourniCSV) {
-			if(!commandes.verifHisto2)
+//			if(!commandes.verifHisto2)
-				try {
+//				try {
-					meptl.ecritureCSV(ensembleanalyse);
+//					meptl.ecritureCSV(ensembleanalyse);
-				} catch (IOException e) {
+//				} catch (IOException e) {
-					e.printStackTrace();
+//					e.printStackTrace();
-				}
+//				}
-			if(commandes.verifHisto2)
+//			if(commandes.verifHisto2)
-				try {
+//				try {
-					meptl.ecritureCSV(ensembleanalyse,verif,a,commandes.sujet.retourneFirstEnfantsByName("setting"));
+//					meptl.ecritureCSV(ensembleanalyse,verif,a,commandes.sujet.retourneFirstEnfantsByName("setting"));
-				} catch (IOException e) {
+//				} catch (IOException e) {
-					e.printStackTrace();
+//					e.printStackTrace();
-				}
+//				}
-		}
+//		}
-		
+//		
-		//***********************************************************************
+//		//***********************************************************************
-		//** Exportation au format CSV  si -csv file.csv ou -verifcsv file.csv **
+//		//** Exportation au format CSV  si -csv file.csv ou -verifcsv file.csv **
-		//***********************************************************************
+//		//***********************************************************************
-		if(commandes.ecritNoteCSV && commandes.fourniCSV) {
+//		if(commandes.ecritNoteCSV && commandes.fourniCSV) {
-			try {
+//			try {
-				meptl.ecritureCSV(ensembleanalyse,verif,a,commandes.nodeCSV, commandes.sujet.retourneFirstEnfantsByName("setting"));
+//				meptl.ecritureCSV(ensembleanalyse,verif,a,commandes.nodeCSV, commandes.sujet.retourneFirstEnfantsByName("setting"));
-			} catch (IOException e) {
+//			} catch (IOException e) {
-				e.printStackTrace();
+//				e.printStackTrace();
-			}
+//			}
-			//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
+//			//a.ecritureNodeEnXML(ensembleanalyse, "ensembleAnalyse"); //écriture du node de l'étudiant
-		}
+//		}
-		
+//		
-		//**************************************
+//		//**************************************
-		//** Mise à jour du fichier d'analyse **
+//		//** Mise à jour du fichier d'analyse **
-		//**************************************
+//		//**************************************
-		if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
+//		if(commandes.MAJFichierAnalyse||commandes.MAJnameAnalysisFile) {
-			try {
+//			try {
-				verificationFichierAnalyse_node_commandesSujet.MiseAJourFichierAnalyse();
+//				verificationFichierAnalyse_node_commandesSujet.MiseAJourFichierAnalyse();
-			} catch (CloneNotSupportedException | IOException e) {
+//			} catch (CloneNotSupportedException | IOException e) {
-				e.printStackTrace();
+//				e.printStackTrace();
-			}
+//			}
-			verificationFichierAnalyse_node_commandesSujet.messagMiseAJourFichierAnalyseAprèsAnalyse();
+//			verificationFichierAnalyse_node_commandesSujet.messagMiseAJourFichierAnalyseAprèsAnalyse();
-		}
+//		}
-		
+//		
 		txt.setContentType("text/html");
 		txt.setText(commandes.message.toString());
 		

src/evaluer/verificationHistorique.java

@@ -0,0 +1,124 @@
+package evaluer;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+
+import javax.swing.JEditorPane;
+
+import calc.commandes;
+import xml.node;
+
+public class verificationHistorique {
+
+	node verif = new node();
+	
+	/**
+	 * Vérirication des historiques
+	 * @param verification
+	 * @param a
+	 * @return le node verif
+	 * @throws ParseException 
+	 * @throws CloneNotSupportedException 
+	 */
+	public verificationHistorique(node verification, JEditorPane txt) throws ParseException, CloneNotSupportedException {
+		
+		boolean trouveCorrespondances = false;
+		
+		verif.setNameNode("verification");
+		verif.addAttributs(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.retourneAllEnfants("fichier");
+		
+		System.out.println();
+		System.out.println("***** DEBUT VERIFICATION DES HISTORIQUES DES MODIFICATION ****");
+		System.out.println();
+		
+		commandes.message.append("\n\n***** DEBUT VERIFICATION DES HISTORIQUES DES MODIFICATION ****\n");
+		
+		int nbFichier = LesFichiers.size();
+		for(int i = 0 ; i < LesFichiers.size() ; i++) {	
+			
+			node nodStudent = new node();
+			nodStudent.setNameNode("fichier");
+			nodStudent.addAttributs(LesFichiers.get(i).getAttributs());
+			
+			ArrayList<node> HitoriqueDuFichier = LesFichiers.get(i).retourneAllEnfants("table:cell-content-change");
+
+			int nombreModifications = HitoriqueDuFichier.size();
+			
+			nodStudent.getAttributs().put("nombre_modification", String.valueOf(nombreModifications));
+
+			// Affichage message
+			String nameStudent1 = LesFichiers.get(i).getAttributs().get("dossier");
+			String AffichageMessageEcran = "Analyse du fichier " + i + " / " + nbFichier +"\n" + LesFichiers.get(i).getAttributs().get("dossier") + " -  number of modifications : " + nombreModifications;
+			txt.setText(AffichageMessageEcran);
+			
+			@SuppressWarnings("unchecked")
+			ArrayList<node> LesFichiers2 = (ArrayList<node>) LesFichiers.clone();
+			LesFichiers2.remove(i);
+
+
+			// Parcours toutes les modifications dans l'historique du fichier de l'étudiants
+			// pour les comparer à tous les autres.
+			for(int j = 0 ; j < HitoriqueDuFichier.size(); j++) {
+				for(int i2 = 0 ; i2 < LesFichiers2.size(); i2++) {
+					String nameStudent2 = LesFichiers2.get(i2).getAttributs().get("dossier");
+					String AffichageMessageEcran2 = AffichageMessageEcran + "\n" + "Recherche correspondance avec " + nameStudent2;
+					txt.setText(AffichageMessageEcran2);
+					int compteurnombreCorrespondance=0;
+					boolean correspondance = false;
+					node Tempo = new node("liste_comparer");
+					ArrayList<node> HitoriqueDuFichier2 = LesFichiers2.get(i2).retourneAllEnfants("table:cell-content-change");
+					for(int j2 = 0 ; j2 <HitoriqueDuFichier2.size(); j2++ ) {
+						if(HitoriqueDuFichier.get(j).enfantsTousIdentique(HitoriqueDuFichier2.get(j2))) {
+							txt.setText(AffichageMessageEcran2 + "\n" + "TROUVE CORRESPONDANCE");
+							compteurnombreCorrespondance++;
+							correspondance=true;
+							node A = new node("C"+String.valueOf(compteurnombreCorrespondance));
+							node B = new node("student1");
+							B.addAttribut("id", nameStudent1);
+							B.addEnfant(HitoriqueDuFichier.get(j));
+							node C = new node("student2");
+							C.addAttribut("id", nameStudent2);
+							C.addEnfant(HitoriqueDuFichier2.get(j2));
+							A.addEnfant(B);
+							A.addEnfant(C);
+							Tempo.addEnfant(A);
+						}
+					}
+					if(correspondance) {
+						node NodeCorrespondance = new node("correspondance");
+						NodeCorrespondance.addAttribut("student1", nameStudent1);
+						NodeCorrespondance.addAttribut("student2", nameStudent2);
+						NodeCorrespondance.addAttribut("nombreCorrespondance", String.valueOf(compteurnombreCorrespondance));
+						NodeCorrespondance.addEnfant(Tempo);
+						verif.addEnfant(NodeCorrespondance);
+						trouveCorrespondances=true;
+					}
+				}
+			}
+			
+		}
+		if(trouveCorrespondances) {
+			String AffichageMessageEcran = 
+					"┌─────────────────────────────────────────────────┐\n"+
+					"│            TROUVE DES CORREPONDNACES            │\n"+
+					"│                ENTRE DES FICHIERS               │\n"+
+					"└─────────────────────────────────────────────────┘\n\n"+
+					"Le fichier Verif.xml se trouve dans le dossier de l'application."+
+					commandes.pathApp;
+			txt.setText(AffichageMessageEcran);
+		}
+		System.gc();   // Demande de nettoyage du GC
+	}	
+				
+	public node getVerif() {
+		return verif;
+	}
+	
+	
+	
+}

src/fenetres/evaluate.java

@@ -42,6 +42,7 @@ import actions.actOpenBaseListesEtudiants;
 import actions.actSaveEvaluation;
 import actions.actTutoriels;
 import calc.commandes;
+import evaluer.evaluerLesFichiersEtudiants;
 import net.miginfocom.swing.MigLayout;
 
 /**

src/xml/EnsembleFichiers.java

@@ -1,6 +1,8 @@
 package xml;
 
 import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class EnsembleFichiers {
 	private static ArrayList<String> ListeContentTableur = new ArrayList<String>();
@@ -8,6 +10,9 @@ public class EnsembleFichiers {
 	private static ArrayList<String> ListeNomFichierFeedBack = new ArrayList<String>();
 	private static ArrayList<String> ListeFichierods = new ArrayList<String>();
 	private static ArrayList<String> ListeObjetGraphicTableur = new ArrayList<String>();
+	private static ArrayList<String> ListeHistoriqueTableur = new ArrayList<String>();
+
+
 	public static int size=0;
 	
 	public EnsembleFichiers() {
@@ -38,7 +43,26 @@ public class EnsembleFichiers {
 	 */
 	public void AjouteEnsembleAnalyse(String NomDossier, String contentT,String fichierods, 
 		String fichierObjectgraphicTableur, String fichierFeedBack) {
+		
+		String historiques="";
+		 // Regex pour capturer tout le contenu entre <table:tracked-changes> et </table:tracked-changes>
+        String regex = "<table:tracked-changes>(.*?)</table:tracked-changes>";
+        // Compilation du pattern avec le flag DOTALL pour inclure les sauts de ligne
+        Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
+        Matcher matcher = pattern.matcher(contentT);
+    
+        if (matcher.find()) {
+            // Capture du texte compris entre les balises
+            String capturedText = matcher.group(1);
+            historiques = historiques + capturedText;
+            System.out.println("Texte capturé : " + capturedText);
+        }
+        historiques = "<table:tracked-changes>"+historiques+"</table:tracked-changes>";
+        
+        contentT = contentT.replaceAll(Pattern.quote(historiques), "");
+        
 		ListeContentTableur.add(contentT);
+		ListeHistoriqueTableur.add(historiques);
 		ListeNomDossier.add(NomDossier);
 		ListeObjetGraphicTableur.add(fichierObjectgraphicTableur);
 		ListeFichierods.add(fichierods);
@@ -47,16 +71,16 @@ public class EnsembleFichiers {
 	}
 
 
-	public ArrayList<String> getListeNomDossier() {
+	public static ArrayList<String> getListeNomDossier() {
 		return ListeNomDossier;
 	}
 
-	public ArrayList<String> getListeFichierods() {
+	public static ArrayList<String> getListeFichierods() {
 		return ListeFichierods;
 	}
 
 
-	public int getSize() {
+	public static int getSize() {
 		return EnsembleFichiers.size;
 	}
 
@@ -74,7 +98,7 @@ public class EnsembleFichiers {
 		EnsembleFichiers.size = size;
 	}
 
-	public ArrayList<String> getListeObjetGraphicTableur() {
+	public static ArrayList<String> getListeObjetGraphicTableur() {
 		return ListeObjetGraphicTableur;
 	}
 
@@ -82,7 +106,7 @@ public class EnsembleFichiers {
 		ListeObjetGraphicTableur = listeObjetGraphicTableur;
 	}
 
-	public ArrayList<String> getListeNomFichierFeedBack() {
+	public static ArrayList<String> getListeNomFichierFeedBack() {
 		return ListeNomFichierFeedBack;
 	}
 
@@ -90,9 +114,12 @@ public class EnsembleFichiers {
 		ListeNomFichierFeedBack = listeNomFichierFeedBack;
 	}
 
-	public ArrayList<String> getListeContentTableur() {
+	public static ArrayList<String> getListeContentTableur() {
 		return ListeContentTableur;
 	}
 
+	public static ArrayList<String> getListeHistoriqueTableur() {
+		return ListeHistoriqueTableur;
+	}
 
 }

src/xml/LecturesDossiers.java

@@ -69,11 +69,12 @@ public class LecturesDossiers {
 										ContentT = ContenuContent(fichiers2[j]);
 										fichierAnalyseods = fichiers2[j].getName();
 										ContentObjectGraphicTableur	= ContenuContentObject(fichiers2[j]);
-										fichierAnalyseods = fichiers2[j].getName(); }
+										}
 								}
 							}
 							if(NomDossier==null) {NomDossier="inconnu"; filename="inconnu";}
 							if(fichierAnalyseods==null) fichierAnalyseods="pas de fichier calc déposé.";
+							if(ContentT==null) fichierAnalyseods="pas de fichier calc déposé.";
 
 						
 							if(fichierAnalyseods!=null) {
@@ -81,13 +82,17 @@ public class LecturesDossiers {
 								node nod = transformeXLMtoNode.getNodeRoot();
 								fichierAnalyseods = nod.ecritureXML().toString();
 								
-								new transformeXLMtoNode(ContentObjectGraphicTableur,false,null);
+								if(ContentObjectGraphicTableur!=null) {
-								nod = transformeXLMtoNode.getNodeRoot();
+									// ContentObjectGraphicTableur="<Object num=\"0\" vide=\"true\"</Object>";
-								ContentObjectGraphicTableur = nod.ecritureXML().toString();
+									new transformeXLMtoNode(ContentObjectGraphicTableur,false,null);
+									nod = transformeXLMtoNode.getNodeRoot();
+									ContentObjectGraphicTableur = nod.ecritureXML().toString();
+								}
+								
 							}
 							
 							EC.AjouteEnsembleAnalyse(NomDossier, ContentT, fichierAnalyseods,ContentObjectGraphicTableur,filename );
-							System.out.print(".");	
+							System.out.println(fichierAnalyseods);	
 					}
 				}
 

src/xml/node.java

@@ -1,6 +1,5 @@
 package xml;
 
-
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -8,11 +7,11 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Objects;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -47,7 +46,6 @@ private boolean nodeClose = false;
 		parent.addEnfant(this);
 	}
 
-	
 	public boolean isNodeClose() {
 		return nodeClose;
 	}
@@ -104,19 +102,24 @@ private boolean nodeClose = false;
 	public void addNewEnfant(String nameNewEnfant) {
 		node newEnfant = new node(nameNewEnfant);
 		newEnfant.setParent(this);
+		newEnfant.setLevel(this.level+1);
 		this.enfants.add(newEnfant);
-		this.recalculLevel();
+		//this.recalculLevel();
 	}
 
 	public void addEnfant(node enfant) {
 		enfant.setParent(this);
+		enfant.setLevel(this.level+1);
 		this.enfants.add(enfant);
-		this.recalculLevel();
+//		this.recalculLevel();
 	}
 		
 	public void addAllEnfants(ArrayList<node> enfants) {
+		for(int i = 0 ; i < enfants.size();i++) {
+			enfants.get(i).setLevel(this.level+1);
+		}
 		this.enfants.addAll(enfants);
-		this.recalculLevel();
+//		this.recalculLevel();
 	}
 	
 	public void removeEnfant(node enfant) {
@@ -304,7 +307,7 @@ private boolean nodeClose = false;
 		return attributs.size();
 	}
 	
-	public HashMap<String, String> getAttributs() {
+	public LinkedHashMap<String, String> getAttributs() {
 		return attributs;
 	}
 
@@ -660,6 +663,7 @@ private boolean nodeClose = false;
 		
 		if(this.enfants.size()>0) {
 			for(int i = 0 ; i < this.enfants.size(); i++) {
+				if(this.enfants.get(i)==null) continue;
 				sb.append(this.enfants.get(i).ecritureXML());
 				if((indexMaxContenu-indexContenu)>0) {
 					if(this.contenu.size()>indexContenu) {
@@ -766,6 +770,55 @@ private boolean nodeClose = false;
 		}
 	}
 	
+	/**
+	 * Cette méthode permet de vérifier si deux nodes sont identiques.<br>
+	 * Retourne TRUE s'ils sont identiques, dans le cas contraire retourne FALSE.
+	 * @param nodAVerifier
+	 * @return
+	 */
+	public boolean identique(node nodAComparer) {
+		if(!this.nameNode.equals(nodAComparer.getNameNode())) return false;
+		if(this.getNbrEnfants()!=nodAComparer.getNbrEnfants()) return false;
+		if(this.getNbrAttributs()!=nodAComparer.getNbrAttributs()) return false;
+		if(!this.getContenu().equals(nodAComparer.getContenu())) return false;
+		
+		Set<String> keys =  this.getAttributs().keySet();
+		for (String key : keys) {
+			 String valeur1 = this.getAttributs().get(key);
+			 String valeur2 = nodAComparer.getAttributs().get(key);
+			 if(!valeur1.equals(valeur2)) return false;
+		}
+
+		
+		for(int i = 0 ; i <this.getEnfants().size();i++) {
+			if(!this.getEnfant(i).identique(nodAComparer.getEnfant(i))) return false;
+		}
+		
+		return true;
+	}
+	
+	
+	/**
+	 * Compare tous les nodes enfants. Cette méthode doit être utilisée pour comparer les historique de modifications.<br>
+	 * Le node <table:previous> n'est pas comparé.<br>
+	 * Retourne TRUE si tous les nodes enfants sont identiques.<br>
+	 * Retourne FALSE dans le cas ou un seul n'est pas identique.
+	 * @param nodAComparer
+	 * @return
+	 */
+	public boolean enfantsTousIdentique(node nodAComparer) {
+		
+		if(this.getNbrEnfants()!=nodAComparer.getNbrEnfants()) return false;
+		
+		for (int i = 0 ; i < this.enfants.size();i++) {
+			if(this.getEnfant(i).getNameNode().equals("table:previous")) continue;
+			if(!this.getEnfant(i).identique(nodAComparer.getEnfant(i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
 	/**
 	 * Insère l'attribut saut.
 	 * @param value : valeur logique du saut.
@@ -824,6 +877,7 @@ private boolean nodeClose = false;
 
 	/**
 	 * Ecriture d'un node dans un fichier au format XML.<br>
+	 * Le fichier doit existé.
 	 * 
 	 * @param nod Le node à écrire dans un fichier.
 	 * @param filename Le nom du fichier.
@@ -833,13 +887,42 @@ private boolean nodeClose = false;
 	 * @return Erreur True ou False
 	 */
 		public boolean saveNodeEnXML(String filenameWithExtension, String pathDestination) {
-		if(filenameWithExtension.contains(".xml")) {
+			if(filenameWithExtension.contains(".xml")) {
-			filenameWithExtension = filenameWithExtension.substring(0,filenameWithExtension.lastIndexOf(".xml"));
+				filenameWithExtension = filenameWithExtension.substring(0,filenameWithExtension.lastIndexOf(".xml"));
+			}
+				
+			Path outputFilePath = Paths.get(pathDestination +"/"+ filenameWithExtension + ".xml");
+			
+			if(Files.isWritable(outputFilePath)){
+				try {
+					BufferedWriter  fichier = Files.newBufferedWriter(outputFilePath, StandardCharsets.UTF_8);
+					fichier.write(this.ecritureXML().toString());
+					fichier.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+					return false;
+				}
+			}else {
+				return false;
+			}
+			return true;
 		}
 		
-		Path outputFilePath = Paths.get(pathDestination +"/"+ filenameWithExtension + ".xml");
+		/**
+		 * Ecriture d'un node dans un fichier au format XML.<br>
+		 * Dans un nouveau fichier.
+	 	*  
+		 * @param filenameWithExtension
+		 * @param pathDestination
+		 * @return
+		 */
+		public boolean saveNodeEnXMLinNewFile(String filenameWithExtension, String pathDestination) {
+			if(filenameWithExtension.contains(".xml")) {
+				filenameWithExtension = filenameWithExtension.substring(0,filenameWithExtension.lastIndexOf(".xml"));
+			}
+				
+			Path outputFilePath = Paths.get(pathDestination +"/"+ filenameWithExtension + ".xml");
 			
-		if(Files.isWritable(outputFilePath)){
 			try {
 				BufferedWriter  fichier = Files.newBufferedWriter(outputFilePath, StandardCharsets.UTF_8);
 				fichier.write(this.ecritureXML().toString());
@@ -848,11 +931,10 @@ private boolean nodeClose = false;
 				e.printStackTrace();
 				return false;
 			}
-		}else {
+			
-			return false;
+			return true;
 		}
-		return true;
+		
-	}
 	
 		/**
 		 * Insère l'attribut addmenu avec la valeur logique.