ice.fo.utils/TokenUtils.js

import CookieParser from 'set-cookie-parser'
import { ICE_SOURCE_PREFIX, REFRESH_SUFFIX, ROUTE_NAMES, TOKEN_SUFFIX } from 'ice.fo.utils/constants/enums'

export function extractSiteId (context) {
  const { req, $config, route } = context

  const isDynamicPage = [ROUTE_NAMES.DynamicPage, ROUTE_NAMES.BuilderEditablePage].includes(route.name)

  if (!isDynamicPage) {
    const siteIdByRoutePath = route.path.split('/').filter(i => i)[0]
    if (!siteIdByRoutePath) {
      return $config.exclusiveSiteId || $config.defaultSiteId
    } else {
      return siteIdByRoutePath
    }
  }

  let targetPath
  let siteId = ''

  if (process.server) {
    targetPath = req.originalUrl.split(/\?|#/)[0]
  } else {
    targetPath = route.path
  }

  if ($config.dynamicSiteRouting) {
    const pathTokens = targetPath.split('/').filter(key => key.trim())
    siteId = [ROUTE_NAMES.BuilderEditablePage].includes(route.name) ? pathTokens[2] : pathTokens[0]
  } else if ($config.exclusiveSiteId) {
    siteId = $config.exclusiveSiteId
  }

  if (!siteId || siteId == ICE_SOURCE_PREFIX) {
    siteId = $config.defaultSiteId
  }

  if (!siteId) {
    console.error('[ Site ] SiteId is not defined anywhere.')
  }

  return siteId
}

export function requestCookieParser (cookieString = '') {
  const cookies = cookieString.split(';')

  return cookies.reduce((result, current) => {
    if (!current) {
      return result
    }

    const parsed = CookieParser.parse(current.trim())[0]
    result[parsed.name] = parsed.value
    return result
  }, {})
}

export function checkHasToken ({ req, store, $config }) {
  const headers = req.headers
  const requestCookies = headers.cookie
  const parsedOriginCookies = requestCookieParser(requestCookies)

  const siteId = store.getters['ice/siteId']
  const jwtSiteId = $config.ssoSiteId || siteId
  const jwtCookieNm = jwtSiteId + 'SvcJWT'
  const hasToken = !!parsedOriginCookies[jwtCookieNm]

  // return hasToken && !hasSessionSigned
  return hasToken
}

export async function fetchToken (context) {
  const { $axios } = context

  const response = await $axios.request({
    url: '/auth/svc/jwt',
    withCredentials: true,
  })

  if (process.server) {
    const headerCookies = response && response.headers['set-cookie']

    if (!headerCookies) {
      return { response }
    }

    const cookies = headerCookies.reduce((result, item) => {
      const parsed = CookieParser.parse(item)[0]
      result[parsed.name] = parsed.value
      return result
    }, {})

    context.res.setHeader('Set-Cookie', headerCookies)

    return { response, cookies }
  }

  return response
}

export function saveTokens (tokens, context) {
  const { store, $config } = context
  const siteId = store.getters['ice/siteId']
  const jwtSiteId = $config.ssoSiteId || siteId

  store.commit('session/SETJWT', {
    jwt: tokens[`${jwtSiteId}${TOKEN_SUFFIX}`],
    refresh: tokens[`${jwtSiteId}${REFRESH_SUFFIX}`],

    jwt2: tokens.admJWT || tokens.mgjJWT,
  })
}

export function updateCookiesToken (cookies, context) {
  if (process.server && context.req.headers.cookie) {
    const tokens = requestCookieParser(context.req.headers.cookie)

    saveTokens(tokens, context)

    const newCookies = Object.entries({
      ...tokens,
      i18n_redirected: context.i18n.locale,
    }).filter(([, value]) => !!value)

    context.res.setHeader('Set-Cookie', newCookies.map(([key, value]) => `${key}=${value}`).join(';'))

    context.res.cookie('i18n_redirected', context.i18n.locale)
  }

  if (cookies) {
    saveTokens(cookies, context)
  }
}

export async function readSiteInfo ({ store, $axios, $logger }) {
  const siteId = store.getters['ice/siteId']

  if (!siteId) {
    $logger.error('[Read Site Info]', 'SiteId is empty.')
    return siteId
  }

  try {
    const { data } = await $axios.request({
      url: '/svc/service/site',
      params: {
        id: siteId,
      },
      cache: true,
      withCredentials: true,
    })

    if (!data.item) {
      return
    }

    store.commit('site/SET_SITE_INFO', data.item)
    const theme = store.getters['site/theme']

    const { data: siteTheme } = await $axios.request({
      url: '/svc/siteTheme/design',
      params: {
        theme: theme.name,
      },
      cache: true,
      withCredentials: true,
    })

    store.commit('site/SET_SITE_THEME', siteTheme.items[0])
  } catch (e) {
    if (!e.message.includes('ECONNREFUSED')) {
      $logger.error(
        'TokenUtils > Read Site Info',
        `"${siteId}" site does not exist`,
        'Cannot connect to Backend Core',
      )
    }
  }

  return siteId
}