freeleaps_frontend/frontend/src/plugins/router/router.js

import { createRouter, createWebHistory } from 'vue-router'
import { store, userRoleEnum } from '../store/index'

//public
import About from '../../pages/public/About.vue'
import Blogs from '../../pages/public/Blogs.vue'
import Career from '../../pages/public/Career.vue'
import Contact from '../../pages/public/Contact.vue'
import PdfContentViewer from '../../pages/public/PdfContentViewer.vue'
import LinkContentViewer from '../../pages/public/LinkContentViewer.vue'

//guest
import FrontDoor from '../../pages/guest/FrontDoor.vue'
import SigninWithEmailAndCode from '../../pages/guest/SigninWithEmailAndCode.vue'
import NewUserSetPassword from '../../pages/guest/NewUserSetPassword.vue'
import NewUserSetFlid from '../../pages/guest/NewUserSetFlid.vue'
import SigninWithEmailAndPassword from '../../pages/guest/SigninWithEmailAndPassword.vue'

//Workspace projects
import MyWorkspaceProjects from '../../pages/user/workspace/projectManage/Home.vue'

import ProjectManage from '../../pages/user/workspace/projectManage/ProjectManage.vue'
import ProjectManageCode from '../../pages/user/workspace/projectManage/Code.vue'
import ProjectManageDeploy from '../../pages/user/workspace/projectManage/Deploy.vue'
import ProjectManageGeneral from '../../pages/user/workspace/projectManage/General.vue'
import ProjectManageIssues from '../../pages/user/workspace/projectManage/Issues.vue'
import ProjectManageProduct from '../../pages/user/workspace/projectManage/Product.vue'
import ProjectManageProgress from '../../pages/user/workspace/projectManage/Progress.vue'

//Workspace Requests
import MyWorkspaceRequests from '../../pages/user/workspace/requestManage/Home.vue'

/// Request Issue
import IssueRequest from '../../pages/user/workspace/requestIssue/Issue.vue'
import RequestSubmitted from '../../pages/user/workspace/requestIssue/Submitted.vue'
import RequestDeposit from '../../pages/user/workspace/requestIssue/Deposit.vue'
import RequestDeposited from '../../pages/user/workspace/requestIssue/Deposited.vue'

//Workspace Proposals
import MyWorkspaceProposals from '../../pages/user/workspace/proposalManage/Home.vue'

//Message Hub
import MessageHub from '../../pages/user/messages/Home.vue'

//Provider Hub
import ProviderHub from '../../pages/user/providers/Home.vue'

//Request Hub
import RequestHub from '../../pages/user/requests/Home.vue'
import MakeProposal from '../../pages/user/requests/Propose.vue'
import ProposalSubmitted from '../../pages/user/requests/ProposalSubmitted.vue'

import RequestManage from '../../pages/user/workspace/requestManage/Manage.vue'
import ReviewProposalBeforeAccetance from '../../pages/user/workspace/requestManage/ReviewProposal.vue'
import UserProfile from '../../pages/user/account/UserProfile.vue'
import UserFinance from '../../pages/user/account/UserFinance.vue'
import UserHistory from '../../pages/user/account/UserHistory.vue'
import Workspace from '../../pages/user/workspace/Home.vue'

import FooterGuest from '../../footers/FooterGuest.vue'
import FooterUser from '../../footers/FooterUser.vue'

import HeaderGuest from '../../headers/HeaderGuest.vue'
import HeaderUser from '../../headers/HeaderUser.vue'

//Lab
import LabHome from '../../pages/lab/Home.vue'
import TranslationHome from '../../pages/lab/translation/Home.vue'

const router = createRouter({
  history: createWebHistory(),
  routes: [
    { path: '/', redirect: '/front-door' },
    /*
    {
      path: '/users',
      components: {
        default: UsersList,
        footer: UsersFooter
      },
      beforeEnter(to, from, next) {
        console.log('users beforeEnter');
        console.log(to, from);
        next();
      }
    },
    { path: '/:notFound(.*)', component: NotFound }
    */ //public
    {
      name: 'about',
      path: '/about',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: About, footer: FooterGuest, header: HeaderGuest }
    },

    {
      name: 'blogs',
      path: '/blogs',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: Blogs, footer: FooterGuest, header: HeaderGuest }
    },

    {
      name: 'career',
      path: '/career',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: Career, footer: FooterGuest, header: HeaderGuest }
    },

    {
      name: 'contact',
      path: '/contact',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: Contact, footer: FooterGuest, header: HeaderGuest }
    },

    {
      name: 'pdf-content-viewer',
      path: '/pdf-content-viewer/:content_id',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: PdfContentViewer, footer: FooterGuest, header: HeaderGuest },
      props: true
    },
    {
      name: 'link-content-viewer',
      path: '/link-content-viewer/:content_link_based64',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: LinkContentViewer, footer: FooterGuest, header: HeaderGuest },
      props: true
    },

    // guest
    {
      name: 'front-door',
      path: '/front-door',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: FrontDoor, footer: FooterGuest, header: HeaderGuest }
      /*children: [
        {
          name: 'team-members',
          path: ':teamId',
          component: TeamMembers,
          props: true
        } // /teams/t1
      ]*/
    },

    {
      name: 'signin-with-email-and-code',
      path: '/signin-with-email-and-code/:email',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: SigninWithEmailAndCode, footer: FooterGuest, header: HeaderGuest },
      props: true
    },

    {
      name: 'signin-with-email-and-password',
      path: '/signin-with-email-and-password/:email',
      meta: { requiredRoles: [userRoleEnum.NONE] },
      components: { default: SigninWithEmailAndPassword, footer: FooterGuest, header: HeaderGuest },
      props: true
    },

    //user

    {
      name: 'new-user-set-password',
      path: '/new-user-set-password',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: NewUserSetPassword, footer: FooterGuest, header: HeaderGuest },
      props: false
    },
    {
      name: 'new-user-set-flid',
      path: '/new-user-set-flid/:suggested_flid',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: NewUserSetFlid, footer: FooterGuest, header: HeaderGuest },
      props: true
    },
    {
      name: 'my-workspace-projects',
      path: '/my-workspace-projects',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MyWorkspaceProjects, footer: FooterUser, header: HeaderUser },
      props: false
    },

    {
      name: 'project-manage',
      path: '/project-manage/:projectId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: ProjectManage, footer: FooterUser, header: HeaderUser },
      props: true,
      children: [
        {
          name: 'project-manage-code',
          path: 'code',
          components: { default: ProjectManageCode },
          props: true
        },
        {
          name: 'project-manage-deploy',
          path: 'deploy',
          components: { default: ProjectManageDeploy },
          props: true
        },
        {
          name: 'project-manage-general',
          path: 'general',
          components: { default: ProjectManageGeneral },
          props: true
        },
        {
          name: 'project-manage-issues',
          path: 'issues',
          components: { default: ProjectManageIssues },
          props: true
        },
        {
          name: 'project-manage-product',
          path: 'product',
          components: { default: ProjectManageProduct },
          props: true
        },
        {
          name: 'project-manage-progress',
          path: 'progress',
          components: { default: ProjectManageProgress },
          props: true
        }
      ]
    },
    {
      name: 'my-workspace-requests',
      path: '/my-workspace-requests',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MyWorkspaceRequests, footer: FooterUser, header: HeaderUser },
      props: false
    },
    {
      name: 'request-issue',
      path: '/request-issue/:loadFrom',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Post' },
      components: { default: IssueRequest, footer: FooterUser, header: HeaderUser },
      props: (route) => {
        /**
         * This would preserve the other route.params object properties overriding only
         * `loadFrom` in case it exists with its integer equivalent, or otherwise with
         * undefined.
         */
        return {
          ...route.params,
          ...{ loadFrom: Number.parseInt(route.params.loadFrom, 10) || undefined }
        }
      }
    },
    {
      name: 'request-issue2',
      path: '/request-issue/:loadFrom/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: IssueRequest, footer: FooterUser, header: HeaderUser },
      props: (route) => {
        /**
         * This would preserve the other route.params object properties overriding only
         * `loadFrom` in case it exists with its integer equivalent, or otherwise with
         * undefined.
         */
        return {
          ...route.params,
          ...{ loadFrom: Number.parseInt(route.params.loadFrom, 10) || undefined }
        }
      }
    },
    {
      name: 'request-submitted',
      path: '/request-submitted/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Post' },
      components: { default: RequestSubmitted, footer: FooterUser, header: HeaderUser },
      props: true
    },
    {
      name: 'request-deposit',
      path: '/request-deposit/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: RequestDeposit, footer: FooterUser, header: HeaderUser },
      props: true
    },
    {
      name: 'request-deposited',
      path: '/request-deposited/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: RequestDeposited, footer: FooterUser, header: HeaderUser },
      props: true
    },
    {
      name: 'my-workspace-proposals',
      path: '/my-workspace-proposals',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MyWorkspaceProposals, footer: FooterUser, header: HeaderUser },
      props: false
    },
    //message hub
    {
      name: 'message-hub',
      path: '/message-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'message' },
      components: { default: MessageHub, footer: FooterUser, header: HeaderUser }
    },
    // provider hub
    {
      name: 'provider-hub',
      path: '/provider-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Providers' },
      components: { default: ProviderHub, footer: FooterUser, header: HeaderUser }
    },
    //request hub
    {
      name: 'request-hub',
      path: '/request-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Requests' },
      components: { default: RequestHub, footer: FooterUser, header: HeaderUser }
    },
    {
      name: 'make-proposal',
      path: '/make-proposal/:requestId/:loadingMode',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MakeProposal, footer: FooterUser, header: HeaderUser },
      props: true
    },
    {
      name: 'proposal-submitted',
      path: '/proposal-submitted/:proposalId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: ProposalSubmitted, footer: FooterUser, header: HeaderUser },
      props: true
    },

    {
      name: 'request-manage',
      path: '/request-manage/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: RequestManage, footer: FooterUser, header: HeaderUser },
      props: true
    },
    {
      name: 'review-proposal-before-acceptance',
      path: '/review-proposal-before-acceptance/:requestId/:proposalId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: {
        default: ReviewProposalBeforeAccetance,
        footer: FooterUser,
        header: HeaderUser
      },
      props: true
    },

    {
      name: 'user-profile',
      path: '/user-profile',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: UserProfile, footer: FooterUser, header: HeaderUser }
    },
    {
      name: 'user-finance',
      path: '/user-finance',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: UserFinance, footer: FooterUser, header: HeaderUser }
    },
    {
      name: 'user-history',
      path: '/user-history',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: UserHistory, footer: FooterUser, header: HeaderUser }
    },
    {
      name: 'work-space',
      path: '/work-space',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Workspace' },
      components: { default: Workspace, footer: FooterUser, header: HeaderUser }
    },
    {
      name: 'lab-home',
      path: '/lab-home',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: LabHome, footer: FooterUser, header: HeaderUser }
    }
    ,
    {
      name: 'machine-translation',
      path: '/machine-translation',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: TranslationHome, footer: FooterUser, header: HeaderUser }
    }
    ],

  linkActiveClass: 'active'
  /*    scrollBehavior(_, _2, savedPosition) {
        if (savedPosition) {
          return savedPosition;
        }
        return { left: 0, top: 0 };
      }
  */
})

router.beforeEach(function (to, from, next) {
  if (to.name == 'front-door') {
    next()
  } else if (to.meta.requiredRoles.includes(userRoleEnum.NONE)) {
    next()
  } else if (to.meta.requiredRoles.includes(store.getters['userProfile/userRole'])) {
    next()
  } else {
    next('/front-door')
  }
})

/*
router.beforeEach(function(to, from, next) {
  console.log('Global beforeEach');
  console.log(to, from);
  if (to.meta.needsAuth) {
    console.log('Needs auth!');
    next();
  } else {
    next();
  }
  // if (to.name === 'team-members') {
  //   next();
  // } else {
  //   next({ name: 'team-members', params: { teamId: 't2' } });
  // }
  // next();
});
 
router.afterEach(function(to, from) {
  // sending analytics data
  console.log('Global afterEach');
  console.log(to, from);
});
*/

export { router }