Question / answer getting imporvements, code refactoring

stable.user.js

@@ -157,6 +157,9 @@
   // ----------------------------------------------------------------------------------------------
   // Result page processing functions
   // ----------------------------------------------------------------------------------------------
+
+  const uniq = a => [...new Set(a)]
+
   function getQuiz() {
     return new Promise(resolve => {
       let promises = []
@@ -176,88 +179,157 @@
       //      "type": "simple"
       //    }
       // }]
-      Promise.all(promises).then(result => {
-        console.log(result)
-        resolve(result)
-      })
+      Promise.all(promises)
+        .then(result => {
+          console.log(result)
+          resolve(result)
+        })
+        .catch(err => {
+          console.warn('Error in getQuiz()')
+          console.warn(err)
+        })
     })
   }
 
-  function getData(image) {
-    if (image) {
+  function getPromisesThatMeetsRequirements(getters, node) {
+    let res
+    Object.keys(getters).some(key => {
+      const getter = getters[key]
+      if (getter.requirement(node)) {
+        res = getter.getterFunction(node)
+        return true
+      } else {
+        Log(`${getter.description} did not pass`)
+      }
+    })
+
+    return res
+  }
+
+  function getQuizFromNode(node) {
+    return new Promise(resolve => {
+      const questionPromises = getPromisesThatMeetsRequirements(
+        questionGetters,
+        node
+      )
+      const answerPromises = getPromisesThatMeetsRequirements(
+        answerGetters,
+        node
+      )
+      if (!answerPromises || !questionPromises) {
+        resolve({ success: false })
+      }
+
+      const makeTextFromElements = element => {
+        if (element.type === 'img') {
+          return '[' + element.val + ']'
+        } else {
+          return element.val
+        }
+      }
+
+      const getImagesFromElements = elements => {
+        return elements.reduce((acc, element) => {
+          if (element.type === 'img') {
+            acc.push(element.val)
+          }
+          return acc
+        }, [])
+      }
+
+      Promise.all([Promise.all(questionPromises), Promise.all(answerPromises)])
+        .then(res => {
+          const questionText = res[0].map(makeTextFromElements).join(' ')
+          const answerText = res[1].map(makeTextFromElements).join(' ')
+          let images = getImagesFromElements([...res[0], ...res[1]])
+          images = uniq(images)
+
+          resolve({
+            A: removeUnnecesarySpaces(answerText),
+            Q: removeUnnecesarySpaces(questionText),
+            data: getData(images),
+            success: true,
+          })
+        })
+        .catch(err => {
+          console.warn('Error in getQuizFromNode()')
+          console.warn(err)
+        })
+    })
+  }
+
+  function getData(images) {
+    if (!images || images.length === 0) {
       return {
         type: 'simple',
       }
     } else {
       return {
         type: 'image',
-        src: image,
+        images: images,
       }
     }
   }
 
-  function getAnswerPromisesFromNode(node) {
-    let answer = node.getElementsByClassName('rightanswer')
-    if (answer.length === 0) {
-      console.warn('NO ANSWER FOR ANSWER')
-    }
-    answer = answer[0]
-    const promises = []
+  const questionGetters = {
+    getSimpleQuestion: {
+      description: 'Basic question getter',
+      index: 0,
+      requirement: node => {
+        return node.getElementsByClassName('qtext').length > 0
+      },
+      getterFunction: node => {
+        let question = node.getElementsByClassName('qtext')[0]
+        const promises = []
 
-    Array.from(answer.childNodes).forEach(elem => {
-      if (elem.tagName === 'IMG') {
-        promises.push(digestMessage(getBase64Image(elem)))
-      } else {
-        promises.push({ type: 'txt', val: elem.nodeValue })
-      }
-    })
-    return promises
-  }
-
-  function getQuizFromNode(node) {
-    return new Promise(resolve => {
-      const promises = getAnswerPromisesFromNode(node)
-
-      Promise.all(promises).then(res => {
-        const images = []
-        const question = getQuestionFromNode(node)
-        const solution = res
-          .map(i => {
-            if (i.type === 'img') {
-              images.push(i.val)
-              return '[' + i.val + ']'
-            } else {
-              return i.val
-            }
-          })
-          .join(' ')
-
-        resolve({
-          A: removeUnnecesarySpaces(solution),
-          Q: question,
-          images,
+        Array.from(question.childNodes).forEach(elem => {
+          if (elem.tagName === 'IMG') {
+            promises.push(digestMessage(getBase64Image(elem)))
+          } else if (elem.tagName === undefined) {
+            promises.push({ type: 'txt', val: elem.nodeValue })
+          } else {
+            promises.push({ type: 'txt', val: elem.innerText })
+          }
         })
-      })
-    })
+        return promises
+      },
+    },
   }
 
-  function getQuestionFromNode(node) {
-    let question = node.getElementsByClassName('qtext')
-    if (question.length === 0) {
-      console.warn('NO QUESTION FOR QTEXT')
-    }
-    question = question[0].innerText
-    return removeUnnecesarySpaces(question)
-  }
+  const answerGetters = {
+    getSimpleAnswer: {
+      description: 'Basic answer getter',
+      index: 0,
+      requirement: node => {
+        return node.getElementsByClassName('rightanswer').length > 0
+      },
+      getterFunction: node => {
+        let answer = node.getElementsByClassName('rightanswer')[0]
+        const promises = []
 
-  function getBase64Image(img) {
-    let canvas = document.createElement('canvas')
-    canvas.width = img.width
-    canvas.height = img.height
-    let ctx = canvas.getContext('2d')
-    ctx.drawImage(img, 0, 0)
-    let dataURL = canvas.toDataURL('image/png')
-    return dataURL.replace(/^data:image\/(png|jpg);base64,/, '')
+        Array.from(answer.childNodes).forEach(elem => {
+          if (elem.tagName === 'IMG') {
+            promises.push(digestMessage(getBase64Image(elem)))
+          } else if (elem.tagName === undefined) {
+            promises.push({ type: 'txt', val: elem.nodeValue })
+          } else {
+            promises.push({ type: 'txt', val: elem.innerText })
+          }
+        })
+        return promises
+      },
+    },
+    getDropdownAnswer: {
+      description: 'Dropdown answer getter',
+      index: 1,
+      requirement: node => {
+        return false
+      },
+      getterFunction: node => {
+        // TODO dropdown kérdés.html
+        return 'asd'
+      },
+    },
   }
 
   function digestMessage(message) {
@@ -275,6 +347,19 @@
     })
   }
 
+  function getBase64Image(img) {
+    const copy = document.createElement('img')
+    copy.src = img.src
+    copy.crossOrigin = 'Anonymous'
+    let canvas = document.createElement('canvas')
+    canvas.width = copy.width
+    canvas.height = copy.height
+    let ctx = canvas.getContext('2d')
+    ctx.drawImage(copy, 0, 0)
+    let dataURL = canvas.toDataURL('image/png')
+    return dataURL.replace(/^data:image\/(png|jpg);base64,/, '')
+  }
+
   // ----------------------------------------------------------------------------------------------
   // String utils 2
   // ----------------------------------------------------------------------------------------------
@@ -941,6 +1026,13 @@
 
   function HandleResults(url) {
     getQuiz().then(res => {
+      console.log('\n\n\n')
+      res.forEach(r => {
+        console.log(r.Q)
+        console.log(r.A)
+        console.log(r.data)
+        console.log('')
+      })
       SaveQuiz(res, ShowSaveQuizDialog) // saves the quiz questions and answers
     })
   }