hzdyjs/mobile/src/common/storage.js

// 用户存储管理工具 - 与mobile工程保持一致

// 会话缓存工具
export const sessionCache = {
    set: (key, value) => {
        try {
            uni.setStorageSync(`session_${key}`, JSON.stringify(value));
        } catch (e) {
            console.error('设置会话缓存失败:', e);
        }
    },

    get: (key) => {
        try {
            const data = uni.getStorageSync(`session_${key}`);
            return data ? JSON.parse(data) : null;
        } catch (e) {
            console.error('获取会话缓存失败:', e);
            return null;
        }
    },

    remove: (key) => {
        try {
            uni.removeStorageSync(`session_${key}`);
        } catch (e) {
            console.error('删除会话缓存失败:', e);
        }
    },
};

// 用户信息缓存工具
export const userStorage = {
    // 保存登录信息
    saveLoginInfo: (loginResult, userInfo) => {
        try {
            // 保存token
            uni.setStorageSync('access_token', loginResult.access_token);

            // 保存用户信息（增加登录时间）
            if (userInfo) {
                const enhancedUserInfo = {
                    ...userInfo,
                    loginTime: new Date().toISOString(),
                    tokenExpireTime: loginResult.expires_in
                        ? new Date(Date.now() + loginResult.expires_in * 1000).toISOString()
                        : null,
                };
                uni.setStorageSync('userInfo', JSON.stringify(enhancedUserInfo));
            }

            // 保存登录状态
            uni.setStorageSync('isLoggedIn', true);

            // 保存其他token信息
            if (loginResult.refresh_token) {
                uni.setStorageSync('refresh_token', loginResult.refresh_token);
            }

            console.log('用户登录信息已保存', {
                hasToken: !!loginResult.access_token,
                hasUserInfo: !!userInfo,
                loginTime: new Date().toLocaleString(),
            });
        } catch (e) {
            console.error('保存登录信息失败:', e);
        }
    },

    // 获取用户信息
    getUserInfo: () => {
        try {
            const userInfo = uni.getStorageSync('userInfo');
            return userInfo ? JSON.parse(userInfo) : null;
        } catch (e) {
            console.error('获取用户信息失败:', e);
            return null;
        }
    },

    // 获取token
    getToken: () => {
        try {
            return uni.getStorageSync('access_token') || '';
        } catch (e) {
            return '';
        }
    },

    // 检查登录状态
    isLoggedIn: () => {
        try {
            const isLoggedIn = uni.getStorageSync('isLoggedIn');
            const token = uni.getStorageSync('access_token');
            return !!(isLoggedIn && token);
        } catch (e) {
            return false;
        }
    },

    // 清除登录信息
    clearLoginInfo: () => {
        try {
            uni.removeStorageSync('access_token');
            uni.removeStorageSync('userInfo');
            uni.removeStorageSync('isLoggedIn');
            console.log('用户登录信息已清除');
        } catch (e) {
            console.error('清除登录信息失败:', e);
        }
    },

    // 清除所有用户相关数据（包括refresh_token等）
    clearAll: () => {
        try {
            // 清除所有登录相关的存储
            uni.removeStorageSync('access_token');
            uni.removeStorageSync('userInfo');
            uni.removeStorageSync('isLoggedIn');
            uni.removeStorageSync('refresh_token');

            // 清除可能存在的其他用户相关数据
            uni.removeStorageSync('userPermissions');
            uni.removeStorageSync('userRoles');
            uni.removeStorageSync('tenantInfo');

            console.log('所有用户相关数据已清除');
        } catch (e) {
            console.error('清除所有用户数据失败:', e);
        }
    },
};

// 数据缓存工具
export const storage = {
    // 设置缓存
    set: (key, value, expire) => {
        try {
            const data = {
                value,
                timestamp: Date.now(),
                expire: expire ? Date.now() + expire * 1000 : null,
            };
            uni.setStorageSync(key, JSON.stringify(data));
        } catch (e) {
            console.error('缓存设置失败:', e);
        }
    },

    // 获取缓存
    get: (key) => {
        try {
            const data = uni.getStorageSync(key);
            if (!data) return null;

            const parsed = JSON.parse(data);

            // 检查是否过期
            if (parsed.expire && Date.now() > parsed.expire) {
                uni.removeStorageSync(key);
                return null;
            }

            return parsed.value;
        } catch (e) {
            console.error('缓存获取失败:', e);
            return null;
        }
    },

    // 删除缓存
    remove: (key) => {
        try {
            uni.removeStorageSync(key);
        } catch (e) {
            console.error('缓存删除失败:', e);
        }
    },

    // 清空缓存
    clear: () => {
        try {
            uni.clearStorageSync();
        } catch (e) {
            console.error('缓存清空失败:', e);
        }
    },
};

// Token测试工具
export const tokenTest = {
    // 测试Token存储
    testTokenStorage: () => {
        console.log('🧪 开始Token存储测试...');

        try {
            // 1. 清除现有Token
            uni.removeStorageSync('access_token');
            console.log('🗑️ 已清除现有Token');

            // 2. 测试存储Token
            const testToken =
                'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIn0.test';
            uni.setStorageSync('access_token', testToken);
            console.log('💾 已存储测试Token');

            // 3. 测试获取Token
            const retrievedToken = uni.getStorageSync('access_token');
            console.log(
                '📖 获取到的Token:',
                retrievedToken ? retrievedToken.substring(0, 30) + '...' : '❌ 为空',
            );

            // 4. 验证Token是否一致
            if (retrievedToken === testToken) {
                console.log('✅ Token存储和获取测试通过');
                return true;
            } else {
                console.log('❌ Token存储和获取测试失败');
                return false;
            }
        } catch (error) {
            console.error('❌ Token测试失败:', error);
            return false;
        }
    },

    // 获取当前存储的Token信息
    getCurrentTokenInfo: () => {
        try {
            const token = uni.getStorageSync('access_token');
            const userInfo = uni.getStorageSync('userInfo');
            const isLoggedIn = uni.getStorageSync('isLoggedIn');

            console.log('📊 当前存储状态:');
            console.log('  🎫 Token:', token ? `存在 (${token.length}字符)` : '❌ 不存在');
            console.log('  👤 用户信息:', userInfo ? '存在' : '❌ 不存在');
            console.log('  🔐 登录状态:', isLoggedIn ? '已登录' : '❌ 未登录');

            return {
                hasToken: !!token,
                tokenLength: token ? token.length : 0,
                hasUserInfo: !!userInfo,
                isLoggedIn: !!isLoggedIn,
            };
        } catch (error) {
            console.error('❌ 获取Token信息失败:', error);
            return null;
        }
    },

    // 清除所有登录信息
    clearAllLoginInfo: () => {
        try {
            uni.removeStorageSync('access_token');
            uni.removeStorageSync('userInfo');
            uni.removeStorageSync('isLoggedIn');
            uni.removeStorageSync('refresh_token');

            console.log('🗑️ 已清除所有登录信息');
            return true;
        } catch (error) {
            console.error('❌ 清除登录信息失败:', error);
            return false;
        }
    },
};