pablo/analyseCalc
pablo/analyseCalc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

maj

Browse Source
This commit is contained in:
pablo rodriguez 2024-12-15 19:09:09 +01:00
parent 17ba45798b
commit f6a3af9dd7
23 changed files with 286 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ana.xml
View File

File diff suppressed because one or more lines are too long

2
base_evaluations_analyseCalc.xml
View File

File diff suppressed because one or more lines are too long

BIN
bin/AnalyseCalc/Classeur2$feuille$colonne.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2$feuille$graphic.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2$feuille$ligne$cellule$validation.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2$feuille$ligne$cellule.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2$feuille$ligne.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2$feuille.class
View File

Binary file not shown.

BIN
bin/AnalyseCalc/Classeur2.class
View File

Binary file not shown.

BIN
bin/actions/actAttribut.class
View File

Binary file not shown.

BIN
bin/calc/commandes.class
View File

Binary file not shown.

BIN
bin/outils/outils.class
View File

Binary file not shown.

2
nodStudent.xml
View File

File diff suppressed because one or more lines are too long

7
src/AnalyseCalc/Classeur2.java
View File

@ -701,6 +701,7 @@ public class Classeur2 {
//lignes chargement sujet
nods= fe.retourneAllEnfants("ligne");
for(int i=0 ; i < nods.size();i++) {
if(i>commandes.analysis_nbr_Ligne_maxi) break;
lignes.put(i, new ligne(nods.get(i), nods.get(i).getAttributs().get("RefLigne")));
}
@ -1224,8 +1225,6 @@ public class Classeur2 {
private TreeMap<String,String> series = new TreeMap<String,String>();
public graphic(node nodeGraphic ) {
//chargement sujet
if(nodeGraphic.getAttributs().get("nomObjet")!=null) nomObjet = nodeGraphic.getAttributs().get("nomObjet");
@ -1427,9 +1426,7 @@ public class Classeur2 {
}
}
/********
*
*/
//** Uniquement pour le chargement **
public void ajouteProperties(node nodeGraphic) {
node b = nodeGraphic.retourneFirstEnfant("chart:chart");

4
src/actions/actAttribut.java
View File

@ -45,10 +45,10 @@ public class actAttribut extends AbstractAction{
if(nod.getLevel()>1 && !nod.getAllNameParents().contains("settings")) {
new attributs(nod,fenetres.create.getTextNodeSelect());
}else {
JOptionPane.showMessageDialog(null, "Vous ne pouvez pas modifier directement les attributs de ce nodeAC." );
JOptionPane.showMessageDialog(null, "Vous ne pouvez pas modifier directement les attributs de ce node." );
}
}else {
JOptionPane.showMessageDialog(null, "Ce nodeAC ne contient pas d'attribut de Calc.");
JOptionPane.showMessageDialog(null, "Ce node ne contient pas d'attribut de Calc.");
}
}

8
src/calc/commandes.java
View File

@ -160,6 +160,7 @@ public class commandes {
public static boolean analyse_controleDateModificationMini = false;
public static double analyse_notefrom=20;
public static Date analyse_modificationDateMini = null;
public static int analysis_nbr_Ligne_maxi = 100;
@ -210,10 +211,10 @@ public class commandes {
analyse_controleDateCreation=false;
analyse_controle_Initial_Creator=false;
analyse_baremeABC=false;
analyse_progression=1;
analyse_bareme=20;
analyse_progression=1;
analyse_bareme=20;
analyse_tolerance_characters = 5;
analyse_tolerance_text = 0.79;
analyse_tolerance_text = 0.79;
analyse_number_match = 2;
analyse_mini_number_modification = 0;
analyse_nombres_modifications_simultané_maxi = 100;
@ -226,6 +227,7 @@ public class commandes {
analysis_filename = "";
analysis_nbr_feuilles = 0;
analysis_producteur = "";
analysis_nbr_Ligne_maxi = 100;
//** Variables pour l'interface du logiciel

21
src/evaluer/crearNodeAna.java
View File

@ -12,6 +12,8 @@ import xml.node;
public class crearNodeAna {
node ana = new node("analyse");
int nbrPointTotal = 0;
int pointGagner = 0;
/**
* Création du node analyse.<br>
@ -27,14 +29,27 @@ public class crearNodeAna {
}
}
/**
* Obtient le node analyse de la class cearNodeAna.<br>
* @return
*/
public node getAna() {
return ana;
}
public void setAna(node ana) {
this.ana = ana;
/**
* Calcul le total des points de l'étudiants.<br>
* Ajoute les attributs nbrPointTotal et pointGagner.<br>
*/
public void getAllResultat() {
for (node enfant : ana.retourneAllEnfants("resultat")) {
nbrPointTotal = nbrPointTotal + Integer.valueOf(enfant.getAttributs().get("total"));
pointGagner = pointGagner + Integer.valueOf(enfant.getAttributs().get("point"));
}
ana.getAttributs().put("nbrPointTotal", String.valueOf(nbrPointTotal));
ana.getAttributs().put("pointGagner", String.valueOf(pointGagner));
}
}

58
src/evaluer/evaluerAttributs.java
View File

@ -12,7 +12,7 @@ public class evaluerAttributs {
/**
* Evaluer les attributs des nodes.<br>
* @param nodeSujet : le node du sujet (colonne, ligne)
* @param nodeSujet : le node du sujet (colonne, ligne, graphic)
* @param nodeEtudiant : le node de l'étudiant.
* @param analyse : le node analyse qui contiendra les résultats.
*/
@ -23,7 +23,11 @@ public class evaluerAttributs {
if(nodeSujet.getNameNode().equals("colonne")) evaluerAttributColonne();
if(nodeSujet.getNameNode().equals("ligne")) {
evaluerAttributLigne();
evaluerAttributCellule(nodeSujet);
evaluerAttributCellule();
}
if(nodeSujet.getNameNode().equals("graphic")) {
evaluerAttributGraphic();
evaluerLesNodesEnfantsGraphic();
}
}
@ -31,7 +35,7 @@ public class evaluerAttributs {
* Evaluer les attributs du node colonne.<br>
*/
private void evaluerAttributColonne() {
nAnalyse.retourneLastEnfant("feuille").addEnfant(new node("colonne", nSujet, "RefColonne", nSujet.getAttributs().get("RefColonne")));
nAnalyse.retourneLastEnfant("feuille").addEnfant(new node("colonne", null, "RefColonne", nSujet.getAttributs().get("RefColonne")));
for (Map.Entry<String, String> entry : nSujet.getAttributs().entrySet()){
if(nSujet.isAttributEvaluer(entry.getKey())) {
node colonneEtudiant = trouveColonneEtudiant();
@ -44,7 +48,7 @@ public class evaluerAttributs {
* Evaluer les attributs du node ligne.<br>
*/
private void evaluerAttributLigne() {
nAnalyse.retourneLastEnfant("feuille").addEnfant(new node("ligne", nSujet, "RefLigne", nSujet.getAttributs().get("RefLigne")));
nAnalyse.retourneLastEnfant("feuille").addEnfant(new node("ligne", null, "RefLigne", nSujet.getAttributs().get("RefLigne")));
for (Map.Entry<String, String> entry : nSujet.getAttributs().entrySet()){
if(nSujet.isAttributEvaluer(entry.getKey())) {
node ligneEtudiant = trouveLigneEtudiant();
@ -56,11 +60,11 @@ public class evaluerAttributs {
/**
* Evaluer les attributs du node cellule.<br>
*/
private void evaluerAttributCellule(node ligneSujet) {
for (node cellule : ligneSujet.retourneAllEnfants("cellule")) {
private void evaluerAttributCellule() {
for (node cellule : nSujet.retourneAllEnfants("cellule")) {
if(cellule.isEvaluer()) {
node celluleEtudiant = trouveCelluleEtudiant(cellule);
nAnalyse.retourneLastEnfant("ligne").addEnfant(new node("cellule", cellule, "RefLigne", cellule.getAttributs().get("RefLigne"), "RefColonne", cellule.getAttributs().get("RefColonne")));
nAnalyse.retourneLastEnfant("ligne").addEnfant(new node("cellule", null, "RefLigne", cellule.getAttributs().get("RefLigne"), "RefColonne", cellule.getAttributs().get("RefColonne")));
for (Map.Entry<String, String> entry : cellule.getAttributs().entrySet()){
if(cellule.isAttributEvaluer(entry.getKey())) {
nAnalyse.retourneLastEnfant("cellule").addEnfant(new outils().Compare("cellule",entry.getKey(), entry.getValue(), celluleEtudiant.getAttributs().get(entry.getKey())));
@ -86,6 +90,37 @@ public class evaluerAttributs {
}
}
/**
* Evaluer les attributs du node graphic.<br>
*/
private void evaluerAttributGraphic() {
for (Map.Entry<String, String> entry : nSujet.getAttributs().entrySet()){
if(nSujet.isAttributEvaluer(entry.getKey())) {
String valeurEtudiant = "";
if(nEtudiant!=null) valeurEtudiant=nEtudiant.getAttributs().get(entry.getKey());
nAnalyse.retourneLastEnfant("graphic").addEnfant(new outils().Compare("graphic",entry.getKey(), entry.getValue(), valeurEtudiant));
}
}
}
/**
* Evaluer tous les nodes enfants du node graphic.<br>
*/
private void evaluerLesNodesEnfantsGraphic() {
for (node enfant : nSujet.getEnfants()) {
if(enfant.isEvaluer()) {
node enfantEtudiant = trouveEnfantGraphicEtudiant(enfant.getNameNode());
for (Map.Entry<String, String> entry : enfant.getAttributs().entrySet()){
if(enfant.isAttributEvaluer(entry.getKey())) {
String valeurEtudiant = "";
if(enfantEtudiant!=null) valeurEtudiant = enfantEtudiant.getAttributs().get(entry.getKey());
nAnalyse.retourneLastEnfant("graphic").addEnfant(new outils().Compare("graphic",entry.getKey(), entry.getValue(), valeurEtudiant ));
}
}
}
}
}
/**
* Trouve la colonne de l'étudiant.<br>
* @return
@ -114,6 +149,15 @@ public class evaluerAttributs {
return Tempo.retourneFirstEnfant("cellule", "RefLigne", cellule.getAttributs().get("RefLigne"), "RefColonne", cellule.getAttributs().get("RefColonne"));
}
/**
* Trouve le node enfant du node graphique.<br>
* @param nameNode
* @return
*/
private node trouveEnfantGraphicEtudiant(String nameNode) {
if(nEtudiant==null) return null;
return nEtudiant.retourneFirstEnfant(nameNode);
}

101
src/evaluer/evaluerLesFichiersEtudiants.java
View File

@ -2,7 +2,6 @@ package evaluer;
import java.io.IOException;
import java.text.ParseException;
import java.util.zip.ZipException;
import javax.swing.JEditorPane;
import javax.xml.parsers.ParserConfigurationException;
@ -18,17 +17,15 @@ import calcul.enumerations.typeFichier;
import fenetres.baliseStyle;
import xml.EnsembleFichiers;
import xml.LecturesDossiers;
import xml.ecritureFileXML;
import xml.node;
import xml.transformeXLMtoNode;
public class evaluerLesFichiersEtudiants implements Runnable{
private final JEditorPane txt;
public node tousLesResultats = new node("Tous");
public evaluerLesFichiersEtudiants(JEditorPane txt) {
commandes.analyse=true;
this.txt=txt;
this.txt.setContentType("text/plain");
@ -37,8 +34,7 @@ public class evaluerLesFichiersEtudiants implements Runnable{
@Override
public synchronized void run() {
commandes.message = new StringBuilder();
commandes.message.append(baliseStyle.balise());
commandes.message.append("<hr><h1>*** LES FICHIERS DES ETUDIANTS ANALYSÉS ET ÉVALUÉS ***</h1><hr>");
@ -94,8 +90,7 @@ public class evaluerLesFichiersEtudiants implements Runnable{
}
}
//*****************************************
//** Nombre de fichier writer à analyser **
//*****************************************
@ -174,7 +169,8 @@ public class evaluerLesFichiersEtudiants implements Runnable{
//***********************************************************
new transformeXLMtoNode(EnsembleFichiers.getListeContentTableur().get(i),false,null);
node nod = transformeXLMtoNode.getNodeRoot();
if(!nod.isHasEnfant()) continue;
Classeur2 ClasseurStudent;
try {
@ -192,25 +188,29 @@ public class evaluerLesFichiersEtudiants implements Runnable{
nodStudent.saveNodeEnXMLinNewFile("nodStudent.xml", commandes.pathApp);
if(commandes.analyse) {
node ana = new crearNodeAna(nomEtudiant, i).getAna();
crearNodeAna evaluationEtudiant = new crearNodeAna(nomEtudiant, i);
node ana = evaluationEtudiant.getAna();
new evaluerNodesClasseurStudent(ana, nodStudent);
ana.saveNodeEnXMLinNewFile("ana.xml", commandes.pathApp);
evaluationEtudiant.getAllResultat();
tousLesResultats.addEnfant(ana.clone());
}
tousLesResultats.saveNodeEnXMLinNewFile("ana.xml", commandes.pathApp);
} catch (CloneNotSupportedException | IOException e) {
e.printStackTrace();
}
}// ** Parcours l'ensemble des fichiers des étudiants ***
}// Run
}
//**********************************
//** Analyse des fichiers student **
//**********************************
if(commandes.analyse||commandes.ecritNodeAnalyse) {
// 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 {
@ -219,26 +219,26 @@ public class evaluerLesFichiersEtudiants implements Runnable{
// // TODO Auto-generated catch block
// e1.printStackTrace();
// }
//**************************************************
//** Ecriture des fichiers d'analyse des students **
//**************************************************
if(commandes.ecritNodeAnalyse) {
// //**************************************************
// //** 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();
// }
}
//****************************
//** Création des feedbacks **
//****************************
if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
if(!commandes.zipfeedback) {
//feedback(ana, verif); //classique directement dans le répertoire
// }
//
// //****************************
// //** Création des feedbacks **
// //****************************
// if(!commandes.sansFeeback&&!commandes.ecritNodeAnalyse) {
// if(!commandes.zipfeedback) {
// //feedback(ana, verif); //classique directement dans le répertoire
// try {
//// feedbacks.feedback(ana,verif, false,false);
// } catch (IOException e) {
@ -246,8 +246,8 @@ public class evaluerLesFichiersEtudiants implements Runnable{
// } catch (ParseException e) {
// e.printStackTrace();
// }
}
if(commandes.zipfeedback) { // Dans une archive pour Moodle
// }
// if(commandes.zipfeedback) { // Dans une archive pour Moodle
// try {
//// a.AddStreamToZip(feedbacks.feedback(ana, verif, true,false), meptl.retourneLeNomDuFeedback(a.getLectDossiers().getEC().getListeNomFichierFeedBack().get(i),ana, verif),commandes.analyse_size,commandes.analyse_nameZip);
// // Modification imposé par Moodle 4
@ -265,20 +265,20 @@ public class evaluerLesFichiersEtudiants implements Runnable{
// } catch (ParseException e) {
// e.printStackTrace();
// }
}
}
//********************************************************************************
//** Ajoute au node ensembleanalyse lorsque -csv file.csv ou -verifcsv file.scv **
//********************************************************************************
// }
// }
//
// ********************************************************************************
// ** 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());
}
}
// }
// }
//
//
//
@ -324,11 +324,8 @@ public class evaluerLesFichiersEtudiants implements Runnable{
// verificationFichierAnalyse_node_commandesSujet.messagMiseAJourFichierAnalyseAprèsAnalyse();
// }
//
txt.setContentType("text/html");
txt.setText(commandes.message.toString());
}
// txt.setContentType("text/html");
// txt.setText(commandes.message.toString());
//
// }
}

41
src/evaluer/evaluerNodesClasseurStudent.java
View File

@ -8,15 +8,22 @@ public class evaluerNodesClasseurStudent {
private node nAna = new node();
private node nodeEtudiant = new node();
/**
* Evaluer les fichiers des étudiants.<br>
* Commence par évaluer les feuilles (nodes colonne, lignes puis cellules).<br>
* Puis evalue le node graphic par le nomObjet="nameObject".<br>
* @param ana
* @param nodStudent
*/
public evaluerNodesClasseurStudent(node ana, node nodStudent) {
nodeEtudiant = nodStudent;
nAna = ana;
evaluerLesFeuilles();
nAna.getAttributs().put("test", "reussi");
evaluerLesGraphics();
}
/**
* Evaluer les feuilles les unes après les autres.
* Evaluer les feuilles les unes après les autres.<br>
*/
private void evaluerLesFeuilles() {
for (node feuilleSujet : commandes.sujet.retourneAllEnfants("feuille")) {
@ -30,6 +37,21 @@ public class evaluerNodesClasseurStudent {
}
}
/**
* Evaluer les graphics les uns après les autres.<br>
*/
private void evaluerLesGraphics() {
for (node graphicSujet : commandes.sujet.retourneAllEnfants("graphic")) {
if(graphicSujet.isEvaluer()) {
node graphicEtudiant = trouveLeGraphicEtudiant(graphicSujet.getAttributs().get("nomObjet"),graphicSujet.getAttributs().get("TitreGraphique"), graphicSujet.getAttributs().get("type") );
node anaGraphic = new node("graphic");
anaGraphic.getAttributs().put("nomObjet", graphicSujet.getAttributs().get("nomObjet"));
nAna.addEnfant(anaGraphic);
new evaluerAttributs(graphicSujet, graphicEtudiant , nAna);
}
}
}
/**
* Trouve la feuille de l'étudiant.<br>
* @param nomFeuille
@ -39,6 +61,19 @@ public class evaluerNodesClasseurStudent {
return nodeEtudiant.retourneFirstEnfant("feuille", "nomFeuille", nomFeuille);
}
/**
* Trouve le graphic de l'étudiant.<br>
* @param nomObjet
* @return
*/
private node trouveLeGraphicEtudiant(String nomObjet, String TitreGraphic, String type) {
node graph = nodeEtudiant.retourneFirstEnfant("graphic", "nomObjet", nomObjet);
if(graph==null) graph = nodeEtudiant.retourneFirstEnfant("graphic", "TitreGraphique", TitreGraphic);
if(graph==null) graph = nodeEtudiant.retourneFirstEnfant("graphic", "type", type);
if(graph==null) graph = nodeEtudiant.retourneFirstEnfant("graphic");
return graph;
}
/**
* Evaluer les colonnes les unes après les autres.<br>
* @param feuilleSujet
@ -66,6 +101,8 @@ public class evaluerNodesClasseurStudent {
}
}
public node getAnalyse() {
return nAna;
}

196
src/outils/outils.java
View File

@ -11,53 +11,109 @@ import xml.node;
public class outils {
// private int pointsClass = 0;
// private int pointTotal=0;
// private int pointEnJeu = 0;
/**
* Compare les String A et B.
* La String B contient le poids de la note après le symbole ‽
* Les String ne sont pas nettoyées avant comparaisons.
* Compare les String ValeurSujet et ValeurEtudiant.<br>
* La String ValeurSujet contient la note après le symbole ‽.<br>
*
* @param A : String du fichier remis
* @param B : string du fichier consigne (sujet) avec le symbole ‽ pour la notation
* @return une String contenant "Correct" , "Erreur" ou "Optionnel".
* @throws UnsupportedEncodingException
* @param nomNode : nom du node.
* @param key : nom de l'attribut.
* @param ValeurEtudiant : Valeur de l'attribut du fichier remis.
* @param ValeurSujet : Valeur de l'attribut du fichier consigne (sujet) avec le symbole ‽ pour la notation.
* @return le node resultat.
*/
public node Compare(String nomNode, String key , String ValeurSujet , String ValeurEtudiant){
if(ValeurEtudiant==null) ValeurEtudiant="";
resultatNotationParComparaison resultat = new resultatNotationParComparaison(false, false, nomNode, key, ValeurSujet, ValeurEtudiant, 0, 0);
// Recupération des points et suppression de texte ‽point.
if (ValeurSujet != null && ValeurSujet.contains("‽")) {
TraitePoint(ValeurSujet, resultat);
ValeurSujet = ValeurSujet.substring(0, ValeurSujet.indexOf("‽"));
}
// Retourne le resultat si optionnel (point = 0 par défaut).
if(resultat.isOptionnel()) {
return resultat.getResultat();
}
//intervalles de valeurs avec le symbole →
// Nettoyer les textes des caractères spéciaux et chiffre.
// Puis égalité strict entre ValeurSujet et ValeurEtudiant.
if(ValeurSujet.contains("↑")) {
ValeurSujet = nettoyerTexte(ValeurSujet);
ValeurEtudiant = nettoyerTexte(ValeurEtudiant);
return egaliteStrict(ValeurSujet,ValeurEtudiant,resultat);
}
// Intervalles de valeurs avec le symbole →
if(ValeurSujet.contains("→")) {
return Intervalle(ValeurEtudiant,ValeurSujet, resultat).getResultat();
return Intervalle(ValeurEtudiant,ValeurSujet, resultat);
}
// Egalité entre les deux valeurs
if (ValeurEtudiant.equals(ValeurSujet)) {
resultat.setCorrect(true);
resultat.setPoint(resultat.getTotal());
return resultat.getResultat();
}else {
resultat.setCorrect(false);
resultat.setPoint(0);
return resultat.getResultat();
// Contient exactement.
if(ValeurSujet.contains("¦")) {
return containsExact(ValeurSujet, ValeurEtudiant,resultat);
}
// par défaut
return egaliteStrict( ValeurSujet, ValeurEtudiant, resultat);
}
/**
* Compare les string `ValeurSujet` et `ValeurEtudiant`.<br>
* @param ValeurSujet
* @param ValeurEtudiant
* @param resultat
*/
private node egaliteStrict(String ValeurSujet, String ValeurEtudiant, resultatNotationParComparaison resultat) {
if (ValeurEtudiant.equals(ValeurSujet)) {
resultat.setCorrect(true);
resultat.setPoint(resultat.getTotal());
}else {
resultat.setCorrect(false);
resultat.setPoint(0);
}
return resultat.getResultat();
}
/**
* Vérifie si la chaîne `ValeurSujet` est contenue de manière exacte dans `value2` entre des délimiteurs `|`.<br>
*
* @param ValeurSujet La valeur à rechercher.ValeurEtudiant.
* @param ValeurEtudiant La chaîne de recherche au format.
* @return true si `ValeurSujet` est trouvé entre les `|`, false sinon.
*/
public node containsExact(String ValeurSujet, String ValeurEtudiant, resultatNotationParComparaison resultat) {
// Vérification si les deux valeurs ne sont pas nulles
if (ValeurSujet == null || ValeurEtudiant == null) {
resultat.setOptionnel(true);
resultat.setPoint(0);
resultat.setTotal(0);
throw new IllegalArgumentException("Les deux valeurs ne doivent pas être nulles.");
}
// Utilisation de split() avec le caractère ¦
String[] parties = ValeurSujet.split("¦");
for (int i = 0; i < parties.length; i++) {
System.out.println("Partie " + (i + 1) + ": " + parties[i]);
// Formater la valeur recherchée avec les séparateurs |...|
String pattern = parties[i] ;
// Vérifie si le motif exact est dans la chaîne de recherche
if( ValeurEtudiant.contains(pattern)) {
resultat.setOptionnel(false);
resultat.setCorrect(true);
resultat.setPoint(resultat.getTotal());
}
}
return resultat.getResultat();
}
/**
* Compare les String A et B.
@ -91,16 +147,11 @@ public class outils {
private resultatNotationParComparaison Intervalle(String A, String Sujet, resultatNotationParComparaison resultat) {
private node Intervalle(String A, String Sujet, resultatNotationParComparaison resultat) {
if (A == null || A.isEmpty() || Sujet == null || Sujet.isEmpty()) {
resultat.setCorrect(false);
resultat.setPoint(0);
return resultat;
return resultat.getResultat();
}
try {
@ -116,7 +167,7 @@ public class outils {
resultat.setOptionnel(true);
resultat.setPoint(0);
resultat.setTotal(0);
return resultat;
return resultat.getResultat();
}
// Nettoyer les bornes et la valeur A
@ -133,7 +184,7 @@ public class outils {
if (valueA >= lowerBound && valueA <= upperBound) {
resultat.setCorrect(true);
resultat.setPoint(resultat.getTotal());
return resultat;
return resultat.getResultat();
}
} catch (NumberFormatException e) {
String key = resultat.getDescription();
@ -142,7 +193,7 @@ public class outils {
resultat.setOptionnel(true);
resultat.setPoint(0);
resultat.setTotal(0);
return resultat;
return resultat.getResultat();
} catch (Exception e) {
}
@ -153,7 +204,7 @@ public class outils {
resultat.setOptionnel(true);
resultat.setPoint(0);
resultat.setTotal(0);
return resultat;
return resultat.getResultat();
}
@ -198,52 +249,23 @@ public class outils {
}
/**
* Tritaement des tollérance et des OU exact
* @param A
* @param Sujet
* @return
*/
private String TraitementIntervalleOUExact(String A, String Sujet) {
if(A.length()==0) {
return "Erreur : ";
}
* Supprime tous les caractères spéciaux et les chiffres d'une chaîne de texte.
* @param texte Le texte d'entrée à nettoyer.
* @return Le texte nettoyé ne contenant que des lettres (A-Z, a-z).
*/
public String nettoyerTexte(String texte) {
if (texte == null) {
return "";
}
// Remplace tous les caractères qui NE sont PAS des lettres (A-Z, a-z) par une chaîne vide
return texte.replaceAll("[^a-zA-Z]", "");
}
String TextB[] = Sujet.split("¦");
for(int i=0;i<TextB.length;i++) {
if (TextB[i].equals("null")) TextB[i]="none";
if (TextB[i].isEmpty()) TextB[i]="none";
String Text[] = TextB[i].split("→");
// rechercher un digite une ou plusieur fois en fin.
Pattern p = Pattern.compile("[^0-9\\.]");
// création du moteur associé à la regex sur la chaîne A
// Matcher m0 = p.matcher(Text[0]);
// remplacement de toutes les occurrences par ""
Text[0]= p.matcher(Text[0]).replaceAll("");
Text[1] = p.matcher(Text[1]).replaceAll("");
A = p.matcher(A).replaceAll("");
double b0 = Double.valueOf(Text[0]);
double b1 = Double.valueOf(Text[1]);
double v = 0;
try {
v = Double.valueOf(A);
}catch(Exception e) {
return "Erreur : ";
}
if(v<=b1 && v>=b0 ) return "Correct : ";
}
return "Erreur : ";
}
@ -316,18 +338,7 @@ public class outils {
if(TraitementCouleur(couleurA, couleurB).equals("Correct : ")) {
couleur =true;
}
// int Ared = Integer.parseInt(couleurA.substring(0, 2),16);
// int Agreen = Integer.parseInt(couleurA.substring(2, 4),16);
// int Ablue = Integer.parseInt(couleurA.substring(4, 6),16);
//
// int Bred = Integer.parseInt(couleurB.substring(0, 2),16);
// int Bgreen = Integer.parseInt(couleurB.substring(2, 4),16);
// int Bblue = Integer.parseInt(couleurB.substring(4, 6),16);
//
// // couleur dominante
// if(Ared>Agreen+10 && Ared>Ablue+10 && Bred>Bgreen+10 && Bred>=Bblue+10) couleur=true;
// if(Agreen>Ared+10 && Agreen>Ablue+10 && Bgreen>Bred+10 && Bgreen>Bblue+10) couleur = true;
// if(Ablue>Ared+10 && Ablue>Agreen+10 & Bblue>Bred+10 && Bblue>Bgreen+10) couleur = true;
}
if(taille && type && couleur) return "Correct : ";
@ -386,6 +397,11 @@ public class outils {
return false;
}
/**
* Traitement des conditions OU
* @param A

12
src/outils/resultatNotationParComparaison.java
View File

@ -14,7 +14,17 @@ public class resultatNotationParComparaison {
private int total; //
private node resultat = new node("resultat");
// **Constructeur**
/**
* Resultat de l'évaluation.
* @param optionnel : par defaut la valeur est false.
* @param correct : par défaut la valeur est false.
* @param nomNode : le nom du node qui contient l'attribut.
* @param description : le nom de l'attribut.
* @param valeurSujet : la valeur de l'attribut dans le sujet.
* @param valeurEtudiant : la valeur de l'attribut dans le fihcier étudiant.
* @param point : les points gagngés par l'étudiant.
* @param total : le nombre de point si correct juste.
*/
public resultatNotationParComparaison(boolean optionnel ,boolean correct, String nomNode, String description, String valeurSujet, String valeurEtudiant, int point, int total) {
this.optionnel = optionnel;
this.correct = correct;

1
src/xml/ecritureFileXML.java
View File

@ -13,7 +13,6 @@ import java.nio.file.Paths;
public class ecritureFileXML {
public static boolean write(node nodeWrite, String nameFileWithExt) {
String directoryName = Paths.get("").toAbsolutePath().toString();
File file = new File(directoryName + "\\" + nameFileWithExt) ;