ClassMG/entry/src/main/ets/common/DatabaseService.ets
2025-04-01 19:49:15 +08:00

415 lines
12 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { hilog } from '@kit.PerformanceAnalysisKit';
import prompt from '@ohos.promptAction';
import http from '@ohos.net.http';
// User model for storing user information from database
export class UserModel {
account: string = '';
nickname: string = '';
email: string = '';
phone: string = '';
photo: string = '';
category: string = '';
constructor(account: string = '',
nickname: string = '',
email: string = '',
phone: string = '',
photo: string = '',
category: string = '') {
this.account = account;
this.nickname = nickname;
this.email = email;
this.phone = phone;
this.photo = photo || 'http://139.155.155.67:2342/images/default_avatar.png'; // Default photo URL
this.category = category;
}
}
// API响应接口定义
export interface ApiResponse {
success: boolean;
message?: string;
user?: UserInfo;
}
// User info returned from API
export interface UserInfo {
account: string;
nickname: string;
email: string;
phone: string;
photo?: string;
category: string;
}
// API服务配置
export interface ApiConfig {
baseUrl: string;
timeout: number;
}
// 定义API服务配置
const API_CONFIG: ApiConfig = {
// 修改为用户实际使用的服务器地址
baseUrl: 'http://139.155.155.67:2342/api',
timeout: 10000 // 10秒超时
};
// 修正JSON响应类型处理
export type JsonResponse = string | object | ArrayBuffer;
// 真实API实现 - 连接到后端服务
export class DatabaseService {
private static instance: DatabaseService;
// 缓存用户数据减少API调用
private userCache: Map<string, UserModel> = new Map();
// 缓存验证结果
private authCache: Map<string, boolean> = new Map();
// Callbacks for user data changes
private userDataChangeCallbacks: (() => void)[] = [];
private constructor() {
// 初始化缓存
hilog.info(0, 'ClassMG', 'Database Service Initialized');
}
public static getInstance(): DatabaseService {
if (!DatabaseService.instance) {
DatabaseService.instance = new DatabaseService();
}
return DatabaseService.instance;
}
// 创建HTTP请求客户端
private createHttpClient(): http.HttpRequest {
let httpRequest = http.createHttp();
httpRequest.on('headersReceive', (header) => {
hilog.debug(0, 'ClassMG', `Headers received: ${JSON.stringify(header)}`);
});
return httpRequest;
}
// 执行登录验证
public async validateUser(account: string, password: string): Promise<boolean> {
try {
// 生成缓存键
const cacheKey = `${account}:${password}`;
// 检查缓存
if (this.authCache.has(cacheKey)) {
const cachedResult = this.authCache.get(cacheKey);
return cachedResult === true; // 确保返回布尔值
}
// 创建HTTP客户端
const httpRequest = this.createHttpClient();
// 准备登录数据
let loginData = {} as Record<string, string>;
loginData.account = account;
loginData.password = password;
// 发送登录请求
const response = await httpRequest.request(
`${API_CONFIG.baseUrl}/login`,
{
method: http.RequestMethod.POST,
header: {
'Content-Type': 'application/json'
},
extraData: JSON.stringify(loginData),
connectTimeout: API_CONFIG.timeout,
readTimeout: API_CONFIG.timeout
}
);
// 释放HTTP客户端
httpRequest.destroy();
// 检查响应
if (response.responseCode === 200) {
// 使用显式类型转换处理JSON结果
const jsonString: string = response.result ? response.result.toString() : '{}';
try {
const result: ApiResponse = JSON.parse(jsonString) as ApiResponse;
// 缓存结果
const isValid = result.success === true;
this.authCache.set(cacheKey, isValid);
// 如果登录成功且有用户数据,缓存用户信息
if (isValid && result.user) {
const user = new UserModel(
result.user.account,
result.user.nickname,
result.user.email,
result.user.phone,
result.user.photo,
result.user.category
);
this.userCache.set(account, user);
}
return isValid;
} catch (parseError) {
const errorMsg: string = parseError instanceof Error ? parseError.message : String(parseError);
hilog.error(0, 'ClassMG', `Error parsing JSON response: ${errorMsg}`);
}
}
// 默认返回false
return false;
} catch (error) {
hilog.error(0, 'ClassMG', `Error validating user: ${error instanceof Error ? error.message : String(error)}`);
// 临时降级到模拟验证 - 仅用于开发/测试
if (account === '2' || account === '9222' || account === '0') {
return password === '1';
}
return false;
}
}
// 获取用户类别
public getUserCategory(account: string): string {
// 检查缓存
if (this.userCache.has(account)) {
const user = this.userCache.get(account);
return user ? user.category : '';
}
// 降级逻辑 - 当API不可用时
if (account.includes('2')) {
return 'student';
} else if (account.includes('0')) {
return 'teacher';
}
return '';
}
// 获取用户昵称
public getUserNickname(account: string): string {
// 检查缓存
if (this.userCache.has(account)) {
const user = this.userCache.get(account);
return user ? user.nickname : '';
}
// 默认值 - 仅用于开发/测试
if (account === '2') return '张三';
if (account === '9222') return '李华';
if (account === '0') return '教师demo';
return '';
}
// 异步获取用户信息
public async getUserByAccountAsync(account: string): Promise<UserModel | null> {
try {
// 检查缓存
if (this.userCache.has(account)) {
const cachedUser = this.userCache.get(account);
return cachedUser || null;
}
// 创建HTTP客户端
const httpRequest = this.createHttpClient();
// 发送获取用户信息请求
const response = await httpRequest.request(
`${API_CONFIG.baseUrl}/user/${account}`,
{
method: http.RequestMethod.GET,
connectTimeout: API_CONFIG.timeout,
readTimeout: API_CONFIG.timeout
}
);
// 释放HTTP客户端
httpRequest.destroy();
// 检查响应
if (response.responseCode === 200) {
// 使用显式类型转换处理JSON结果
const jsonString: string = response.result ? response.result.toString() : '{}';
try {
const result: ApiResponse = JSON.parse(jsonString) as ApiResponse;
if (result.success && result.user) {
const user = new UserModel(
result.user.account,
result.user.nickname,
result.user.email,
result.user.phone,
result.user.photo,
result.user.category
);
// 更新缓存
this.userCache.set(account, user);
return user;
}
} catch (parseError) {
const errorMsg: string = parseError instanceof Error ? parseError.message : String(parseError);
hilog.error(0, 'ClassMG', `Error parsing JSON response: ${errorMsg}`);
}
}
return null;
} catch (error) {
hilog.error(0, 'ClassMG', `Error getting user: ${error instanceof Error ? error.message : String(error)}`);
// 降级到模拟数据 - 仅用于开发/测试
if (account === '2') {
return new UserModel('2', '张三', 'student@qq.com', '17267383831', '', 'student');
} else if (account === '9222') {
return new UserModel('9222', '李华', 'student123@qq.com', '12345678901', '', 'student');
} else if (account === '0') {
return new UserModel('0', '教师demo', 'teach@qq.com', '', '', 'teacher');
}
return null;
}
}
// 为了兼容性保留的同步方法 - 使用缓存
public getUserByAccount(account: string): UserModel | null {
// 检查缓存
if (this.userCache.has(account)) {
const cachedUser = this.userCache.get(account);
return cachedUser || null;
}
// 如果缓存中没有,返回默认模拟数据
if (account === '2') {
return new UserModel('2', '张三', 'student@qq.com', '17267383831', '', 'student');
} else if (account === '9222') {
return new UserModel('9222', '李华', 'student123@qq.com', '12345678901', '', 'student');
} else if (account === '0') {
return new UserModel('0', '教师demo', 'teach@qq.com', '', '', 'teacher');
}
// 触发异步加载并返回null
this.getUserByAccountAsync(account)
.then((user: UserModel | null) => {
if (user) {
this.notifyUserDataChange();
}
})
.catch((error: Error | string | Object) => {
const errorMsg: string = error instanceof Error ? error.message : String(error);
hilog.error(0, 'ClassMG', `Error in async user fetch: ${errorMsg}`);
});
return null;
}
// 更新用户邮箱 - 连接API
public async updateUserEmail(account: string, newEmail: string): Promise<boolean> {
try {
// 验证邮箱格式
if (!this.validateEmailFormat(newEmail)) {
return false;
}
// 创建HTTP客户端
const httpRequest = this.createHttpClient();
// 准备更新数据
let updateData = {} as Record<string, string>;
updateData.email = newEmail;
// 发送更新请求
const response = await httpRequest.request(
`${API_CONFIG.baseUrl}/user/${account}/email`,
{
method: http.RequestMethod.PUT,
header: {
'Content-Type': 'application/json'
},
extraData: JSON.stringify(updateData),
connectTimeout: API_CONFIG.timeout,
readTimeout: API_CONFIG.timeout
}
);
// 释放HTTP客户端
httpRequest.destroy();
// 检查响应
if (response.responseCode === 200) {
// 使用显式类型转换处理JSON结果
const jsonString: string = response.result ? response.result.toString() : '{}';
try {
const result: ApiResponse = JSON.parse(jsonString) as ApiResponse;
if (result.success) {
// 更新本地缓存
if (this.userCache.has(account)) {
const user = this.userCache.get(account);
if (user) {
user.email = newEmail;
this.userCache.set(account, user);
}
}
// 通知更新
this.notifyUserDataChange();
return true;
}
} catch (parseError) {
const errorMsg: string = parseError instanceof Error ? parseError.message : String(parseError);
hilog.error(0, 'ClassMG', `Error parsing JSON response: ${errorMsg}`);
}
}
return false;
} catch (error) {
const errorMessage: string = error instanceof Error ? error.message : String(error);
hilog.error(0, 'ClassMG', `Error updating user email: ${errorMessage}`);
// 降级到本地更新 - 仅用于开发/测试
if (this.userCache.has(account)) {
const user = this.userCache.get(account);
if (user) {
user.email = newEmail;
this.userCache.set(account, user);
this.notifyUserDataChange();
return true;
}
}
return false;
}
}
// 注册数据变化回调
public registerUserDataChangeCallback(callback: () => void): void {
this.userDataChangeCallbacks.push(callback);
}
// 通知所有回调
private notifyUserDataChange(): void {
this.userDataChangeCallbacks.forEach(callback => {
callback();
});
}
// 验证邮箱格式
public validateEmailFormat(email: string): boolean {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return emailRegex.test(email);
}
// 清除缓存
public clearCache(): void {
this.userCache.clear();
this.authCache.clear();
}
}