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

package/src/routes_static.js

@@ -0,0 +1,344 @@
+import Router from 'vue-router'
+import AppCompViewDisplay from './components/AppCompViewDisplay.vue'
+import store from './module/store'
+import { fileAssets } from './shared/generalfuncs'
+// const _path = require('path')
+
+/**
+ * The router Module defines the routes of the App by:
+ * loading the required files for module and activities pages,
+ * dynamically creating the navigation route of module base on the file in VIEWS folder
+ * dynamically creating the navigation routes of activities and branchings base on the files contained in the MODULE
+ * Creating Redirection routes for navigation error
+ * Adding the pages for the module in the STORE
+ */
+
+const _routes = [] // routes of the app
+let errorType = null
+let newRoute = null // wrapper for module routes
+const _allFiles = fileAssets.getActivities()
+let mappedFiles = fileAssets.buildMapTree(_allFiles)
+let menuCreated = false
+
+/**
+ * 1- Preparing the router to catch failing navigation error from browser by
+ * Redefining the Router push method
+ * ref: https://stackoverflow.com/questions/57837758/ navigationduplicated-navigating-to-current-location-search-is-not-allowed
+ */
+const originalPush = Router.prototype.push
+Router.prototype.push = function push(location) {
+  return originalPush.call(this, location).catch((err) => err)
+}
+
+// Creating 1st route: redirection for none existing route to home(Module)
+_routes.push({
+  path: '*',
+  redirect: {
+    name: '404'
+  }
+})
+
+/**
+ * 2 - Creating the 2nd route: The App module route
+ */
+// Load all the files in the VIEWS folder
+
+const defaultRoute = {
+  path: '/',
+  component: AppCompViewDisplay,
+  children: []
+}
+errorType = false
+
+const staticSummary = {
+  path: '/menu',
+  component: () =>
+    import(/* webpackChunkName: "menu" */ `@/views/SummaryView.vue`),
+  name: 'menu',
+  meta: {
+    type: 'page_menu'
+  }
+}
+
+const staticModule = {
+  path: '',
+  component: () =>
+    import(/* webpackChunkName: "home" */ `@/views/ModuleView.vue`),
+  name: 'module',
+  children: [
+    {
+      path: 'introduction',
+      component: AppCompViewDisplay,
+      children: [
+        {
+          path: 'page-1',
+          name: 'introduction',
+          component: () =>
+            import(/* webpackChunkName: "gpNested" */ `@/module/A02/P01.vue`),
+          meta: {
+            id: 'P01',
+            activity_ref: 'A00',
+            type: 'normal',
+            parent: {
+              _ref: 'P01',
+              _path: 'introduction',
+              _namedRoute: 'introduction'
+            }
+          }
+        }
+      ],
+      meta: {
+        id: 'A00',
+        children: [
+          {
+            _ref: 'P01',
+            _path: 'page-1',
+            _namedRoute: 'introduction'
+          }
+        ]
+      }
+    },
+    {
+      path: 'activite-1',
+      component: AppCompViewDisplay,
+      children: [
+        {
+          path: 'page-1',
+          name: 'activite_1',
+          component: () =>
+            import(/* webpackChunkName: "gpNested" */ `@/module/A01/P01.vue`),
+          meta: {
+            id: 'P01',
+            activity_ref: 'A01',
+            type: 'normal',
+            parent: {
+              _ref: 'P01',
+              _path: 'activite-1',
+              _namedRoute: 'activity_1'
+            }
+          }
+        },
+        {
+          path: 'page-2',
+          name: 'activite_1.page_2',
+          component: () =>
+            import(/* webpackChunkName: "gpNested" */ `@/module/A01/P02.vue`),
+          meta: {
+            id: 'P02',
+            activity_ref: 'A01',
+            type: 'branching',
+            parent: {
+              _ref: 'P01',
+              _path: 'activite-1',
+              _namedRoute: 'activity_1'
+            },
+            children: [
+              {
+                _ref: 'P02_E01',
+                _path: 'branch-1',
+                _namedRoute: 'A01.page_2.branching_1.branch_1'
+              },
+              {
+                _ref: 'P02_E02',
+                _path: 'branch-2',
+                _namedRoute: 'A01.page_2.branching_1.branch_2'
+              },
+              {
+                _ref: 'P02_E03',
+                _path: 'branch-3',
+                _namedRoute: 'A01.page_2.branching_1.branch_3'
+              }
+            ]
+          },
+          children: [
+            {
+              path: 'branch-1',
+              name: 'A01.page_2.branching_1.branch_1',
+              component: () =>
+                import(
+                  /* webpackChunkName: "gpNested" */ `@/module/A01/P02_E01.vue`
+                ),
+              meta: {
+                id: 'P02_E01',
+                activity_ref: 'A01',
+                type: 'branch',
+                branching_ref: 'A01.P02.branching_1',
+                parent: {
+                  _ref: 'P02',
+                  _path: 'activite-1.page-2',
+                  _namedRoute: 'activity_1.page_2'
+                }
+              }
+            },
+            {
+              path: 'branch-2',
+              name: 'A01.page_2.branching_1.branch_2',
+              component: () =>
+                import(
+                  /* webpackChunkName: "gpNested" */ `@/module/A01/P02_E02.vue`
+                ),
+              meta: {
+                id: 'P02_E02',
+                activity_ref: 'A01',
+                type: 'branch',
+                branching_ref: 'A01.P02.branching_1',
+                parent: {
+                  _ref: 'P02',
+                  _path: 'activite-1.page-2',
+                  _namedRoute: 'activity_1.page_2'
+                }
+              }
+            },
+            {
+              path: 'branch-3',
+              name: 'A01.page_2.branching_1.branch_3',
+              component: () =>
+                import(
+                  /* webpackChunkName: "gpNested" */ `@/module/A01/P02_E03.vue`
+                ),
+              meta: {
+                id: 'P02_E03',
+                activity_ref: 'A01',
+                type: 'branch',
+                branching_ref: 'A01.P02.branching_1',
+                parent: {
+                  _ref: 'P02',
+                  _path: 'activite-1.page-2',
+                  _namedRoute: 'activity_1.page_2'
+                }
+              }
+            }
+          ]
+        },
+        {
+          path: 'page-3',
+          name: 'activite_1.page_3',
+          component: () =>
+            import(/* webpackChunkName: "gpNested" */ `@/module/A01/P03.vue`),
+          meta: {
+            id: 'P03',
+            activity_ref: 'A01',
+            type: 'normal',
+            parent: {
+              _ref: 'P01',
+              _path: 'activite-1',
+              _namedRoute: 'activity_1'
+            }
+          }
+        }
+      ],
+      meta: {
+        id: 'A01',
+        children: [
+          {
+            _ref: 'P01',
+            _path: 'page-1',
+            _namedRoute: 'activite_1'
+          },
+          {
+            _ref: 'P02',
+            _path: 'page-2',
+            _namedRoute: 'activite_1.page_2'
+          },
+          {
+            _ref: 'P03',
+            _path: 'page-3',
+            _namedRoute: 'activite_1.page_3'
+          }
+        ]
+      }
+    },
+    {
+      path: 'activite-2',
+      component: AppCompViewDisplay,
+      children: [
+        {
+          path: 'page-1',
+          name: 'activite_2',
+          component: () =>
+            import(/* webpackChunkName: "gpNested" */ `@/module/A02/P01.vue`),
+          meta: {
+            id: 'P01',
+            activity_ref: 'A02',
+            type: 'normal',
+            parent: {
+              _ref: 'P01',
+              _path: 'activite-2',
+              _namedRoute: 'activity_2'
+            }
+          }
+        }
+      ],
+      meta: {
+        id: 'A02',
+        children: [
+          {
+            _ref: 'P01',
+            _path: 'page-1',
+            _namedRoute: 'activite_2'
+          }
+        ]
+      }
+    }
+  ],
+  meta: {
+    id: 'mod_00100',
+    type: 'normal',
+    children: [
+      {
+        _ref: 'A01',
+        _path: 'introduction',
+        _namedRoute: 'introduction'
+      },
+      {
+        _ref: 'A01',
+        _path: 'activite-1',
+        _namedRoute: 'activite_1'
+      },
+      {
+        _ref: 'A02',
+        _path: 'activite-2',
+        _namedRoute: 'activite_2'
+      }
+    ]
+  }
+}
+defaultRoute.children.push(staticModule)
+defaultRoute.children.push(staticSummary)
+if (!errorType) {
+  // add the newRoute to the routes array
+  _routes.push(defaultRoute)
+} else {
+  // create Route for error non-existing files
+  _routes.push({
+    path: '/',
+    component: () =>
+      import(
+        /* webpackChunkName: "gpNested" */ `./components/AppBaseErrorDisplay.vue`
+      ),
+    props: {
+      errorMessage: errorType
+    }
+  })
+}
+// Routes for errors : 404
+_routes.push({
+  path: '/404',
+  name: '404',
+  component: () =>
+    import(
+      /* webpackChunkName: "gpNested" */ `./components/AppBaseErrorDisplay.vue`
+    ),
+  props: {
+    errorMessage: '404'
+  }
+})
+
+// Add register Module pages to store
+store.state.thisModule.activities = mappedFiles
+
+// exporting routes object
+export default {
+  base: process.env.BASE_URL,
+  routes: [..._routes]
+}

package/src/shared/generalfuncs.js

@@ -2,16 +2,16 @@ const allfile = require.context('@/', true, /\.vue$/) //get all .vue file at the
 
 const fileAssets = {
   // return the collection of all the files in the project directory
-  allFiles: () => allfile,
+  allFiles: () => allfile.keys(),
 
   // Return all the file in './views' with the Name Module
-  getModule: () => {
-    return allfile.keys().filter((file) => file.startsWith('./views/Module'))
+  getViews: () => {
+    return fileAssets.allFiles().filter((file) => file.startsWith('./views'))
   },
   // return all files that are in the folder './src/module' of the project with name respecting following condition:
   // must start with a capital P followed by a digit (P0, P1, P2...) and not contain keyword "copy"
   getActivities: () => {
-    return allfile.keys().filter((file) => {
+    return fileAssets.allFiles().filter((file) => {
       if (
         file.startsWith('./module/A') &&
         /^P[0-9]{2,3}/.test(file.split('/')[3]) &&
@@ -107,6 +107,81 @@ const fileAssets = {
       }
     }
     return err
+  },
+
+  /**
+   * @description Validator for the content of menu setting file
+   * @param {String} a- array of file for use case
+   * @param {Object} [requiredArgs] list of arguments to include consider in validation ()
+   */
+  buildMapTree: (a) => {
+    // Load files in module folder
+    if (a.length < 0) return
+
+    const mapTree = new Map()
+    // There is a file in the module folder
+
+    a.forEach((key) => {
+      const fileRef = key.replace(/(\.\/)/g, '')
+      const splitted = fileRef.split('/')
+      const activityName = splitted[1]
+      const fileName = splitted[splitted.length - 1].replace(/(\.vue)/g, '')
+      const fileContent = fileAssets.fetchFileContent(`./${fileRef}`).default
+
+      if (!Object.keys(fileContent).includes('data')) return
+      // Handling single page type
+      // adding the page in a map for the Pages
+
+      // Add the key in the map for the routes if it is not in the map, with its data as new Map;
+      if (!mapTree.get(activityName)) {
+        mapTree.set(activityName, new Map())
+      }
+
+      if (fileName.length === 3) {
+        mapTree.get(activityName).set(fileName, {
+          ref: fileRef,
+          content: fileContent.data()
+        }) // add entry for the page
+      }
+      // Handleling Groupe page type
+      else if (fileName.length > 3 && fileName.includes('_')) {
+        const keyToFind = fileName.split('_', 1)[0] // Pxx
+        const KeyToAdd = fileName.split('_')[1] // Exx
+
+        // // search for the page key in the map
+        if (!mapTree.get(activityName).has(keyToFind)) return
+
+        // save a reference for the value of the key
+        const tempSave = mapTree.get(activityName).get(keyToFind)
+
+        // transform value of found key to a new map
+        if (!mapTree.get(activityName).get(keyToFind).size) {
+          mapTree.get(activityName).set(keyToFind, new Map())
+          // Update reference of key's
+          mapTree
+            .get(activityName)
+            .get(keyToFind)
+            .set(keyToFind, tempSave)
+        }
+
+        // Add page EXX in Map if it is not already added
+        if (
+          !mapTree
+            .get(activityName)
+            .get(keyToFind)
+            .get(KeyToAdd)
+        )
+          mapTree
+            .get(activityName)
+            .get(keyToFind)
+            .set(fileName, {
+              ref: fileRef,
+              content: fileContent.data()
+            })
+      }
+    })
+
+    return mapTree
   }
 }
 

package/src/shared/validators.js

@@ -0,0 +1,249 @@
+/**
+ * @description Validator for the content of menu setting file
+ * @param {String} fName- name of the file for use case
+ * @param {Object} fData: file's data to validate
+ * @param {Object} [requiredArgs] list of arguments to include consider in validation ()
+ */
+const validatefileContent = (fName, fData, requiredArgs = {}) => {
+  let err = null
+  if (process.env.NODE_ENV === 'development') {
+    switch (fName) {
+      case 'menuSettings': {
+        const { keys4Activity, keys4Anchors } = requiredArgs
+
+        //*validate that data is an {Object}. if Not send error message
+        if (fData.constructor !== Object)
+          err = '💥Invalid file provided for menu settings'
+
+        if (Object.entries(fData).length > 0) {
+          const content = Object.entries(fData)
+
+          for (let el of content) {
+            // validate that the content of each entry is an object
+            if (el[1].constructor !== Object || !Object.keys(el[1]).length) {
+              err = `💥 invalid data provided for key 👉 ${el[0]} 👈 in ➡ menu.setting.js \n  🚩Must be of type {Object}`
+              break
+            }
+          }
+          // Validate that each entry has the required key
+          if (!err) {
+            for (let el of content) {
+              const entry = el[1]
+              for (let k of keys4Activity) {
+                if (!entry[k]) {
+                  err = `💥 Missing 👉 ${k} 👈 in ${el[0]} in ➡ menu.setting.js \n  🚩Allowed indexes are: 👉 ${keys4Activity}`
+                  break
+                } else {
+                  //validate that each entry as correct value type
+                  switch (k) {
+                    case 'anchors':
+                      if (entry[k].constructor !== Array)
+                        err = `💥 Invalid anchors declaration for 👉 ${el[0]} 👈 in ➡ menu.setting.j \n  🚩Must be of type {Array}`
+                      else {
+                        const anchors = entry.anchors
+
+                        for (let a of anchors) {
+                          //trow error if numbers of keys are not the same as required
+                          const a_numb = anchors.indexOf(a) + 1
+                          if (Object.keys(a).length !== keys4Anchors.length) {
+                            err = `💥 Invalid declaration in 👉anchor ${a_numb}👈  for ➡ ${el[0]} in ➡ menu.setting.js \n  🚩 Allowed indexes are: 👉 ${keys4Anchors}`
+                            break
+                          }
+                          // Validated that required keys condition and type is met
+                          for (let k of keys4Anchors) {
+                            if (!a[k]) {
+                              err = `💥 Missing 👉 ${k} 👈 for anchor ${a_numb} ➡ ${el[0]} ➡ menu.setting.js \n 🚩 Allowed indexes are: 👉 ${keys4Anchors}`
+                            } else if (a[k].constructor !== String) {
+                              err = `💥 Invalid 👉 ${k} 👈 declaration for anchor ${a_numb} ➡ ${el[0]} ➡ menu.setting.js \n  🚩 Must be of type {String}`
+                            }
+                            if (err) break
+                          }
+                          if (err) break
+                        }
+                      }
+
+                      break
+                    default:
+                      if (entry[k].constructor !== String)
+                        err = `Invalid 👉 ${k} 👈 declaration for ➡ ${el[0]} in ➡ menu.setting.js \n  🚩 Must be of type {String}`
+                      break
+                  }
+                }
+              }
+
+              if (err) break
+            }
+          }
+        }
+        break
+      }
+    }
+  }
+  return err
+}
+
+/**
+ * @description Validator for the content of menu setting file
+ * @param {Object} data- Object definition to validate
+ **/
+const validateVideoData = (data) => {
+  const errorList = []
+  if (process.env.NODE_ENV === 'development') {
+    let errStringInConsole = null
+    let errString = null
+    const expectedKeys = ['mSources', 'mSubtitles', 'mPoster', 'mTranscript']
+
+    if (!data || data.constructor !== Object || Object.keys(data).length < 1) {
+      errStringInConsole = `\n 💥 Invalid declaration for video element`
+      console.warn(
+        `%c  WARNING!>>> VIDEO: ${errStringInConsole}`,
+        'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+      )
+      errString = `Declaration invalide pour Objet video.`
+      errorList.push(errString)
+    }
+
+    if (!data['mSources']) {
+      errStringInConsole = ` Missing 👉 mSources 👈 declaration for video element`
+
+      errString = `l'Attribut 👉 mSources 👈 pour l'Objet video n'est pas defini. `
+      console.warn(
+        `%c  WARNING!>>> ${errStringInConsole}`,
+        'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+      )
+      errorList.push(errString)
+    }
+
+    //Start validation of keys in data
+    if (!errString) {
+      expectedKeys.forEach((k) => {
+        if (!data[k] && k !== 'mSources') return
+
+        switch (k) {
+          case 'mSources':
+            if (
+              data['mSources'].constructor !== Array ||
+              data['mSources'].length < 1
+            ) {
+              errStringInConsole =
+                '\n 💥 Invalid type declaration for mSources.\n  🚩 Must be of type Array'
+
+              errString = `l'Attribut 👉 mSources 👈  pour le media doit être de type Array`
+
+              errorList.push(errString)
+              console.warn(
+                `%c  WARNING!>>> ${errStringInConsole}`,
+                'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+              )
+            }
+            break
+
+          case 'mSubtitles':
+            {
+              //Validate required keys in Subtitle definition
+              let expectedKeys = ['label', 'src', 'srclang']
+              //we only accept one subtitle and must be defined as an Object with 3 keys
+              if (
+                data['mSubtitles'].constructor !== Array ||
+                !data['mSubtitles'].length
+              ) {
+                errStringInConsole = `\n 💥 Invalid type declaration for mSubtitles.\n  🚩 Must be of type Array with at list one Object defined with: ${expectedKeys}`
+
+                errString = `l'Attribut 👉 mSubtitles 👈 doit être de type Array avec au moins un Objet: {${expectedKeys}} `
+
+                console.warn(
+                  `%c  WARNING!>>> ${errStringInConsole}`,
+                  'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+                )
+
+                return errorList.push(errString)
+              }
+              //Validate definition for each Subtitle Object
+              for (const obj of data['mSubtitles']) {
+                const objIndex = data['mSubtitles'].indexOf(obj)
+                expectedKeys.forEach((expected) => {
+                  if (!obj[expected]) {
+                    errStringInConsole = `\n 💥 Missing key 👉 ${expected} 👈 for mSubtitles No.${objIndex +
+                      1}.\n  🚩 required keys are: ${expectedKeys} `
+
+                    errString = `l'Attribut 👉 ${expected} 👈  pour le sous-titre  No.${objIndex +
+                      1} n'est pas défini`
+
+                    console.warn(
+                      `%c  WARNING!>>> ${errStringInConsole}`,
+                      'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+                    )
+                    return errorList.push(errString)
+                  }
+
+                  // Only none empty String type Accepted
+                  if (
+                    obj[expected].constructor === String &&
+                    obj[expected].trim().length
+                  )
+                    return
+
+                  errStringInConsole = `\n 💥 Invalid type declaration for 👉${expected}👈 in mSubtitles No.${objIndex +
+                    1}.\n  🚩 Must be none-empty String `
+
+                  errString = `l'Attribut 👉${expected}👈 du sous-titre No.${objIndex +
+                    1} doit être de type String et ne peut pas être vide. `
+
+                  console.warn(
+                    `%c  WARNING!>>> ${errStringInConsole}`,
+                    'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+                  )
+
+                  errorList.push(errString)
+                })
+              }
+            }
+            break
+          case 'mPoster':
+            //Only type String allowed and must not be empty
+            if (
+              data['mPoster'] &&
+              data['mPoster'].constructor == String &&
+              data['mPoster'].trim().length
+            )
+              return
+
+            errStringInConsole = `\n 💥 Invalid type declaration for 👉 mPoster 👈.\n  🚩 Must be none-empty String `
+
+            errString = `l'Attribut 👉 mPoster 👈 doit être de type String et ne peut pas être vide. `
+
+            errorList.push(errString)
+            console.warn(
+              `%c  WARNING!>>> VIDEO: ${errStringInConsole}`,
+              'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+            )
+
+            break
+          case 'mTranscript':
+            //Only type String allowed and must not be empty
+            if (
+              data['mTranscript'] &&
+              data['mTranscript'].constructor == String &&
+              data['mTranscript'].trim().length
+            )
+              return
+
+            errStringInConsole = `\n 💥 Invalid type declaration for 👉 mTranscript 👈 .\n  🚩 Must be none-empty String `
+
+            errString = `l'Attribut 👉 mTranscript 👈 doit être de type String et ne peut pas être vide. `
+
+            console.warn(
+              `%c  WARNING!>>> VIDEO: ${errStringInConsole}`,
+              'background: orange; color: white; display: block; border-radius:5px; margin:5px;'
+            )
+            errorList.push(errString)
+
+            break
+        }
+      })
+    }
+  }
+  return errorList
+}
+
+export { validateVideoData, validatefileContent }