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

package/src/plugins/timeManager.js

@@ -1,77 +0,0 @@
-export default function timeManager(Vue) {
-  Vue.prototype.$timeManager = new Vue({
-    data() {
-      return {
-        lessonTimeCounter: 0,
-        //activityTimeCounter: 0,
-        lessonDuration: 0,
-        activityDuration: 0,
-        activityInterval: null,
-        lessonInterval: null,
-        fullInterval: null
-      }
-    },
-    methods: {
-      /* Start the timer */
-      startTimer(op) {
-        if (op && !['activity', 'lesson'].includes(op))
-          throw new Error('this is not a valid option for the timer')
-
-        switch (op) {
-          case 'activity':
-            this.activityInterval = setInterval(() => {
-              this.activityDuration += 1
-            }, 1000)
-
-            break
-
-          case 'lesson':
-            this.lessonInterval = setInterval(() => {
-              this.lessonTimeCounter += 1
-            }, 1000)
-            break
-
-          default:
-            this.fullInterval = setInterval(() => {
-              this.activityDuration += 1
-              this.lessonDuration += 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 (op === 'activity' && this.activityDuration > 0) {
-          clearInterval(this.activityInterval)
-          this.activityDuration = 0
-        } else if (op === 'lesson' && this.lessonDuration > 0) {
-          clearInterval(this.lessonInterval)
-          this.lessonDuration = 0
-        } else {
-          clearInterval(this.fullInterval)
-          this.activityDuration = 0
-          this.lessonDuration = 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.activityDuration > 0) {
-          window.clearInterval(this.activityDuration)
-        } else if (op === 'lesson') {
-          window.clearInterval(this.lessonDuration)
-        } else {
-          clearInterval(this.fullInterval)
-        }
-      },
-      formatTime(seconds) {
-        let t = new Date(null)
-        t.setSeconds(seconds)
-      }
-    }
-  })
-}

package/src/routes_bckp.js

@@ -1,313 +0,0 @@
-import Router from 'vue-router'
-import AppCompViewDisplay from './components/AppCompViewDisplay.vue'
-import store from './module/store'
-import { fileAssets } from './shared/generalfuncs'
-import ModuleView from '@/views/ModuleView.vue'
-import SummaryView from '@/views/SummaryView.vue'
-/**
- * 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 viewRoute = null // holder for views routes
-let mappedFiles = null // routes definitions
-
-/**
- * 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: [],
-  meta: {}
-}
-
-if (fileAssets.getViews().length > 0) {
-  let hasModule = false
-  let hasSummary = false
-  let fileRef = null
-  let splitted = null
-  let fileName = null
-  let fileContent = null
-
-  for (let view of fileAssets.getViews()) {
-    fileRef = view.replace(/(\.\/)/g, '')
-    splitted = fileRef.split('/')
-    fileName = splitted[splitted.length - 1].replace(/(\.vue)/g, '')
-    fileContent = fileAssets.fetchFileContent(`./${fileRef}`).default
-
-    // Create route for the views
-    viewRoute = {
-      name: fileName.toLowerCase(),
-
-      meta: {}
-    }
-
-    if (fileName.toLowerCase() === 'moduleview' && fileContent.data) {
-      viewRoute.path = ''
-      viewRoute.name = 'module'
-      // viewRoute.meta.type = 'normal'
-      viewRoute.component = ModuleView
-      viewRoute.children = []
-      viewRoute.meta.children = []
-      hasModule = true
-    }
-
-    if (fileName.toLowerCase() == 'summaryview' && fileContent.data) {
-      viewRoute.path = '/menu'
-      viewRoute.name = 'menu'
-      viewRoute.component = SummaryView
-      viewRoute.meta.type = 'page_menu'
-      hasSummary = true
-    }
-
-    defaultRoute.children.push(viewRoute)
-  }
-  // Create activities routes for the ModuleView
-  if (hasModule) {
-    const moduleRoute = defaultRoute.children.find((r) => r.name == 'module') //Get ModuleView route
-    //================== Routes For Activities ================//
-    // Load files in module folder
-    const _allFiles = fileAssets.getActivities()
-    mappedFiles = fileAssets.buildMapTree(_allFiles)
-    let abstractRouteForActivity = {}
-    if (!mappedFiles.size) errorType = 'errorPage'
-
-    //There is a file in the module folder
-    /**
-     * Define a route for each Activity and its pages
-     * Set all nested routes in Activities
-     * Set the activies routes as children of module route
-     */
-    let activityCount = 0
-
-    const buildRouteWithNested = ($arr, $folderName, ctx = '') => {
-      let bCounter = 0 //branch counter
-
-      let mainRoute = {}
-      for (const [key, value] of $arr) {
-        let pgIDtoNum = parseInt(key.slice(1))
-        let firstEl = $arr.entries().next().value
-
-        if (value.constructor === Map)
-          buildRouteWithNested(value, $folderName, ctx)
-        if (key == firstEl[0]) {
-          mainRoute = {
-            path: `page-${pgIDtoNum}`,
-            name: `${ctx.replace('-', '_')}.page_${pgIDtoNum}`,
-            // name: `${$folderName}.page_${pgIDtoNum}`,
-            component: () =>
-              import(
-                /* webpackChunkName: "home" */
-                `@/${firstEl[1].ref}`
-              ),
-            children: [],
-            meta: {
-              id: firstEl[0],
-              type: 'branching',
-              activity_ref: $folderName, // Axx
-              parent: {
-                _ref: 'P01',
-                _path: ctx, // activite-xx
-                _namedRoute: ctx.replace('-', '_') // activite_xx
-              },
-              children: []
-            }
-          }
-        } else {
-          bCounter += 1
-          // build abstract route for branching
-          let branchRoute = {
-            path: `:branche-${bCounter}`,
-            name: `${mainRoute.name}.branche_${bCounter}`,
-            component: () =>
-              import(
-                /* webpackChunkName: "gpNested" */
-                `@/${value.ref}`
-              ),
-            meta: {
-              id: key,
-              type: 'branch_page',
-              activity_ref: $folderName,
-              _branchingRef: `${firstEl[0]}.branch_${bCounter}`,
-              parent: {
-                _ref: firstEl[0],
-                _path: mainRoute.path,
-                _namedRoute: mainRoute.name
-              }
-            }
-          }
-          mainRoute.children.push(branchRoute)
-          mainRoute.meta.children.push({
-            _ref: key,
-            _path: branchRoute.path,
-            _namedRoute: branchRoute.name
-          })
-        }
-      }
-      return mainRoute
-    }
-
-    for (const [$folderName, $pages] of mappedFiles) {
-      let activityPageCount = 0 // page counter
-      //build a abstract route for each folder/activity
-      abstractRouteForActivity = {
-        component: AppCompViewDisplay,
-        meta: {
-          id: $folderName,
-          children: []
-        },
-        children: []
-      }
-      //Define the path for each folder
-      if ($folderName === 'A00') {
-        abstractRouteForActivity.path = 'introduction'
-      } else if ($folderName === 'A99') {
-        abstractRouteForActivity.path = 'conclusion'
-      } else {
-        activityCount++
-        abstractRouteForActivity.path = `activite-${activityCount}`
-      }
-
-      //Build the Route for each page of the Activity
-      for (const [$pageRef, $page] of $pages) {
-        let activityRoute
-        activityPageCount++
-
-        if ($page.constructor === Object) {
-          let firstPage = $pages.entries().next().value
-
-          if ($pageRef == firstPage[0]) {
-            activityRoute = {
-              path: 'page-1',
-              name: abstractRouteForActivity.path.replace('-', '_'), //activite_xx
-              component: () =>
-                import(/* webpackChunkName: "gpNested" */ `@/${$page.ref}`),
-              meta: {
-                id: `${$pageRef}`,
-                activity_ref: { $folderName },
-                parent: {
-                  _ref: `${$pageRef}`,
-                  _path: abstractRouteForActivity.path,
-                  _namedRoute: abstractRouteForActivity.path.replace('-', '_')
-                }
-              }
-            }
-          } else {
-            activityRoute = {
-              path: `page-${activityPageCount}`,
-              name: (() => {
-                let str = abstractRouteForActivity.path.replace('-', '_')
-
-                if (activityPageCount > 1)
-                  str = `${str}.page_${activityPageCount}`
-
-                return str
-              })(),
-              component: () =>
-                import(/* webpackChunkName: "gpNested" */ `@/${$page.ref}`),
-              meta: {
-                id: $pageRef,
-                activity_ref: $folderName,
-                parent: {
-                  _ref: `${$pageRef}`,
-                  _path: abstractRouteForActivity.path,
-                  _namedRoute: abstractRouteForActivity.path.replace('-', '_')
-                }
-              }
-            }
-          }
-        }
-        //Handling Branching Routes
-        if ($page.constructor === Map) {
-          const ctx = abstractRouteForActivity.path
-          activityRoute = buildRouteWithNested($page, $folderName, ctx)
-        }
-        //add page route into activity children
-        abstractRouteForActivity.children.push(activityRoute)
-
-        //add page route reference into in activity meta
-        abstractRouteForActivity.meta.children.push({
-          _ref: activityRoute.meta.id,
-          _path: activityRoute.path,
-          _namedRoute: activityRoute.name
-        })
-      }
-
-      moduleRoute.meta.children.push({
-        _ref: $folderName,
-        _path: abstractRouteForActivity.path,
-        _namedRoute: abstractRouteForActivity.path.replace('-', '_')
-      })
-
-      moduleRoute.children.push(abstractRouteForActivity)
-    }
-
-    // Add register Module pages to store
-    store.state.thisModule.activities = mappedFiles
-
-    // Set Module route as child of abstract route. Module will render inside abstract component
-  } else errorType = 'errorModule'
-  if (!hasSummary) errorType = 'errorMenu'
-} else errorType = 'errorModule'
-
-if (!errorType) {
-  // add the viewRoute 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'
-  }
-})
-
-// exporting routes object
-export default {
-  base: process.env.BASE_URL,
-  routes: [..._routes]
-}