correction consultation définition

api.js

@@ -3,7 +3,6 @@ console.log("api.js chargé correctement");
 // Fonction pour récupérer les lexiques (personnels) de l'utilisateur
 async function getUserLexicons(authToken) {
   const lexiconsApiUrl = 'https://babalex.lezinter.net/api/user/lexicons';
-
   try {
     const response = await fetch(lexiconsApiUrl, {
       method: 'GET',
@@ -24,7 +23,29 @@ async function getUserLexicons(authToken) {
   }
 }
 
-//TODO: ajouter l'appel API à partir de user_id ex. https://babalex.lezinter.net/api/lexicon/search?user_id=52&language=fr
+
+// Fonction pour récupérer les lexiques de l'utilisateur (ici utilisateur test)
+async function getLexicons(authToken, userId = 52, language = 'fr') {
+  const lexiconsApiUrl = `https://babalex.lezinter.net/api/lexicon/search?user_id=${userId}&language=${language}`;
+  try {
+    const response = await fetch(lexiconsApiUrl, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Erreur lors de la récupération des lexiques : ${response.statusText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    console.error('Erreur lors de la récupération des lexiques :', error);
+    throw error;
+  }
+}
+
 
 // Fonction pour récupérer les entrées d'un lexique donné (simple liste des mots)
 async function getLexiconEntries(authToken, idLexicon) {
@@ -58,7 +79,6 @@ async function getLexiconEntries(authToken, idLexicon) {
 }
 
 
-
 // Fonction pour récupérer les graphies et leurs ID
 async function getLexiconEntriesID(authToken, idLexicon) {
   const entriesApiUrl = `https://babalex.lezinter.net/api/lexicon/entries/${idLexicon}`;
@@ -108,6 +128,7 @@ async function getGraphyInfo(authToken, word) {
   }
 }
 
+
 // Fonction pour obtenir les informations sur un mot par son ID
 async function getDefinition(authToken, entryId) {
   const entryInfoApiUrl = `https://babalex.lezinter.net/api/entry/get/${entryId}`;
@@ -134,6 +155,7 @@ async function getDefinition(authToken, entryId) {
   }
 }
 
+
 // Fonction pour obtenir une définition depuis le Wiktionnaire
 async function getWiktionaryDefinition(authToken, word) {
   // Construire l'URL de l'API avec le mot sélectionné

menu_contextuel/context_menu.js

@@ -12,99 +12,78 @@ readTokenFile()
     console.error('Erreur lors du chargement du token :', error);
   });
 
-// Création de la zone blanche
+// Fonction pour créer le menu contextuel
 // TODO : BOUTONS A REMPLACER AVEC UN PICTOGRAMME-------------------------------------------------------------------------//
-// TODO : VERIFIER SI L'UTILISATEUR EST CONNECTÉ ET AFFICHER LES BOUTONS POSSIBLES ex. lexiques perso / utilisateurs-----//
-// TODO : PRENDRE EN COMPTE LES LEXIQUES DE GROUPE -----//
 function createWhiteBox() {
   const whiteBox = document.createElement('div');
   whiteBox.id = 'whiteBox';
   whiteBox.style.display = 'none'; // Cachée par défaut
   whiteBox.innerHTML = 
-
-  //searchLexiconButton  marche uniquement pour le lexique utilisateur avec api/user/lexicons
-  //returnLexicon marche uniquement pour l'utilisateur n°52 (compte de test) avec api/lexicon/search?user_id=52&language=fr
-  //getDefinitionButton
-  //getDefinitionWikiButton
-
   `
     <p id="selectedWord">Mot sélectionné</p>
     <input id="searchLexiconButton" type="button" class="searchButton" value="Vérifier si le mot est dans le lexique personnel" />
     <input id="checkLexiconButton" type="button" class="searchButton" value="Afficher dans quels lexiques le mot est présent" />
     <input id="getDefinitionButton" type="button" class="searchButton" value="Obtenir une définition à partir de mes lexiques" />
     <input id="getDefinitionWikiButton" type="button" class="searchButton" value="Rechercher une définition sur le Wiktionnaire" />
-
   `;
   document.body.appendChild(whiteBox);
-
-  // Ajouter un événement pour cacher la zone si on clique en dehors
+  
+  // Évènement pour cacher la zone si on clique en dehors
   document.addEventListener('click', (event) => {
     if (!whiteBox.contains(event.target)) {
       whiteBox.style.display = 'none'; // Cacher la zone
     }
   });
-
   return whiteBox;
 }
 
-// Initialiser la zone blanche
+// Créer le menu contextuel
 const whiteBox = createWhiteBox();
 
-//TODO : gérer les évènement en background script -------------------------------------------------------------------------//
-// Gérer la sélection de texte et le clic droit
+//TODO : gérer les évènements en background script -------------------------------------------------------------------------//
+//Écoute des évènements du menu contextuel
 document.addEventListener('contextmenu', (event) => {
-  event.preventDefault(); // Empêcher le menu contextuel par défaut
+  event.preventDefault(); // Cacher le menu contextuel par défaut
 
-  const selectedText = window.getSelection().toString().trim();
 
-  // SI on a du texte sélectionné, on modifie le contenu et affiche le bouton de recherche dans le lexique
+  // Sélection de texte
+  const selectedText = window.getSelection().toString().trim();
+  // Si on sélectionne du texte, on l'affiche dans la barre latérale et dans le menu contextuel
   if (selectedText) {
     console.log('Texte sélectionné :', selectedText);
-
     // Envoyer le mot sélectionné à la barre latérale
     browser.runtime.sendMessage({
       action: "mot_selectionne",
       mot: selectedText
     });
-    
-
-    // Mettre à jour le texte affiché dans la zone blanche
+    // Mise à jour du texte affiché dans la zone blanche
     const selectedWordElement = document.getElementById('selectedWord');
     if (selectedWordElement) {
       selectedWordElement.textContent = selectedText;
     }
-
     // Positionner la zone blanche à l'endroit du clic
     whiteBox.style.left = `${event.pageX}px`;
     whiteBox.style.top = `${event.pageY}px`;
-    whiteBox.style.display = 'block'; // Afficher la zone
+    whiteBox.style.display = 'block';
 
 
-
-    // Bouton de recherche dans le lexique perso
-    // Ne marche que pour la langue française
+    // Bouton de recherche dans le lexique perso (ne marche que pour la langue française)
     const searchLexiconButton = document.getElementById('searchLexiconButton');
-
     searchLexiconButton.onclick = async () => {
       console.log('Recherche du mot dans le lexique :', selectedText);
-
       try {
         const lexicons = await getUserLexicons(authToken);
         console.log('Lexiques (personnels) de l’utilisateur :', lexicons);
-
         // TODO: intégrer la variable lang
         const frenchLexicon = lexicons.find((lexicon) => lexicon.language === 'fr');
         if (!frenchLexicon) {
           alert('Aucun lexique pour la langue française trouvé.');
           return;
         }
-
         const idLexicon = frenchLexicon.id;
         console.log('ID du lexique français :', idLexicon);
-
         const entries = await getLexiconEntriesID(authToken, idLexicon);
         console.log('Graphies et ID dans le lexique français :', entries);
-
         const isWordPresent = entries.some((entry) => entry.graphy.toLowerCase() === selectedText.toLowerCase());        if (isWordPresent) {
           alert(`Mot présent dans le lexique personnel français n°"${idLexicon}": "${selectedText}"`);
         } else {
@@ -116,44 +95,28 @@ document.addEventListener('contextmenu', (event) => {
     };
 
 
-
     // Bouton pour afficher dans quels lexiques le mot est présent
     const checkLexiconButton = document.getElementById('checkLexiconButton');
     checkLexiconButton.onclick = async () => {
       console.log('Vérification dans quels lexiques le mot est présent :', selectedText);
-
       try {
-        // Récupérer les lexiques de l'utilisateur du compte de test (id = 52)
-        const lexiconsApiUrl = 'https://babalex.lezinter.net/api/lexicon/search?user_id=52&language=fr';
-        const response = await fetch(lexiconsApiUrl, {
-          method: 'GET',
-          headers: {
-            Authorization: `Bearer ${authToken}`,
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (!response.ok) {
-          throw new Error(`Erreur lors de la récupération des lexiques : ${response.statusText}`);
-        }
-        
         // Récupérer les données des lexiques
-        const lexicons = await response.json();
+        const lexicons = await getLexicons(authToken);
         console.log('Lexiques récupérés pour l’utilisateur 52 :', lexicons);
-
         const results = [];
-        
-        // On parcours les lexiques de l'utilisateur pour vérifier si le mot y est présent
+        // On parcourt les lexiques de l'utilisateur pour vérifier si le mot y est présent
         for (const lexicon of lexicons) {
-          //getLexiconEntriesID pour récupérer les détails des mots du lexique
+          // Récupérer les détails des mots du lexique
           const lexiconEntries = await getLexiconEntriesID(authToken, lexicon.id);
           // Vérifier si le mot sélectionné est présent dans ce lexique
-          const isWordPresent = lexiconEntries.some((entry) => entry.graphy.toLowerCase() === selectedText.toLowerCase());
-          //Nom du lexique
-          const lexiconName = lexicon.category === 'User'
-            ? `Lexique personnel (${lexicon.user.pseudo || 'Inconnu'})`
-            : `Lexique de groupe (${lexicon.group?.name || 'Inconnu'})`;
-          
+          const isWordPresent = lexiconEntries.some(
+            (entry) => entry.graphy.toLowerCase() === selectedText.toLowerCase()
+          );
+          // Nom du lexique
+          const lexiconName =
+            lexicon.category === 'User'
+              ? `Lexique personnel (${lexicon.user.pseudo || 'Inconnu'})`
+              : `Lexique de groupe (${lexicon.group?.name || 'Inconnu'})`;
           // Ajouter les résultats pour ce lexique dans le tableau
           results.push({
             lexiconName,
@@ -161,25 +124,21 @@ document.addEventListener('contextmenu', (event) => {
             isPresent: isWordPresent,
           });
         }
-
-        //Envoi des résultats à la barre latérale
+        // Envoyer les résultats à la barre latérale
         browser.runtime.sendMessage({
           action: "mot_et_lexiques",
           mot: selectedText,
           lexiques: results,
         });
         console.log('Résultats envoyés à la barre latérale :', results);
-
         // Message contenant les résultats pour chaque lexique
         let resultMessage = `Résultats pour le mot sélectionné :\n\n`;
-
         results.forEach(({ lexiconName, lexiconId, isPresent }) => {
           resultMessage += `- Lexique : ${lexiconName}\n`;
           resultMessage += `  ID du lexique : ${lexiconId}\n`;
           resultMessage += `  Statut : ${isPresent ? 'Mot présent dans ce lexique' : 'Mot non présent dans ce lexique'}\n\n`;
         });
-
-        // Résultats
+        // Affichage des résultats
         alert(`Résultats pour "${selectedText}" :\n\n${resultMessage}`);
       } catch (error) {
         console.error('Erreur lors de la vérification des lexiques :', error);
@@ -187,147 +146,103 @@ document.addEventListener('contextmenu', (event) => {
       }
     };
 
-    // Bouton pour rechercher une définition sur le Wiktionnaire
-    const getDefinitionWikiButton = document.getElementById('getDefinitionWikiButton');
-    getDefinitionWikiButton.onclick = async () => {
-      console.log('Recherche sur le Wiktionnaire pour :', selectedText);
-
-      try {
-        // On effectue une requête sur le Wiktionnaire
-        const wiktionaryDefinitions = await getWiktionaryDefinition(authToken, selectedText);
-
-        // On affiche uniquement le résultat brut retourné par l'API dans la console
-        console.log('Résultat brut de la recherche Wiktionnaire :', wiktionaryDefinitions);
-      } catch (error) {
-        console.error('Erreur lors de la recherche sur le Wiktionnaire :', error);
-      }
-    };
 
     // Bouton pour obtenir une définition issu des lexiques de l'utilisateur spécifique (ici compte test, user_id = 52)
-    const getDefinitionButton = document.getElementById('getDefinitionButton');
+    const getDefinitionButton = document.getElementById("getDefinitionButton");
     getDefinitionButton.onclick = async () => {
-      console.log('Recherche des informations détaillées sur le mot :', selectedText);
-
+      console.log("Recherche des informations détaillées sur le mot :", selectedText);
       try {
-        // Récupérer les lexiques pour trouver le mot sélectionné
-        const lexiconsApiUrl = 'https://babalex.lezinter.net/api/lexicon/search?user_id=52&language=fr';
-        const response = await fetch(lexiconsApiUrl, {
-          method: 'GET',
-          headers: {
-            Authorization: `Bearer ${authToken}`,
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (!response.ok) {
-          throw new Error(`Erreur lors de la récupération des lexiques : ${response.statusText}`);
-        }
-
-        const lexicons = await response.json();
-        console.log('Lexiques récupérés pour l’utilisateur 52 :', lexicons); // Log de l'API des lexiques
-
-        let foundLexicons = []; // Stocke les noms et IDs des lexiques où le mot a été trouvé
-        let allDefinitions = null; // Stocke les définitions communes
+        // Récupérer les lexiques de l'utilisateur
+        const lexicons = await getLexicons(authToken);
+        console.log("Lexiques récupérés pour l'utilisateur 52 :", lexicons);
 
-        // On parcourt tous les lexiques pour rechercher le mot sélectionné
+        let message = ""; // Contiendra le message pour la console et l'alerte
+        // Parcourir les lexiques pour rechercher les définitions
         for (const lexicon of lexicons) {
           const lexiconEntries = await getLexiconEntriesID(authToken, lexicon.id);
-          const entry = lexiconEntries.find((entry) => entry.graphy.toLowerCase() === selectedText.toLowerCase());
-
+          const entry = lexiconEntries.find(
+            (entry) => entry.graphy.toLowerCase() === selectedText.toLowerCase()
+          );
           if (entry) {
-            console.log(`Mot trouvé dans le lexique ID ${lexicon.id} avec l'ID d'entrée : ${entry.id}`);
             const entryInfo = await getDefinition(authToken, entry.id);
-
-            console.log(`Informations pour le lexique "${lexicon.category}" (ID ${lexicon.id}) :`, entryInfo);
-
             const definitions = extractDefinitions(entryInfo);
-
-            if (allDefinitions === null) {
-              allDefinitions = definitions; // Initialisation avec les premières définitions trouvées
-            } else if (!compareDefinitions(allDefinitions, definitions)) {
-              console.warn('Les définitions ne sont pas identiques entre les lexiques.'); // Alerte en cas de divergence
-              break; // Arrêt si les définitions diffèrent
-            }
-
-            // Ajouter le lexique à la liste des lexiques trouvés
-            foundLexicons.push({
-              lexiconName: lexicon.category === 'User'
-                ? `Lexique personnel (${lexicon.user.pseudo || 'Inconnu'})`
-                : `Lexique de groupe (${lexicon.group?.name || 'Inconnu'})`,
-              lexiconId: lexicon.id,
+            // Ajouter les résultats au message
+            message += `\n--- Lexique "${lexicon.category === "User" 
+              ? `Lexique personnel (${lexicon.user.pseudo || "Inconnu"})`
+              : `Lexique de groupe (${lexicon.group?.name || "Inconnu"})`
+            }" (ID ${lexicon.id}) ---\n\n`;
+            definitions.forEach(({ id, partOfSpeech, definitions }) => {
+              message += `id: "${id}" (${partOfSpeech})\n`;
+              definitions.forEach((definition, index) => {
+                message += `    - Définition ${index + 1}: "${definition.definition}"\n`;
+              });
+              message += "\n";
             });
           }
         }
-
-        // Résultats
-        if (foundLexicons.length > 0 && allDefinitions) {
-          console.log('Définitions issues des lexiques dans lesquels le mot est présent :');
-          foundLexicons.forEach(({ lexiconName, lexiconId }) => {
-            console.log(`--- Lexique "${lexiconName}" (ID ${lexiconId}) ---`);
-          });
-
-          console.log('--- Définitions : ---');
-          allDefinitions.forEach(({ id, definition }) => {
-            console.log(`ID : ${id}, Définition : ${definition}`);
-          });
-          // Construire le message pour l'alerte
-          let alertMessage = `Définitions issues des lexiques dans lesquels le mot "${selectedText}" est présent :\n\n`;
-          foundLexicons.forEach(({ lexiconName, lexiconId }) => {
-            alertMessage += `--- Lexique "${lexiconName}" (ID ${lexiconId}) ---\n`;
-          });
-          alertMessage += '\n--- Définitions : ---\n';
-          allDefinitions.forEach(({ id, definition }) => {
-            alertMessage += `ID : ${id}\nDéfinition : ${definition}\n\n`;
-          });
-    
-          alert(alertMessage);
-
+        // Afficher les résultats
+        if (message.trim()) {
+          console.log(message);
+          alert(message);
         } else {
-          const noResultsMessage = `Le mot "${selectedText}" n'a pas été trouvé dans les lexiques ou aucune définition valide n'a été trouvée.`;
+          const noResultsMessage = `Le mot "${selectedText}" n'a pas été trouvé dans les lexiques.`;
           console.log(noResultsMessage);
           alert(noResultsMessage);
         }
       } catch (error) {
-        console.error('Erreur lors de la recherche des informations sur le mot :', error);
-        alert('Une erreur est survenue lors de la recherche des informations sur le mot.');
+        console.error("Erreur lors de la recherche des informations sur le mot :", error);
+        alert("Une erreur est survenue lors de la recherche des informations sur le mot.");
       }
     };
+    
 
-    // Fonction pour extraire les définitions à partir de la réponse API
-    function extractDefinitions(entryInfo) {
-      // Vérifier si l'objet entryInfo est valide et contient les informations nécessaires
-      if (!entryInfo || !entryInfo.attributes || !entryInfo.attributes.Items) {
-        console.warn('Structure des données inattendue ou vide.');
-        return [];
+  function extractDefinitions(entryInfo) {
+    if (!entryInfo || !entryInfo.attributes || !entryInfo.attributes.Items) {
+      console.warn("Structure des données inattendue ou vide.");
+      return [];
+    }
+    const items = entryInfo.attributes.Items;
+    // Vérifie si Items est un objet et le convertit en tableau si nécessaire
+    const itemsArray = Array.isArray(items) ? items : Object.values(items);
+    const results = [];
+    itemsArray.forEach((item) => {
+      const partOfSpeech = item.PartOfSpeech || "Non spécifié";
+      const itemId = item.id || "ID non disponible";
+      if (item.Sense && Array.isArray(item.Sense.Definitions)) {
+        const definitions = item.Sense.Definitions.map((def, index) => ({
+          id: def.id || `Définition ${index + 1}`,
+          definition: def.Def || "Définition non disponible",
+        }));
+        results.push({
+          id: itemId,
+          partOfSpeech,
+          definitions,
+        });
       }
-      const definitions = [];
-      // Parcourir les éléments de l'entrée
-      entryInfo.attributes.Items.forEach((item) => {
-        if (item.Sense && Array.isArray(item.Sense.Definitions)) {
-          item.Sense.Definitions.forEach((def) => {
-            definitions.push({
-              id: def.id || 'ID non disponible',
-              definition: def.Def || 'Définition non disponible',
-            });
-          });
-        }
-      });
+    });
+    console.log("réponse: ", results);
+    return results;
+  }
 
-      return definitions;
-    }
 
-    // Fonction pour comparer deux ensembles de définitions
-    function compareDefinitions(definitions1, definitions2) {
-      if (definitions1.length !== definitions2.length) return false;
+    // Bouton pour rechercher une définition sur le Wiktionnaire
+    const getDefinitionWikiButton = document.getElementById('getDefinitionWikiButton');
+    getDefinitionWikiButton.onclick = async () => {
+      console.log('Recherche sur le Wiktionnaire pour :', selectedText);
+      try {
+        // On effectue une requête sur le Wiktionnaire
+        const wiktionaryDefinitions = await getWiktionaryDefinition(authToken, selectedText);
 
-      return definitions1.every((def1, index) => {
-        const def2 = definitions2[index];
-        return def1.id === def2.id && def1.definition === def2.definition;
-      });
-    }
+        // On affiche uniquement le résultat brut retourné par l'API dans la console
+        console.log('Résultat brut de la recherche Wiktionnaire :', wiktionaryDefinitions);
+      } catch (error) {
+        console.error('Erreur lors de la recherche sur le Wiktionnaire :', error);
+      }
+    };
+  
 
+    // Si aucun texte n'est sélectionné, on cache la zone
     } else {
-    whiteBox.style.display = 'none'; // Si aucun texte n'est sélectionné, on cache la zone
-    }
-    });
+    whiteBox.style.display = 'none'; 
+    }});