fcad-core-dragon 2.0.0-beta.1 → 2.0.0-beta.10

package/src/mixins/$quizMixins.js

@@ -1,456 +0,0 @@
-const $extendsQuiz = {
-  watch: {
-    /**
-     * @description used to call a validation
-     */
-    quizSubmit(newValue) {
-      if (newValue == true) {
-        this.validateAnswers()
-      }
-    }
-  },
-
-  methods: {
-    /**
-     * @param {String} inputId
-     * @returns {Array} the class
-     */
-    classInput(inputId) {
-      let theClass = []
-
-      switch (this.inputType) {
-        case 'choix_unique':
-          if (inputId == this.quizInputUnique) {
-            theClass.push('reponseSelectionner')
-          }
-          break
-
-        case 'choix_mult':
-          if (this.containsValue(this.quizInputMultiple, inputId)) {
-            theClass.push('reponseSelectionner')
-          }
-      }
-
-      if (this.showSolution) {
-        if (this.solution !== null) {
-          switch (this.inputType) {
-            case 'choix_unique':
-              if (inputId == this.solution) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-
-            case 'choix_mult':
-              if (this.containsValue(this.solution, inputId)) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-
-            case 'dropdown':
-              if (this.solution[inputId] == this.quizSelectedValue[inputId]) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-
-            case 'texte_troue_select':
-              if (typeof this.quizSelectedValue[inputId] !== 'undefined') {
-                if (
-                  Object.values(this.solution[inputId])[0] ==
-                  this.quizSelectedValue[inputId]
-                ) {
-                  theClass.push('correct_answer')
-                } else {
-                  theClass.push('wrong_answer')
-                }
-              }
-              break
-
-            case 'reponse_ouverte':
-              if (this.solution == this.quizTextArea) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-            case 'texte_tableau':
-              if (
-                this.containsValue(
-                  this.solution[inputId].reponse_value,
-                  this.quizTextTableValue[inputId]
-                )
-              ) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-            case 'texte_troue':
-              if (typeof this.quizTextTableValue[inputId] !== 'undefined') {
-                if (
-                  this.containsValue(
-                    Object.values(this.solution[inputId])[0],
-                    this.quizTextTableValue[inputId]
-                  )
-                ) {
-                  theClass.push('correct_answer')
-                } else {
-                  theClass.push('wrong_answer')
-                }
-              }
-              break
-            case 'association':
-              if (
-                this.solution[inputId] == this.quizAssociationValue[inputId]
-              ) {
-                theClass.push('correct_answer')
-              } else {
-                theClass.push('wrong_answer')
-              }
-              break
-            case 'dragdrop':
-              if (
-                this.solution &&
-                this.solution[inputId] &&
-                this.quizDragDropValue &&
-                this.quizDragDropValue[inputId]
-              ) {
-                //remove sort if order is important
-                const solution = [...this.solution[inputId]].sort(function(
-                  a,
-                  b
-                ) {
-                  return a - b
-                })
-                const values = [...this.quizDragDropValue[inputId]].sort(
-                  function(a, b) {
-                    return a - b
-                  }
-                )
-                if (this.isEqual(solution, values)) {
-                  theClass.push('correct_answer')
-                } else {
-                  theClass.push('wrong_answer')
-                }
-              }
-          }
-        }
-      }
-      return theClass
-    },
-    messageAccessibility(inputId) {
-      let mess = ''
-      if (this.showSolution) {
-        if (this.solution !== null) {
-          switch (this.inputType) {
-            case 'choix_unique':
-              if (inputId == this.solution) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-
-            case 'choix_mult':
-              if (this.containsValue(this.solution, inputId)) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-
-            case 'dropdown':
-              if (this.solution[inputId] == this.quizSelectedValue[inputId]) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-
-            case 'texte_troue_select':
-              if (typeof this.quizSelectedValue[inputId] !== 'undefined') {
-                if (
-                  Object.values(this.solution[inputId])[0] ==
-                  this.quizSelectedValue[inputId]
-                ) {
-                  mess = `${this.$t('quizState.goodAnswer')}`
-                } else {
-                  mess = `${this.$t('quizState.badAnswer')}`
-                }
-              }
-              break
-
-            case 'reponse_ouverte':
-              if (this.solution == this.quizTextArea) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-            case 'texte_tableau':
-              if (
-                this.containsValue(
-                  this.solution[inputId].reponse_value,
-                  this.quizTextTableValue[inputId]
-                )
-              ) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-            case 'texte_troue':
-              if (typeof this.quizTextTableValue[inputId] !== 'undefined') {
-                if (
-                  this.containsValue(
-                    Object.values(this.solution[inputId])[0],
-                    this.quizTextTableValue[inputId]
-                  )
-                ) {
-                  mess = `${this.$t('quizState.goodAnswer')}`
-                } else {
-                  mess = `${this.$t('quizState.badAnswer')}`
-                }
-              }
-              break
-            case 'association':
-              if (
-                this.solution[inputId] == this.quizAssociationValue[inputId]
-              ) {
-                mess = `${this.$t('quizState.goodAnswer')}`
-              } else {
-                mess = `${this.$t('quizState.badAnswer')}`
-              }
-              break
-            case 'dragdrop':
-              if (
-                this.solution &&
-                this.solution[inputId] &&
-                this.quizDragDropValue &&
-                this.quizDragDropValue[inputId]
-              ) {
-                //remove sort if order is important
-                const solution = [...this.solution[inputId]].sort(function(
-                  a,
-                  b
-                ) {
-                  return a - b
-                })
-                const values = [...this.quizDragDropValue[inputId]].sort(
-                  function(a, b) {
-                    return a - b
-                  }
-                )
-                if (this.isEqual(solution, values)) {
-                  mess = `${this.$t('quizState.goodAnswer')}`
-                } else {
-                  mess = `${this.$t('quizState.badAnswer')}`
-                }
-              }
-          }
-        }
-      }
-      return mess
-    },
-    /**
-     * @description check if this question is correct
-     * @fires quiz-submit to AppCompQuiz.vue
-     */
-    validateAnswers() {
-      let theAnswer = {}
-
-      switch (this.inputType) {
-        case 'choix_unique': {
-          let listInput = this.quizInputUnique
-          if (listInput) {
-            theAnswer = {
-              [this.inputDataId]: listInput
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'choix_mult': {
-          let listInputCheck = this.quizInputMultiple
-          if (listInputCheck.length > 0) {
-            theAnswer = {
-              [this.inputDataId]: listInputCheck
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-
-          break
-        }
-
-        case 'dropdown': {
-          let listQuizSelected = this.quizSelected
-
-          if (
-            listQuizSelected.length == this.inputData.length &&
-            !this.containsValue(listQuizSelected, null)
-          ) {
-            let listQuizSelectedConvert = []
-            for (let index = 0; index < this.inputData.length; index++) {
-              const element = this.inputData[index]
-              listQuizSelectedConvert.push({
-                question_id: element.id,
-                reponse_id: listQuizSelected[index]
-              })
-            }
-            theAnswer = {
-              [this.inputDataId]: listQuizSelectedConvert
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'texte_troue_select': {
-          const regex = /\$%\S*%\$/g // regex pattern to match exp: $%number%$
-          let matchAll = this.textBase.split(regex)
-          let listQuizSelectedText = this.quizSelected
-          if (
-            listQuizSelectedText.length == matchAll.length - 1 &&
-            !this.containsValue(listQuizSelectedText, null)
-          ) {
-            let listQuizSelectedTextConvert = []
-            for (let index = 0; index < listQuizSelectedText.length; index++) {
-              listQuizSelectedTextConvert.push({
-                question_id: index,
-                reponse_id: listQuizSelectedText[index]
-              })
-            }
-            theAnswer = {
-              [this.inputDataId]: listQuizSelectedTextConvert
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'reponse_ouverte': {
-          let listInputText = this.quizTextArea
-          if (listInputText.length > 0) {
-            theAnswer = {
-              [this.inputDataId]: listInputText
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-        case 'texte_tableau': {
-          let listInputTextTable = this.quizTextTable
-          if (
-            listInputTextTable.length == this.inputData.length &&
-            !this.containsValue(listInputTextTable, null) &&
-            !this.containsValue(listInputTextTable, '')
-          ) {
-            let listInputTextTableConvert = []
-            for (let index = 0; index < this.inputData.length; index++) {
-              const element = this.inputData[index]
-              listInputTextTableConvert.push({
-                question_id: element.id,
-                reponse: listInputTextTable[index]
-              })
-            }
-            theAnswer = {
-              [this.inputDataId]: listInputTextTableConvert
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'texte_troue': {
-          const regex = /\$%\S*%\$/g // regex pattern to match exp: $%number%$
-          let matchAll = this.textBase.split(regex)
-          let listInputTextFill = this.quizTextTable
-          if (
-            listInputTextFill.length == matchAll.length - 1 &&
-            !this.containsValue(listInputTextFill, null) &&
-            !this.containsValue(listInputTextFill, '')
-          ) {
-            let listInputTextFillConvert = []
-            for (let index = 0; index < listInputTextFill.length; index++) {
-              listInputTextFillConvert.push({
-                question_id: index,
-                reponse: listInputTextFill[index]
-              })
-            }
-            theAnswer = {
-              [this.inputDataId]: listInputTextFillConvert
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'association': {
-          let listInputAssociation = this.quizAssociation
-          if (
-            Object.values(listInputAssociation).length ==
-              Object.values(this.solution).length &&
-            !this.containsValue(Object.values(listInputAssociation), '')
-          ) {
-            theAnswer = {
-              [this.inputDataId]: listInputAssociation
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-          break
-        }
-
-        case 'dragdrop': {
-          let listInputDragDrop = this.quizDragDrop
-          if (
-            Object.keys(listInputDragDrop).length ==
-            Object.keys(this.solution).length
-          ) {
-            theAnswer = {
-              [this.inputDataId]: this.quizDragDrop
-            }
-          } else {
-            //did not answered
-            theAnswer = null
-          }
-        }
-      }
-      this.$emit('quiz-submit', theAnswer)
-    },
-    /**
-     * @description - Method to get the question
-     */
-    getQuizQuestion() {
-      const el = document.querySelector(`#${this.aBy}`)
-      if (!el || !el.innerHTML) return
-      const labelFor =
-        this.$i18n.locale === 'fr'
-          ? 'Choix de reponse pour la'
-          : 'Answers available for the'
-      return `${labelFor} ${el.innerText}`
-    }
-  }
-}
-export default $extendsQuiz

package/src/mixins/timerMixin.js

@@ -1,156 +0,0 @@
-/*
-@ Description: Mixins to extends general fonctionnalities in a page of an activity. Add time tracker in activities
-@ Note: .
-*/
-export const timerMixin = {
-  data() {
-    return {
-      lessonTimeCounter: 0,
-      activityTimeCounter: 0,
-      elapsedCounter: 0, // count the elapse time since lesson started
-      activityInterval: null,
-      lessonInterval: null,
-      fullInterval: null,
-      timerState: 'stopped',
-      elapsedInterval: null // interval of passed time since the lesson is started. used only for saving purposed
-    }
-  },
-  methods: {
-    /* Start the timer */
-    startTimer(op) {
-      if (op && !['activity', 'lesson'].includes(op))
-        throw new Error('this is not a valid option for the timer')
-      if (this.timerState === 'stopped') {
-        switch (op) {
-          case 'activity':
-            this.activityInterval = setInterval(() => {
-              this.activityTimeCounter += 1
-            }, 1000)
-            this.timerState = 'started'
-
-            break
-
-          case 'lesson':
-            this.lessonInterval = setInterval(() => {
-              this.lessonTimeCounter += 1
-            }, 1000)
-            break
-
-          default:
-            this.fullInterval = setInterval(() => {
-              this.activityTimeCounter += 1
-              this.lessonTimeCounter += 1
-            }, 1000)
-        }
-      }
-    },
-    /* Stop the timer and reset  thimer to zero */
-    stopTimer(op) {
-      if (op && !['activity', 'lesson'].includes(op))
-        throw new Error('this is not a valid parameter')
-
-      if (this.timerState === 'started') {
-        if (op === 'activity' && this.activityTimeCounter > 0) {
-          this.lessonTimeCounter =
-            this.lessonTimeCounter + this.activityTimeCounter //add to the lesson counter
-          clearInterval(this.activityInterval) //clear the interval
-          this.activityTimeCounter = 0 // reset the counter
-          this.timerState = 'stopped'
-        } else if (op === 'lesson' && this.lessonTimeCounter > 0) {
-          clearInterval(this.lessonInterval)
-          this.lessonTimeCounter = 0
-        } else {
-          clearInterval(this.fullInterval)
-          clearInterval(this.elapsedCounter)
-          clearInterval(this.elapsedInterval)
-
-          this.activityTimeCounter = 0
-          this.lessonTimeCounter = 0
-          this.elapsedCounter = 0
-        }
-      }
-    },
-    /* Pause the timer but does not reset to zero*/
-    pauseTimer(op) {
-      if (op && !['activity', 'lesson'].includes(op))
-        throw new Error('this is not a valid parameter')
-
-      if (op === 'activity' && this.activityTimeCounter > 0) {
-        clearInterval(this.activityInterval)
-      } else if (op === 'lesson') {
-        clearInterval(this.lessonInterval)
-      } else {
-        clearInterval(this.fullInterval)
-        clearInterval(this.elapsedInterval)
-      }
-    },
-
-    /* Format seconds to ISO 8601 format */
-    formatToISOString(seconds) {
-      let d = new Date(null) //create a default date ref
-      d.setSeconds(seconds) //set the time with passed numbers of seconds
-      //Example of ISO 8601 time format of 24 chars: "1970-01-04T14:50:00.000Z"
-      let ISOTime = d.toISOString()
-
-      return ISOTime // YYYY-MM-DDTHH:mm:ss.sssZ
-    },
-
-    /* Parse a ISO string time period to the format of HH:mm:ss */
-    ISOTimeParser(seconds) {
-      let ISOTimePeriod = this.formatToISOString(seconds).substring(8, 19) // only the time portion of it
-      ISOTimePeriod = ISOTimePeriod.split('T')
-      const DDToHrs = (parseInt(ISOTimePeriod[0]) - 1) * 24 // convert xxT to hrs
-      const periodOfTime = ISOTimePeriod[1] ? ISOTimePeriod[1].split(':') : null
-
-      if (!periodOfTime) return '00:00:00'
-
-      let timeString = ''
-      let HH = (DDToHrs + parseInt(periodOfTime[0])).toString()
-      let mm = periodOfTime[1]
-      let ss = periodOfTime[2]
-
-      if (HH.length === 1) HH = `0${HH}`
-
-      timeString = `${HH}:${mm}:${ss}`
-
-      return timeString
-    }
-  },
-  mounted() {
-    this.$bus.$on('start-timer', (op) => {
-      this.startTimer(op)
-    })
-
-    this.$bus.$on('stop-timer', (op) => {
-      this.stopTimer(op)
-    })
-
-    this.$bus.$on('pause-timer', (op) => {
-      this.pauseTimer(op)
-    })
-
-    this.elapsedInterval = setInterval(() => {
-      this.elapsedCounter += 1
-    }, 1000)
-  },
-  computed: {
-    activityDuration() {
-      let duration
-      if (this.activityTimeCounter > 0)
-        duration = this.ISOTimeParser(this.activityTimeCounter)
-      else duration = '00:00:00'
-
-      return duration
-    },
-    lessonDuration() {
-      this.lessonTimeCounter = this.lessonTimeCounter + this.activityTimeCounter
-
-      let duration = this.ISOTimeParser(this.lessonTimeCounter)
-      return duration
-    },
-    elapsedTime() {
-      const eTime = this.elapsedCounter
-      return eTime
-    }
-  }
-}