mtsd/sqxp-wx/stores/user.js

import { defineStore } from 'pinia'
import { computed, ref } from 'vue'
import { TOKEN_KEY, REFRESH_TOKEN_KEY, USER_INFO_KEY } from '@/config/api'
import { request, parseResponseJson } from '@/utils/request'
import { buildMiniEncryptedLoginBody } from '@/utils/loginRsa'

const PAGE_PATHS = {
  login: '/pages/login/login',
  client: '/pages/client/home/home',
  supplier: '/pages/supplier/home/home',
  deliverer: '/pages/deliverer/home/home'
}

export const useUserStore = defineStore('user', () => {
  const token = ref('')
  const refreshToken = ref('')
  const userInfo = ref(null)
  const isLoading = ref(false)

  function normalizeUserInfo(raw) {
    if (!raw || typeof raw !== 'object') return raw || null
    const avatarUrl =
      raw.avatarUrl != null && String(raw.avatarUrl).trim()
        ? String(raw.avatarUrl).trim()
        : raw.avatar_url != null && String(raw.avatar_url).trim()
          ? String(raw.avatar_url).trim()
          : ''
    return {
      ...raw,
      avatarUrl
    }
  }

  const isLoggedIn = computed(() => !!token.value && !!userInfo.value)
  const userRole = computed(() => userInfo.value?.role || 'client')
  const isClient = computed(() => userRole.value === 'client')
  const isSupplier = computed(() => userRole.value === 'supplier')
  const isDeliverer = computed(() => userRole.value === 'deliver')

  const homePath = computed(() => {
    if (userRole.value === 'supplier') return PAGE_PATHS.supplier
    if (userRole.value === 'deliver') return PAGE_PATHS.deliverer
    return PAGE_PATHS.client
  })

  function checkLoginStatus() {
    const savedToken = uni.getStorageSync(TOKEN_KEY)
    const savedUserInfo = uni.getStorageSync(USER_INFO_KEY)
    const savedRefreshToken = uni.getStorageSync(REFRESH_TOKEN_KEY)
    const normalizedToken =
      typeof savedToken === 'string' ? savedToken.trim() : savedToken ? String(savedToken).trim() : ''

    let normalizedUserInfo = null
    if (typeof savedUserInfo === 'string') {
      try {
        normalizedUserInfo = normalizeUserInfo(JSON.parse(savedUserInfo))
      } catch (error) {
        normalizedUserInfo = null
      }
    } else if (savedUserInfo && typeof savedUserInfo === 'object') {
      normalizedUserInfo = normalizeUserInfo(savedUserInfo)
    }

    if (normalizedToken && normalizedUserInfo) {
      token.value = normalizedToken
      refreshToken.value = typeof savedRefreshToken === 'string' ? savedRefreshToken : ''
      userInfo.value = normalizedUserInfo
      return
    }

    // 本地无有效登录态时，必须同步清空内存态，避免登录页 onShow 误判已登录后跳回首页
    token.value = ''
    refreshToken.value = ''
    userInfo.value = null
  }

  function setLoginInfo(data) {
    token.value = data.token || ''
    refreshToken.value = data.refreshToken || ''
    userInfo.value = normalizeUserInfo(data.userInfo || null)
    uni.setStorageSync(TOKEN_KEY, token.value)
    uni.setStorageSync(REFRESH_TOKEN_KEY, refreshToken.value)
    uni.setStorageSync(USER_INFO_KEY, userInfo.value)
  }

  async function login(params) {
    isLoading.value = true
    try {
      const encryptedBody = await buildMiniEncryptedLoginBody(params.username, params.password)
      const res = await request({
        url: '/mini/auth/login',
        method: 'POST',
        data: encryptedBody
      })
      const result = parseResponseJson(res)
      if (result && result.code === 200 && result.data) {
        setLoginInfo({
          token: result.data.token,
          refreshToken: result.data.refreshToken,
          userInfo: result.data.userInfo
        })
        return true
      }
      uni.showToast({ title: (result && result.message) || '登录失败', icon: 'none' })
      return false
    } catch (error) {
      uni.showToast({
        title: (error && error.message) || '网络请求失败',
        icon: 'none'
      })
      return false
    } finally {
      isLoading.value = false
    }
  }

  function clearLoginInfo() {
    token.value = ''
    refreshToken.value = ''
    userInfo.value = null
    uni.removeStorageSync(TOKEN_KEY)
    uni.removeStorageSync(REFRESH_TOKEN_KEY)
    uni.removeStorageSync(USER_INFO_KEY)
  }

  async function logout() {
    try {
      await request({
        url: '/mini/auth/logout',
        method: 'POST'
      })
    } catch (error) {
      // ignore
    } finally {
      clearLoginInfo()
      uni.reLaunch({ url: PAGE_PATHS.login })
    }
  }

  function navigateToHome() {
    uni.reLaunch({ url: homePath.value })
  }

  function updateUserInfo(info) {
    if (!userInfo.value || !info) return
    userInfo.value = normalizeUserInfo({ ...userInfo.value, ...info })
    uni.setStorageSync(USER_INFO_KEY, userInfo.value)
  }

  async function refreshUserInfo() {
    if (!token.value || !String(token.value).trim()) return
    try {
      const res = await request({
        url: '/mini/auth/current-user',
        method: 'GET'
      })
      const result = parseResponseJson(res)
      if (result.code !== 200 || !result.data) return
      userInfo.value = normalizeUserInfo(result.data)
      uni.setStorageSync(USER_INFO_KEY, userInfo.value)
    } catch {
      // ignore
    }
  }

  return {
    token,
    refreshToken,
    userInfo,
    isLoading,
    isLoggedIn,
    userRole,
    isClient,
    isSupplier,
    isDeliverer,
    homePath,
    checkLoginStatus,
    login,
    logout,
    clearLoginInfo,
    navigateToHome,
    updateUserInfo,
    refreshUserInfo
  }
})