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 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 ProjectIssue from '@/pages/user/workspace/projectIssue/Issue.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 UserHistory from '@/pages/user/account/UserHistory.vue'
import Workspace from '@/pages/user/workspace/Home.vue'

import FooterGuest from '@/footers/FooterGuest.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'
import TaskCompletion from '@/pages/lab/openai/TaskCompletion.vue'
import MultiturnChat from '@/pages/lab/openai/MultiturnChat.vue'
import ImageGeneration from '@/pages/lab/openai/ImageGeneration.vue'

const router = createRouter({
  history: createWebHistory(),
  routes: [
    { path: '/', redirect: '/front-door' },
    /*
    { 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 }
    },

    {
      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-requests',
      path: '/my-workspace-requests',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MyWorkspaceRequests, footer: FooterGuest, header: HeaderUser },
      props: false
    },
    {
      name: 'request-issue',
      path: '/request-issue/:loadFrom',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Post' },
      components: { default: IssueRequest, footer: FooterGuest, 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: 'project-issue',
      path: '/project-issue/:project_id',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: ProjectIssue, footer: FooterGuest, header: HeaderUser },
      props: true
    },
    {
      name: 'request-issue2',
      path: '/request-issue/:loadFrom/:requestId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: IssueRequest, footer: FooterGuest, 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: FooterGuest, header: HeaderUser },
      props: true
    },
    {
      name: 'my-workspace-proposals',
      path: '/my-workspace-proposals',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MyWorkspaceProposals, footer: FooterGuest, header: HeaderUser },
      props: false
    },
    //message hub
    {
      name: 'message-hub',
      path: '/message-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'message' },
      components: { default: MessageHub, footer: FooterGuest, header: HeaderUser }
    },
    // provider hub
    {
      name: 'provider-hub',
      path: '/provider-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Providers' },
      components: { default: ProviderHub, footer: FooterGuest, header: HeaderUser }
    },
    //request hub
    {
      name: 'request-hub',
      path: '/request-hub',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Requests' },
      components: { default: RequestHub, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'make-proposal',
      path: '/make-proposal/:requestId/:loadingMode',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MakeProposal, footer: FooterGuest, header: HeaderUser },
      props: true
    },
    {
      name: 'proposal-submitted',
      path: '/proposal-submitted/:proposalId',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: ProposalSubmitted, footer: FooterGuest, header: HeaderUser },
      props: true
    },

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

    {
      name: 'user-profile',
      path: '/user-profile',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: UserProfile, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'user-history',
      path: '/user-history',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: UserHistory, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'work-space',
      path: '/work-space',
      meta: { requiredRoles: [userRoleEnum.PERSONAL], activePath: 'Workspace' },
      components: { default: Workspace, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'lab-home',
      path: '/lab-home',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: LabHome, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'machine-translation',
      path: '/machine-translation',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: TranslationHome, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'task-completion',
      path: '/task-completion',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: TaskCompletion, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'multiturn-chat',
      path: '/multiturn-chat',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: MultiturnChat, footer: FooterGuest, header: HeaderUser }
    },
    {
      name: 'image-generation',
      path: '/image-generation',
      meta: { requiredRoles: [userRoleEnum.PERSONAL] },
      components: { default: ImageGeneration, footer: FooterGuest, 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 }