gaoluyang
2026-11-03 2d8b1a28fa5c8b852f0d0078bac4894bfb4abed5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import { computed, reactive } from 'vue';
 
import {
  getAuthPermissionInfoApi,
  getEnabledMenuListApi,
  getUserProfileApi,
  loginApi,
  logoutApi,
  type AuthMenu,
  type EnabledMenu,
  type LoginParams,
  type LoginResult,
  type UserProfile,
} from '../api/auth';
 
const TOKEN_KEY = 'mom_access_token';
const REFRESH_TOKEN_KEY = 'mom_refresh_token';
const USER_KEY = 'mom_user_profile';
const PERMISSIONS_KEY = 'mom_permissions';
const MENUS_KEY = 'mom_access_menus_api';
const ROLES_KEY = 'mom_user_roles';
const ENABLED_MENUS_KEY = 'mom_enabled_menus';
function readStorage<T>(key: string): T | null {
  try {
    return uni.getStorageSync(key) || null;
  } catch {
    return null;
  }
}
 
const state = reactive({
  accessToken: readStorage<string>(TOKEN_KEY),
  refreshToken: readStorage<string>(REFRESH_TOKEN_KEY),
  user: readStorage<UserProfile>(USER_KEY),
  permissions: readStorage<string[]>(PERMISSIONS_KEY) ?? [],
  menus: readStorage<AuthMenu[]>(MENUS_KEY) ?? [],
  roles: readStorage<string[]>(ROLES_KEY) ?? [],
  enabledMenus: readStorage<EnabledMenu[]>(ENABLED_MENUS_KEY) ?? [],
});
 
function saveUser(user: UserProfile | null) {
  state.user = user;
  if (user) {
    uni.setStorageSync(USER_KEY, user);
  } else {
    uni.removeStorageSync(USER_KEY);
  }
}
 
function savePermissionInfo(data: { permissions: string[]; menus: AuthMenu[]; roles: string[] }) {
  state.permissions = data.permissions || [];
  state.menus = data.menus || [];
  state.roles = data.roles || [];
  uni.setStorageSync(PERMISSIONS_KEY, state.permissions);
  uni.setStorageSync(MENUS_KEY, state.menus);
  uni.setStorageSync(ROLES_KEY, state.roles);
}
 
function saveEnabledMenus(menus: EnabledMenu[]) {
  state.enabledMenus = menus || [];
  uni.setStorageSync(ENABLED_MENUS_KEY, state.enabledMenus);
}
 
function clearPermissionInfo() {
  state.permissions = [];
  state.menus = [];
  state.roles = [];
  uni.removeStorageSync(PERMISSIONS_KEY);
  uni.removeStorageSync(MENUS_KEY);
  uni.removeStorageSync(ROLES_KEY);
  state.enabledMenus = [];
  uni.removeStorageSync(ENABLED_MENUS_KEY);
}
 
function clearSession() {
    state.accessToken = null;
    state.refreshToken = null;
    uni.removeStorageSync(TOKEN_KEY);
    uni.removeStorageSync(REFRESH_TOKEN_KEY);
    saveUser(null);
    clearPermissionInfo();
  }
 
  uni.$on('auth-expired', clearSession);
 
export function useAuth() {
  const isLoggedIn = computed(() => Boolean(state.accessToken));
 
  function hasPermission(code: string) {
    return state.permissions.includes(code);
  }
 
  async function initializeSession(result: LoginResult) {
    state.accessToken = result.accessToken;
    state.refreshToken = result.refreshToken;
    uni.setStorageSync(TOKEN_KEY, result.accessToken);
    uni.setStorageSync(REFRESH_TOKEN_KEY, result.refreshToken);
 
    try {
      const [user, permissionInfo, enabledMenus] = await Promise.all([
        getUserProfileApi(result.accessToken),
        getAuthPermissionInfoApi(result.accessToken),
        getEnabledMenuListApi(result.accessToken),
      ]);
      saveUser(user);
      savePermissionInfo(permissionInfo);
      saveEnabledMenus(enabledMenus);
    } catch (error) {
      clearSession();
      throw error;
    }
  }
 
  async function login(params: LoginParams) {
    await initializeSession(await loginApi(params));
  }
 
  async function restoreUser() {
    if (!state.accessToken) return;
    try {
      if (!state.user) {
        saveUser(await getUserProfileApi(state.accessToken));
      }
      if ((!state.menus.length && !state.permissions.length) || !state.enabledMenus.length) {
        const [permissionInfo, enabledMenus] = await Promise.all([
          getAuthPermissionInfoApi(state.accessToken),
          getEnabledMenuListApi(state.accessToken),
        ]);
        savePermissionInfo(permissionInfo);
        saveEnabledMenus(enabledMenus);
      }
    } catch {
      clearSession();
    }
  }
 
  async function refreshPermissionInfo() {
    if (!state.accessToken) {
      clearPermissionInfo();
      return;
    }
    const [permissionInfo, enabledMenus] = await Promise.all([
      getAuthPermissionInfoApi(state.accessToken),
      getEnabledMenuListApi(state.accessToken),
    ]);
    savePermissionInfo(permissionInfo);
    saveEnabledMenus(enabledMenus);
  }
 
  async function logout() {
    const accessToken = state.accessToken;
    clearSession();
    if (accessToken) {
      try {
        await logoutApi(accessToken);
      } catch {
        // 本地登录状态已经清理,无需阻断退出流程
      }
    }
  }
 
  return {
    state,
    isLoggedIn,
    hasPermission,
    login,
    logout,
    restoreUser,
    refreshPermissionInfo,
  };
}