web-apis\types

schoolNewsWeb/src/apis/ai/index.ts

@@ -0,0 +1,236 @@
+/**
+ * @description 智能体相关API
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { api } from '@/apis/index';
+import type { 
+  AiAgentConfig, 
+  AiConversation, 
+  AiMessage, 
+  AiKnowledge, 
+  AiUploadFile,
+  ChatRequest,
+  ChatResponse,
+  FileUploadResponse,
+  ResultDomain
+} from '@/types';
+
+/**
+ * 智能体配置API服务
+ */
+export const aiAgentConfigApi = {
+  /**
+   * 获取智能体配置
+   * @returns Promise<ResultDomain<AiAgentConfig>>
+   */
+  async getAgentConfig(): Promise<ResultDomain<AiAgentConfig>> {
+    const response = await api.get<AiAgentConfig>('/ai/agent-config');
+    return response.data;
+  },
+
+  /**
+   * 更新智能体配置
+   * @param config 配置数据
+   * @returns Promise<ResultDomain<AiAgentConfig>>
+   */
+  async updateAgentConfig(config: AiAgentConfig): Promise<ResultDomain<AiAgentConfig>> {
+    const response = await api.put<AiAgentConfig>('/ai/agent-config', config);
+    return response.data;
+  }
+};
+
+/**
+ * 对话API服务
+ */
+export const conversationApi = {
+  /**
+   * 获取用户对话列表
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<AiConversation>>
+   */
+  async getConversationList(userID: string): Promise<ResultDomain<AiConversation>> {
+    const response = await api.get<AiConversation>('/ai/conversation/list', { userID });
+    return response.data;
+  },
+
+  /**
+   * 创建对话
+   * @param conversation 对话数据
+   * @returns Promise<ResultDomain<AiConversation>>
+   */
+  async createConversation(conversation: AiConversation): Promise<ResultDomain<AiConversation>> {
+    const response = await api.post<AiConversation>('/ai/conversation/create', conversation);
+    return response.data;
+  },
+
+  /**
+   * 删除对话
+   * @param conversationID 对话ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteConversation(conversationID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/ai/conversation/${conversationID}`);
+    return response.data;
+  },
+
+  /**
+   * 清空对话记录
+   * @param conversationID 对话ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async clearConversation(conversationID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.post<boolean>(`/ai/conversation/${conversationID}/clear`);
+    return response.data;
+  }
+};
+
+/**
+ * 消息API服务
+ */
+export const messageApi = {
+  /**
+   * 获取对话消息列表
+   * @param conversationID 对话ID
+   * @returns Promise<ResultDomain<AiMessage>>
+   */
+  async getMessageList(conversationID: string): Promise<ResultDomain<AiMessage>> {
+    const response = await api.get<AiMessage>(`/ai/message/list`, { conversationID });
+    return response.data;
+  },
+
+  /**
+   * 发送消息
+   * @param request 消息请求
+   * @returns Promise<ResultDomain<ChatResponse>>
+   */
+  async sendMessage(request: ChatRequest): Promise<ResultDomain<ChatResponse>> {
+    const response = await api.post<ChatResponse>('/ai/message/send', request);
+    return response.data;
+  },
+
+  /**
+   * 流式发送消息
+   * @param request 消息请求
+   * @param onMessage 消息回调
+   * @returns Promise<void>
+   */
+  // async sendMessageStream(request: ChatRequest, onMessage: (message: string) => void): Promise<void> {
+  //   const response = await api.post('/ai/message/stream', { ...request, stream: true }, {
+  //     responseType: 'stream'
+  //   });
+    
+  //   // 处理流式响应
+  //   const reader = response.data.getReader();
+  //   const decoder = new TextDecoder();
+  //   let done = false;
+
+  //   while (!done) {
+  //     const readResult = await reader.read();
+  //     done = readResult.done;
+  //     if (done) break;
+
+  //     const chunk = decoder.decode(readResult.value);
+  //     const lines = chunk.split('\n');
+      
+  //     for (const line of lines) {
+  //       if (line.startsWith('data: ')) {
+  //         const data = line.slice(6);
+  //         if (data === '[DONE]') return;
+          
+  //         try {
+  //           const parsed = JSON.parse(data);
+  //           onMessage(parsed.content || '');
+  //         } catch (e) {
+  //           console.error('解析流式数据失败:', e);
+  //         }
+  //       }
+  //     }
+  //   }
+  // }
+};
+
+/**
+ * 知识库API服务
+ */
+export const knowledgeApi = {
+  /**
+   * 获取知识库列表
+   * @returns Promise<ResultDomain<AiKnowledge>>
+   */
+  async getKnowledgeList(): Promise<ResultDomain<AiKnowledge>> {
+    const response = await api.get<AiKnowledge>('/ai/knowledge/list');
+    return response.data;
+  },
+
+  /**
+   * 创建知识库条目
+   * @param knowledge 知识库数据
+   * @returns Promise<ResultDomain<AiKnowledge>>
+   */
+  async createKnowledge(knowledge: AiKnowledge): Promise<ResultDomain<AiKnowledge>> {
+    const response = await api.post<AiKnowledge>('/ai/knowledge/create', knowledge);
+    return response.data;
+  },
+
+  /**
+   * 更新知识库条目
+   * @param knowledge 知识库数据
+   * @returns Promise<ResultDomain<AiKnowledge>>
+   */
+  async updateKnowledge(knowledge: AiKnowledge): Promise<ResultDomain<AiKnowledge>> {
+    const response = await api.put<AiKnowledge>('/ai/knowledge/update', knowledge);
+    return response.data;
+  },
+
+  /**
+   * 删除知识库条目
+   * @param knowledgeID 知识库ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteKnowledge(knowledgeID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/ai/knowledge/${knowledgeID}`);
+    return response.data;
+  }
+};
+
+/**
+ * 文件上传API服务
+ */
+export const fileUploadApi = {
+  /**
+   * 上传文件
+   * @param file 文件
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<FileUploadResponse>>
+   */
+  async uploadFile(file: File, userID: string): Promise<ResultDomain<FileUploadResponse>> {
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('userID', userID);
+    
+    const response = await api.upload<FileUploadResponse>('/ai/file/upload', formData);
+    return response.data;
+  },
+
+  /**
+   * 获取上传文件列表
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<AiUploadFile>>
+   */
+  async getUploadFileList(userID: string): Promise<ResultDomain<AiUploadFile>> {
+    const response = await api.get<AiUploadFile>('/ai/file/list', { userID });
+    return response.data;
+  },
+
+  /**
+   * 删除上传文件
+   * @param fileID 文件ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteUploadFile(fileID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/ai/file/${fileID}`);
+    return response.data;
+  }
+};

schoolNewsWeb/src/apis/homepage/index.ts

@@ -0,0 +1,208 @@
+/**
+ * @description 首页相关API
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { api } from '@/apis/index';
+import type { Resource, Banner, ResultDomain } from '@/types';
+
+/**
+ * 首页API服务
+ */
+export const homepageApi = {
+  /**
+   * 获取轮播组件数据
+   * @returns Promise<ResultDomain<Banner>>
+   */
+  async getBannerList(): Promise<ResultDomain<Banner>> {
+    const response = await api.get<Banner>('/homepage/banner/list');
+    return response.data;
+  },
+
+  /**
+   * 点击轮播跳转新闻详情
+   * @param bannerID Banner ID
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getBannerNewsDetail(bannerID: string): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>(`/homepage/banner/click/${bannerID}`);
+    return response.data;
+  },
+
+  /**
+   * 获取活跃轮播列表
+   * @returns Promise<ResultDomain<Banner>>
+   */
+  async getActiveBanners(): Promise<ResultDomain<Banner>> {
+    const response = await api.get<Banner>('/homepage/banner/active');
+    return response.data;
+  },
+
+  /**
+   * 获取TOP资源推荐列表
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getTopRecommendList(): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/recommend/top-list');
+    return response.data;
+  },
+
+  /**
+   * 后台调控展示顺序
+   * @param orderData 排序数据
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async updateRecommendOrder(orderData: any): Promise<ResultDomain<boolean>> {
+    const response = await api.put<boolean>('/homepage/recommend/order', orderData);
+    return response.data;
+  },
+
+  /**
+   * 获取高热度新闻
+   * @param limit 限制数量
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getHotNews(limit?: number): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/recommend/hot-news', { limit });
+    return response.data;
+  },
+
+  /**
+   * 获取思政新闻概览
+   * @param pageNum 页码
+   * @param pageSize 每页条数
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getNewsOverview(pageNum?: number, pageSize?: number): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/news/overview', {
+      pageNum,
+      pageSize
+    });
+    return response.data;
+  },
+
+  /**
+   * 点击跳转二级详情页
+   * @param newsID 新闻ID
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getNewsDetail(newsID: string): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>(`/homepage/news/detail/${newsID}`);
+    return response.data;
+  },
+
+  /**
+   * 获取最新思政新闻
+   * @param limit 限制数量
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async getLatestNews(limit?: number): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/news/latest', { limit });
+    return response.data;
+  },
+
+  /**
+   * 获取顶部菜单栏配置
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getTopMenuConfig(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/menu/top-menu');
+    return response.data;
+  },
+
+  /**
+   * 后台修改菜单名称
+   * @param menuData 菜单数据
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async updateMenuName(menuData: any): Promise<ResultDomain<boolean>> {
+    const response = await api.put<boolean>('/homepage/menu/update-name', menuData);
+    return response.data;
+  },
+
+  /**
+   * 获取菜单项列表
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getMenuList(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/menu/list');
+    return response.data;
+  },
+
+  /**
+   * 模糊检索资源
+   * @param keyword 关键词
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async searchResources(keyword: string): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/search', { keyword });
+    return response.data;
+  },
+
+  /**
+   * 实时搜索建议
+   * @param keyword 关键词
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getSearchSuggestions(keyword: string): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/search/suggestions', { keyword });
+    return response.data;
+  },
+
+  /**
+   * 获取热门搜索词
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getHotKeywords(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/search/hot-keywords');
+    return response.data;
+  },
+
+  /**
+   * 搜索新闻
+   * @param keyword 关键词
+   * @returns Promise<ResultDomain<Resource>>
+   */
+  async searchNews(keyword: string): Promise<ResultDomain<Resource>> {
+    const response = await api.get<Resource>('/homepage/search/news', { keyword });
+    return response.data;
+  },
+
+  /**
+   * 搜索课程
+   * @param keyword 关键词
+   * @returns Promise<ResultDomain<any>>
+   */
+  async searchCourses(keyword: string): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/search/courses', { keyword });
+    return response.data;
+  },
+
+  /**
+   * 获取首页统计数据
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getHomePageStatistics(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/statistics');
+    return response.data;
+  },
+
+  /**
+   * 获取今日访问量
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getTodayVisits(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/statistics/today-visits');
+    return response.data;
+  },
+
+  /**
+   * 获取资源总数
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getTotalResources(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/homepage/statistics/total-resources');
+    return response.data;
+  }
+};

schoolNewsWeb/src/apis/study/index.ts

@@ -0,0 +1,333 @@
+/**
+ * @description 学习相关API
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { api } from '@/apis/index';
+import type { 
+  Course, 
+  CourseChapter, 
+  LearningTask, 
+  LearningRecord, 
+  LearningStatistics,
+  LearningProgress,
+  LearningRecordStatistics,
+  ResultDomain
+} from '@/types';
+
+/**
+ * 课程API服务
+ */
+export const courseApi = {
+  /**
+   * 获取课程列表
+   * @param filter 过滤条件
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async getCourseList(filter?: Partial<Course>): Promise<ResultDomain<Course>> {
+    const response = await api.get<Course>('/study/course/list', filter);
+    return response.data;
+  },
+
+  /**
+   * 根据ID获取课程详情
+   * @param courseID 课程ID
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async getCourseById(courseID: string): Promise<ResultDomain<Course>> {
+    const response = await api.get<Course>(`/study/course/${courseID}`);
+    return response.data;
+  },
+
+  /**
+   * 创建课程
+   * @param course 课程数据
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async createCourse(course: Course): Promise<ResultDomain<Course>> {
+    const response = await api.post<Course>('/study/course/create', course);
+    return response.data;
+  },
+
+  /**
+   * 更新课程
+   * @param course 课程数据
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async updateCourse(course: Course): Promise<ResultDomain<Course>> {
+    const response = await api.put<Course>('/study/course/update', course);
+    return response.data;
+  },
+
+  /**
+   * 删除课程
+   * @param courseID 课程ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteCourse(courseID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/study/course/${courseID}`);
+    return response.data;
+  },
+
+  /**
+   * 更新课程状态
+   * @param courseID 课程ID
+   * @param status 状态
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async updateCourseStatus(courseID: string, status: number): Promise<ResultDomain<Course>> {
+    const response = await api.put<Course>(`/study/course/${courseID}/status`, null, {
+      params: { status }
+    });
+    return response.data;
+  },
+
+  /**
+   * 增加课程浏览次数
+   * @param courseID 课程ID
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async incrementViewCount(courseID: string): Promise<ResultDomain<Course>> {
+    const response = await api.post<Course>(`/study/course/${courseID}/view`);
+    return response.data;
+  },
+
+  /**
+   * 增加课程学习人数
+   * @param courseID 课程ID
+   * @returns Promise<ResultDomain<Course>>
+   */
+  async incrementLearnCount(courseID: string): Promise<ResultDomain<Course>> {
+    const response = await api.post<Course>(`/study/course/${courseID}/learn`);
+    return response.data;
+  },
+
+  /**
+   * 获取课程章节列表
+   * @param courseID 课程ID
+   * @returns Promise<ResultDomain<CourseChapter>>
+   */
+  async getCourseChapters(courseID: string): Promise<ResultDomain<CourseChapter>> {
+    const response = await api.get<CourseChapter>(`/study/course/${courseID}/chapters`);
+    return response.data;
+  },
+
+  /**
+   * 根据ID获取章节详情
+   * @param chapterID 章节ID
+   * @returns Promise<ResultDomain<CourseChapter>>
+   */
+  async getChapterById(chapterID: string): Promise<ResultDomain<CourseChapter>> {
+    const response = await api.get<CourseChapter>(`/study/course/chapter/${chapterID}`);
+    return response.data;
+  },
+
+  /**
+   * 创建课程章节
+   * @param chapter 章节数据
+   * @returns Promise<ResultDomain<CourseChapter>>
+   */
+  async createChapter(chapter: CourseChapter): Promise<ResultDomain<CourseChapter>> {
+    const response = await api.post<CourseChapter>('/study/course/chapter/create', chapter);
+    return response.data;
+  },
+
+  /**
+   * 更新课程章节
+   * @param chapter 章节数据
+   * @returns Promise<ResultDomain<CourseChapter>>
+   */
+  async updateChapter(chapter: CourseChapter): Promise<ResultDomain<CourseChapter>> {
+    const response = await api.put<CourseChapter>('/study/course/chapter/update', chapter);
+    return response.data;
+  },
+
+  /**
+   * 删除课程章节
+   * @param chapterID 章节ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteChapter(chapterID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/study/course/chapter/${chapterID}`);
+    return response.data;
+  },
+
+  /**
+   * 更新章节排序
+   * @param chapterID 章节ID
+   * @param orderNum 排序号
+   * @returns Promise<ResultDomain<CourseChapter>>
+   */
+  async updateChapterOrder(chapterID: string, orderNum: number): Promise<ResultDomain<CourseChapter>> {
+    const response = await api.put<CourseChapter>(`/study/course/chapter/${chapterID}/order`, null, {
+      params: { orderNum }
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 学习任务API服务
+ */
+export const learningTaskApi = {
+  /**
+   * 获取学习任务列表
+   * @param filter 过滤条件
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async getTaskList(filter?: Partial<LearningTask>): Promise<ResultDomain<LearningTask>> {
+    const response = await api.get<LearningTask>('/study/learning-task/list', filter);
+    return response.data;
+  },
+
+  /**
+   * 根据ID获取任务详情
+   * @param taskID 任务ID
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async getTaskById(taskID: string): Promise<ResultDomain<LearningTask>> {
+    const response = await api.get<LearningTask>(`/study/learning-task/${taskID}`);
+    return response.data;
+  },
+
+  /**
+   * 创建学习任务
+   * @param task 任务数据
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async createTask(task: LearningTask): Promise<ResultDomain<LearningTask>> {
+    const response = await api.post<LearningTask>('/study/learning-task/create', task);
+    return response.data;
+  },
+
+  /**
+   * 更新学习任务
+   * @param task 任务数据
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async updateTask(task: LearningTask): Promise<ResultDomain<LearningTask>> {
+    const response = await api.put<LearningTask>('/study/learning-task/update', task);
+    return response.data;
+  },
+
+  /**
+   * 删除学习任务
+   * @param taskID 任务ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async deleteTask(taskID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>(`/study/learning-task/${taskID}`);
+    return response.data;
+  },
+
+  /**
+   * 发布学习任务
+   * @param taskID 任务ID
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async publishTask(taskID: string): Promise<ResultDomain<LearningTask>> {
+    const response = await api.post<LearningTask>(`/study/learning-task/${taskID}/publish`);
+    return response.data;
+  },
+
+  /**
+   * 获取用户任务进度
+   * @param userID 用户ID
+   * @param taskID 任务ID
+   * @returns Promise<ResultDomain<LearningProgress>>
+   */
+  async getUserTaskProgress(userID: string, taskID: string): Promise<ResultDomain<LearningProgress>> {
+    const response = await api.get<LearningProgress>(`/study/learning-task/${taskID}/progress`, {
+      userID
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 学习记录API服务
+ */
+export const learningRecordApi = {
+  /**
+   * 获取学习记录列表
+   * @param filter 过滤条件
+   * @returns Promise<ResultDomain<LearningRecord>>
+   */
+  async getRecordList(filter?: Partial<LearningRecord>): Promise<ResultDomain<LearningRecord>> {
+    const response = await api.get<LearningRecord>('/study/learning-record/list', filter);
+    return response.data;
+  },
+
+  /**
+   * 创建学习记录
+   * @param record 记录数据
+   * @returns Promise<ResultDomain<LearningRecord>>
+   */
+  async createRecord(record: LearningRecord): Promise<ResultDomain<LearningRecord>> {
+    const response = await api.post<LearningRecord>('/study/learning-record/create', record);
+    return response.data;
+  },
+
+  /**
+   * 更新学习记录
+   * @param record 记录数据
+   * @returns Promise<ResultDomain<LearningRecord>>
+   */
+  async updateRecord(record: LearningRecord): Promise<ResultDomain<LearningRecord>> {
+    const response = await api.put<LearningRecord>('/study/learning-record/update', record);
+    return response.data;
+  },
+
+  /**
+   * 获取用户学习统计
+   * @param userID 用户ID
+   * @param timeRange 时间范围
+   * @returns Promise<ResultDomain<LearningRecordStatistics>>
+   */
+  async getUserLearningStatistics(userID: string, timeRange?: string): Promise<ResultDomain<LearningRecordStatistics>> {
+    const response = await api.get<LearningRecordStatistics>('/study/learning-record/statistics', {
+      userID,
+      timeRange
+    });
+    return response.data;
+  },
+
+  /**
+   * 获取学习时长图表数据
+   * @param userID 用户ID
+   * @param timeRange 时间范围
+   * @returns Promise<ResultDomain<LearningRecordStatistics>>
+   */
+  async getLearningDurationChart(userID: string, timeRange?: string): Promise<ResultDomain<LearningRecordStatistics>> {
+    const response = await api.get<LearningRecordStatistics>('/study/learning-record/duration-chart', {
+      userID,
+      timeRange
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 学习计划API服务
+ */
+export const learningPlanApi = {
+  /**
+   * 获取学习计划列表
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async getPlanList(): Promise<ResultDomain<LearningTask>> {
+    const response = await api.get<LearningTask>('/study/learning-plan/list');
+    return response.data;
+  },
+
+  /**
+   * 根据ID获取计划详情
+   * @param planID 计划ID
+   * @returns Promise<ResultDomain<LearningTask>>
+   */
+  async getPlanById(planID: string): Promise<ResultDomain<LearningTask>> {
+    const response = await api.get<LearningTask>(`/study/learning-plan/${planID}`);
+    return response.data;
+  }
+};

schoolNewsWeb/src/apis/system/auth.ts

@@ -5,7 +5,7 @@
  */
 
 import { api } from '@/apis/index';
-import type { LoginParam, LoginDomain } from '@/types';
+import type { LoginParam, LoginDomain, ResultDomain } from '@/types';
 
 /**
  * 认证API服务
@@ -14,58 +14,58 @@ export const authApi = {
   /**
    * 用户登录
    * @param loginParam 登录参数
-   * @returns Promise<LoginDomain>
+   * @returns Promise<ResultDomain<LoginDomain>>
    */
-  async login(loginParam: LoginParam): Promise<LoginDomain> {
+  async login(loginParam: LoginParam): Promise<ResultDomain<LoginDomain>> {
     const response = await api.post<LoginDomain>('/auth/login', loginParam);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 用户登出
-   * @returns Promise<string>
+   * @returns Promise<ResultDomain<string>>
    */
-  async logout(): Promise<string> {
+  async logout(): Promise<ResultDomain<string>> {
     const response = await api.post<string>('/auth/logout');
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 获取验证码
-   * @returns Promise<{captchaId: string, captchaImage: string}>
+   * @returns Promise<ResultDomain<{captchaId: string, captchaImage: string}>>
    */
-  async getCaptcha(): Promise<{ captchaId: string; captchaImage: string }> {
+  async getCaptcha(): Promise<ResultDomain<{ captchaId: string; captchaImage: string }>> {
     const response = await api.get<{ captchaId: string; captchaImage: string }>('/auth/captcha');
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 刷新Token
-   * @returns Promise<string>
+   * @returns Promise<ResultDomain<string>>
    */
-  async refreshToken(): Promise<string> {
+  async refreshToken(): Promise<ResultDomain<string>> {
     const response = await api.post<string>('/auth/refresh-token');
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 发送手机验证码
    * @param phone 手机号
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async sendSmsCode(phone: string): Promise<boolean> {
+  async sendSmsCode(phone: string): Promise<ResultDomain<boolean>> {
     const response = await api.post<boolean>('/auth/send-sms-code', { phone });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 发送邮箱验证码
    * @param email 邮箱
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async sendEmailCode(email: string): Promise<boolean> {
+  async sendEmailCode(email: string): Promise<ResultDomain<boolean>> {
     const response = await api.post<boolean>('/auth/send-email-code', { email });
-    return response.data.data!;
+    return response.data;
   }
 };
 

schoolNewsWeb/src/apis/system/dept.ts

@@ -5,7 +5,7 @@
  */
 
 import { api } from '@/apis/index';
-import type { SysDept, SysRole, DeptRoleVO, SysDeptRole } from '@/types';
+import type { SysDept, SysRole, DeptRoleVO, SysDeptRole, ResultDomain } from '@/types';
 
 /**
  * 部门API服务
@@ -13,120 +13,120 @@ import type { SysDept, SysRole, DeptRoleVO, SysDeptRole } from '@/types';
 export const deptApi = {
   /**
    * @description    查询所有部门
-   * @returns Promise<SysDept[]> 部门列表
+   * @returns Promise<ResultDomain<SysDept>> 部门列表
    * @author    yslg
    * @ since 2025-10-06
    */
-  async getAllDepts(): Promise<SysDept[]> {
+  async getAllDepts(): Promise<ResultDomain<SysDept>> {
     const response = await api.post<SysDept>('/depts/all');
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    查询部门列表
    * @param    filter 过滤条件
-   * @returns Promise<SysDept[]> 部门列表
+   * @returns Promise<ResultDomain<SysDept>> 部门列表
    * @author    yslg
    * @ since 2025-10-06
    */
-  async getDeptList(filter: SysDept): Promise<SysDept[]> {
+  async getDeptList(filter: SysDept): Promise<ResultDomain<SysDept>> {
     const response = await api.post<SysDept>('/depts/list', filter);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    查询部门
    * @param    dept 部门信息
-   * @returns Promise<SysDept> 部门信息
+   * @returns Promise<ResultDomain<SysDept>> 部门信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async getDeptById(dept: SysDept): Promise<SysDept> {
+  async getDeptById(dept: SysDept): Promise<ResultDomain<SysDept>> {
     const response = await api.post<SysDept>('/depts/id', dept);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    创建部门
    * @param    dept 部门信息
-   * @returns Promise<SysDept> 部门信息
+   * @returns Promise<ResultDomain<SysDept>> 部门信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async createDept(dept: SysDept): Promise<SysDept> {
+  async createDept(dept: SysDept): Promise<ResultDomain<SysDept>> {
     const response = await api.post<SysDept>('/depts/dept', dept);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    更新部门
    * @param    dept 部门信息
-   * @returns Promise<SysDept> 部门信息
+   * @returns Promise<ResultDomain<SysDept>> 部门信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async updateDept(dept: SysDept): Promise<SysDept> {
+  async updateDept(dept: SysDept): Promise<ResultDomain<SysDept>> {
     const response = await api.put<SysDept>('/depts/dept', dept);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    删除部门
    * @param    dept 部门信息
-   * @returns Promise<SysDept> 部门信息
+   * @returns Promise<ResultDomain<SysDept>> 部门信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async deleteDept(dept: SysDept): Promise<SysDept> {
+  async deleteDept(dept: SysDept): Promise<ResultDomain<SysDept>> {
     const response = await api.delete<SysDept>('/depts/dept', dept);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    查询部门绑定角色
    * @param    dept 部门信息
-   * @returns Promise<SysRole[]> 角色列表
+   * @returns Promise<ResultDomain<SysRole>> 角色列表
    * @author    yslg
    * @ since 2025-10-06
    */
-  async getDeptByRole(dept: SysDept): Promise<SysRole[]> {
+  async getDeptByRole(dept: SysDept): Promise<ResultDomain<SysRole>> {
     const response = await api.post<SysRole>('/depts/role', dept);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    查询部门角色列表
    * @param    dept 部门角色信息
-   * @returns Promise<SysDeptRole[]> 部门角色列表
+   * @returns Promise<ResultDomain<SysDeptRole>> 部门角色列表
    * @author    yslg
    * @ since 2025-10-06
    */
-  async getDeptRoleList(dept: SysDeptRole): Promise<SysDeptRole[]> {
+  async getDeptRoleList(dept: SysDeptRole): Promise<ResultDomain<SysDeptRole>> {
     const response = await api.post<SysDeptRole>('/depts/role/list', dept);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    绑定部门角色
    * @param    deptRole 部门角色VO
-   * @returns Promise<SysDeptRole> 部门角色信息
+   * @returns Promise<ResultDomain<SysDeptRole>> 部门角色信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async bindDeptRole(deptRole: DeptRoleVO): Promise<SysDeptRole> {
+  async bindDeptRole(deptRole: DeptRoleVO): Promise<ResultDomain<SysDeptRole>> {
     const response = await api.post<SysDeptRole>('/depts/bind/role', deptRole);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    解绑部门角色
    * @param    deptRole 部门角色VO
-   * @returns Promise<SysDeptRole> 部门角色信息
+   * @returns Promise<ResultDomain<SysDeptRole>> 部门角色信息
    * @author    yslg
    * @ since 2025-10-06
    */
-  async unbindDeptRole(deptRole: DeptRoleVO): Promise<SysDeptRole> {
+  async unbindDeptRole(deptRole: DeptRoleVO): Promise<ResultDomain<SysDeptRole>> {
     const response = await api.post<SysDeptRole>('/depts/unbind/role', deptRole);
-    return response.data.data!;
+    return response.data;
   }
 };

schoolNewsWeb/src/apis/system/menu.ts

@@ -5,7 +5,7 @@
  */
 
 import { api } from '@/apis/index';
-import type { SysMenu, MenuTreeNode, SysPermission } from '@/types';
+import type { SysMenu, MenuTreeNode, SysPermission, ResultDomain } from '@/types';
 
 /**
  * 菜单API服务
@@ -13,100 +13,100 @@ import type { SysMenu, MenuTreeNode, SysPermission } from '@/types';
 export const menuApi = {
   /**
    * 获取当前用户的菜单树
-   * @returns Promise<MenuTreeNode[]>
+   * @returns Promise<ResultDomain<MenuTreeNode>>
    */
-  async getCurrentUserMenuTree(): Promise<MenuTreeNode[]> {
-    const response = await api.get<SysMenu>('/menus/user-tree');
-    return response.data.dataList! as MenuTreeNode[];
+  async getCurrentUserMenuTree(): Promise<ResultDomain<MenuTreeNode>> {
+    const response = await api.get<MenuTreeNode>('/menus/user-tree');
+    return response.data;
   },
 
   /**
    * 获取所有菜单列表
-   * @returns Promise<SysMenu[]>
+   * @returns Promise<ResultDomain<SysMenu>>
    */
-  async getAllMenuList(): Promise<SysMenu[]> {
+  async getAllMenuList(): Promise<ResultDomain<SysMenu>> {
     const response = await api.post<SysMenu>('/menus/all');
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * 获取菜单列表
    * @param filter 过滤条件
-   * @returns Promise<SysMenu[]>
+   * @returns Promise<ResultDomain<SysMenu>>
    */
-  async getMenuList(filter: SysMenu): Promise<SysMenu[]> {
+  async getMenuList(filter: SysMenu): Promise<ResultDomain<SysMenu>> {
     const response = await api.post<SysMenu>('/menus/list', filter);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * 获取菜单树
-   * @returns Promise<MenuTreeNode[]>
+   * @returns Promise<ResultDomain<MenuTreeNode>>
    */
-  async getMenuTree(): Promise<MenuTreeNode[]> {
-    const response = await api.get<SysMenu>('/menus/tree');
-    return response.data.dataList! as MenuTreeNode[];
+  async getMenuTree(): Promise<ResultDomain<MenuTreeNode>> {
+    const response = await api.get<MenuTreeNode>('/menus/tree');
+    return response.data;
   },
 
   /**
    * 根据ID获取菜单
    * @param menuID 菜单ID
-   * @returns Promise<SysMenu>
+   * @returns Promise<ResultDomain<SysMenu>>
    */
-  async getMenuById(menuID: string): Promise<SysMenu> {
+  async getMenuById(menuID: string): Promise<ResultDomain<SysMenu>> {
     const response = await api.get<SysMenu>(`/menus`, {  menuID  });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 创建菜单
    * @param menu 菜单信息
-   * @returns Promise<string> 返回菜单ID
+   * @returns Promise<ResultDomain<string>> 返回菜单ID
    */
-  async createMenu(menu: SysMenu): Promise<string> {
+  async createMenu(menu: SysMenu): Promise<ResultDomain<string>> {
     const response = await api.post<string>('/menu', menu);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 更新菜单
    * @param menuID 菜单ID
    * @param menu 菜单信息
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async updateMenu(menu: SysMenu): Promise<boolean> {
+  async updateMenu(menu: SysMenu): Promise<ResultDomain<boolean>> {
     const response = await api.put<boolean>(`/menus`, menu);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 删除菜单
    * @param menuID 菜单ID
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async deleteMenu(menuID: string): Promise<boolean> {
+  async deleteMenu(menuID: string): Promise<ResultDomain<boolean>> {
     const response = await api.delete<boolean>(`/menus`, {  menuID  });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 获取子菜单列表
    * @param parentID 父菜单ID
-   * @returns Promise<SysMenu[]>
+   * @returns Promise<ResultDomain<SysMenu>>
    */
-  async getChildMenus(parentID: string): Promise<SysMenu[]> {
+  async getChildMenus(parentID: string): Promise<ResultDomain<SysMenu>> {
     const response = await api.get<SysMenu>(`/menus/children`, {  parentID  });
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * 获取菜单权限
    * @param menuID 菜单ID
-   * @returns Promise<SysPermission[]>
+   * @returns Promise<ResultDomain<SysPermission>>
    */
-  async getMenuPermission(menuID: string): Promise<SysPermission[]> {
+  async getMenuPermission(menuID: string): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>(`/menus/permission`, {  menuID  });
-    return response.data.dataList!;
+    return response.data;
   }
 };
 

schoolNewsWeb/src/apis/system/permission.ts

@@ -4,7 +4,7 @@
  * @since 2025-10-06
  */
 import { api } from '@/apis/index';
-import { SysPermission } from '@/types';
+import { SysPermission, ResultDomain } from '@/types';
 
 
 export const permissionApi = {
@@ -15,9 +15,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async getPermission(permission: SysPermission|null=null): Promise<SysPermission[]> {
+  async getPermission(permission: SysPermission|null=null): Promise<ResultDomain<SysPermission>> {
     const response = await api.get<SysPermission>('/permissions/permission', permission);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
@@ -26,9 +26,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async addPermission(permission: SysPermission): Promise<SysPermission[]> {
+  async addPermission(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/permission', permission);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
@@ -37,9 +37,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async updatePermission(permission: SysPermission): Promise<SysPermission[]> {
+  async updatePermission(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.put<SysPermission>('/permissions/permission', permission);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
@@ -48,9 +48,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async deletePermission(permission: SysPermission): Promise<SysPermission[]> {
+  async deletePermission(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.delete<SysPermission>('/permissions/permission', permission);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
@@ -59,9 +59,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async getPermissionList(permission: SysPermission|null=null): Promise<SysPermission[]> {
+  async getPermissionList(permission: SysPermission|null=null): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/list', permission);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
@@ -70,9 +70,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async getPermissionBindingList(permission: SysPermission): Promise<SysPermission> {
+  async getPermissionBindingList(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/list/binding', permission);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
@@ -81,9 +81,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async bindMenu(permission: SysPermission): Promise<SysPermission> {
+  async bindMenu(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/bind/menu', permission);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
@@ -92,9 +92,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async bindRole(permission: SysPermission): Promise<SysPermission> {
+  async bindRole(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/bind/role', permission);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
@@ -103,9 +103,9 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async unbindMenu(permission: SysPermission): Promise<SysPermission> {
+  async unbindMenu(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/unbind/menu', permission);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
@@ -114,8 +114,8 @@ export const permissionApi = {
    * @author    yslg
    * @ since 2025-10-08
    */
-  async unbindRole(permission: SysPermission): Promise<SysPermission> {
+  async unbindRole(permission: SysPermission): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/permissions/unbind/role', permission);
-    return response.data.data!;
+    return response.data;
   }
 }

schoolNewsWeb/src/apis/system/role.ts

@@ -5,7 +5,7 @@
  */
 
 import { api } from '@/apis/index';
-import type { SysPermission, SysRole, SysRolePermission } from '@/types';
+import type { SysPermission, SysRole, SysRolePermission, ResultDomain } from '@/types';
 
 /**
  * 角色API服务
@@ -13,84 +13,84 @@ import type { SysPermission, SysRole, SysRolePermission } from '@/types';
 export const roleApi = {
   /**
    * @description    获取所有角色
-   * @returns Promise<SysRole[]> 角色列表
+   * @returns Promise<ResultDomain<SysRole>> 角色列表
    * @author    yslg
    * @ since 2025-10-09
    */
-  async getAllRoles(): Promise<SysRole[]> {
+  async getAllRoles(): Promise<ResultDomain<SysRole>> {
     const response = await api.post<SysRole>('/roles/all');
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    根据角色ID获取角色
    * @param    role 角色信息
-   * @returns Promise<SysRole> 角色信息
+   * @returns Promise<ResultDomain<SysRole>> 角色信息
    * @author    yslg
    * @ since 2025-10-09
    */
-  async getRoleById(role: SysRole): Promise<SysRole> {
+  async getRoleById(role: SysRole): Promise<ResultDomain<SysRole>> {
     const response = await api.post<SysRole>('/roles/id', role);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    根据过滤条件获取角色列表
    * @param    filter 过滤条件
-   * @returns Promise<SysRole[]> 角色列表
+   * @returns Promise<ResultDomain<SysRole>> 角色列表
    * @author    yslg
    * @ since 2025-10-09
    */
-  async getRoleList(filter: SysRole): Promise<SysRole[]> {
+  async getRoleList(filter: SysRole): Promise<ResultDomain<SysRole>> {
     const response = await api.post<SysRole>('/roles/list', filter);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * @description    创建角色
    * @param    role 角色信息
-   * @returns Promise<SysRole> 角色信息
+   * @returns Promise<ResultDomain<SysRole>> 角色信息
    * @author    yslg
    * @ since 2025-10-09
    */
-  async createRole(role: SysRole): Promise<SysRole> {
+  async createRole(role: SysRole): Promise<ResultDomain<SysRole>> {
     const response = await api.post<SysRole>('/roles/role', role);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    更新角色
    * @param    role 角色信息
-   * @returns Promise<SysRole> 角色信息
+   * @returns Promise<ResultDomain<SysRole>> 角色信息
    * @author    yslg
    * @ since 2025-10-09
    */
-  async updateRole(role: SysRole): Promise<SysRole> {
+  async updateRole(role: SysRole): Promise<ResultDomain<SysRole>> {
     const response = await api.put<SysRole>('/roles/role', role);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    删除角色
    * @param    role 角色信息
-   * @returns Promise<SysRole> 角色信息
+   * @returns Promise<ResultDomain<SysRole>> 角色信息
    * @author    yslg
    * @ since 2025-10-09
    */
-  async deleteRole(role: SysRole): Promise<SysRole> {
+  async deleteRole(role: SysRole): Promise<ResultDomain<SysRole>> {
     const response = await api.delete<SysRole>('/roles/role', role);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * @description    获取角色绑定权限列表
    * @param    role 角色信息
-   * @returns Promise<SysRole> 角色信息
+   * @returns Promise<ResultDomain<SysPermission>> 角色信息
    * @author    yslg
    * @ since 2025-10-09
    */
-  async getRolePermission(role: SysRole): Promise<SysPermission[]> {
+  async getRolePermission(role: SysRole): Promise<ResultDomain<SysPermission>> {
     const response = await api.post<SysPermission>('/roles/permission', role);
-    return response.data.dataList!;
+    return response.data;
   }
 };

schoolNewsWeb/src/apis/system/user.ts

@@ -5,7 +5,7 @@
  */
 
 import { api } from '@/apis/index';
-import type { SysUser, SysUserInfo, UserVO, UserDeptRoleVO, SysUserDeptRole } from '@/types';
+import type { SysUser, SysUserInfo, UserVO, UserDeptRoleVO, SysUserDeptRole, ResultDomain } from '@/types';
 
 /**
  * 用户API服务
@@ -13,158 +13,158 @@ import type { SysUser, SysUserInfo, UserVO, UserDeptRoleVO, SysUserDeptRole } fr
 export const userApi = {
   /**
    * 获取当前用户信息
-   * @returns Promise<UserVO>
+   * @returns Promise<ResultDomain<UserVO>>
    */
-  async getCurrentUser(): Promise<UserVO> {
+  async getCurrentUser(): Promise<ResultDomain<UserVO>> {
     const response = await api.get<UserVO>('/users/current');
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 更新当前用户信息
    * @param user 用户信息
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async updateCurrentUser(user: SysUser): Promise<boolean> {
+  async updateCurrentUser(user: SysUser): Promise<ResultDomain<boolean>> {
     const response = await api.put<boolean>('/users/current', user);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 更新用户详细信息
    * @param userInfo 用户详细信息
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async updateUserInfo(userInfo: SysUserInfo): Promise<boolean> {
+  async updateUserInfo(userInfo: SysUserInfo): Promise<ResultDomain<boolean>> {
     const response = await api.put<boolean>('/users/info', userInfo);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 修改密码
    * @param oldPassword 旧密码
    * @param newPassword 新密码
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async changePassword(oldPassword: string, newPassword: string): Promise<boolean> {
+  async changePassword(oldPassword: string, newPassword: string): Promise<ResultDomain<boolean>> {
     const response = await api.post<boolean>('/users/change-password', {
       oldPassword,
       newPassword
     });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 获取用户列表
    * @param filter 过滤条件
-   * @returns Promise<SysUser[]>
+   * @returns Promise<ResultDomain<SysUser>>
    */
-  async getUserList(filter: SysUser): Promise<SysUser[]> {
+  async getUserList(filter: SysUser): Promise<ResultDomain<SysUser>> {
     const response = await api.post<SysUser>('/users/list', filter);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * 创建用户
    * @param user 用户信息
-   * @returns Promise<SysUser>
+   * @returns Promise<ResultDomain<SysUser>>
    */
-  async createUser(user: SysUser): Promise<SysUser> {
+  async createUser(user: SysUser): Promise<ResultDomain<SysUser>> {
     const response = await api.post<SysUser>('/users/user', user);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 更新用户
    * @param user 用户信息
-   * @returns Promise<SysUser>
+   * @returns Promise<ResultDomain<SysUser>>
    */
-  async updateUser(user: SysUser): Promise<SysUser> {
+  async updateUser(user: SysUser): Promise<ResultDomain<SysUser>> {
     const response = await api.put<SysUser>('/users/user', user);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 删除用户
    * @param user 用户信息
-   * @returns Promise<SysUser>
+   * @returns Promise<ResultDomain<SysUser>>
    */
-  async deleteUser(user: SysUser): Promise<SysUser> {
+  async deleteUser(user: SysUser): Promise<ResultDomain<SysUser>> {
     const response = await api.delete<SysUser>('/users/user', user);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 获取用户部门角色绑定信息
    * @param user 用户信息
-   * @returns Promise<UserDeptRoleVO>
+   * @returns Promise<ResultDomain<SysUserDeptRole>>
    */
-  async getUserDeptRole(user: SysUserDeptRole): Promise<SysUserDeptRole[]> {
+  async getUserDeptRole(user: SysUserDeptRole): Promise<ResultDomain<SysUserDeptRole>> {
     const response = await api.post<SysUserDeptRole>('/users/bind/deptrole/list', user);
-    return response.data.dataList!;
+    return response.data;
   },
 
   /**
    * 绑定用户部门角色
    * @param userDeptRoleVO 用户部门角色绑定信息
-   * @returns Promise<UserDeptRoleVO>
+   * @returns Promise<ResultDomain<UserDeptRoleVO>>
    */
-  async bindUserDeptRole(userDeptRoleVO: UserDeptRoleVO): Promise<UserDeptRoleVO> {
+  async bindUserDeptRole(userDeptRoleVO: UserDeptRoleVO): Promise<ResultDomain<UserDeptRoleVO>> {
     const response = await api.post<UserDeptRoleVO>('/users/bind/deptrole', userDeptRoleVO);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 解绑用户部门角色
    * @param userDeptRoleVO 用户部门角色解绑信息
-   * @returns Promise<UserDeptRoleVO>
+   * @returns Promise<ResultDomain<UserDeptRoleVO>>
    */
-  async unbindUserDeptRole(userDeptRoleVO: UserDeptRoleVO): Promise<UserDeptRoleVO> {
+  async unbindUserDeptRole(userDeptRoleVO: UserDeptRoleVO): Promise<ResultDomain<UserDeptRoleVO>> {
     const response = await api.post<UserDeptRoleVO>('/users/unbind/deptrole', userDeptRoleVO);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 批量删除用户
    * @param userIds 用户ID列表
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async batchDeleteUsers(userIds: string[]): Promise<boolean> {
+  async batchDeleteUsers(userIds: string[]): Promise<ResultDomain<boolean>> {
     const response = await api.post<boolean>('/users/batch-delete', { userIds });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 启用/禁用用户
    * @param userId 用户ID
    * @param status 状态 0-启用 1-禁用
-   * @returns Promise<boolean>
+   * @returns Promise<ResultDomain<boolean>>
    */
-  async changeUserStatus(userId: string, status: number): Promise<boolean> {
+  async changeUserStatus(userId: string, status: number): Promise<ResultDomain<boolean>> {
     const response = await api.patch<boolean>(`/users/${userId}/status`, { status });
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 重置用户密码
    * @param userId 用户ID
-   * @returns Promise<string> 返回新密码
+   * @returns Promise<ResultDomain<string>> 返回新密码
    */
-  async resetPassword(userId: string): Promise<string> {
+  async resetPassword(userId: string): Promise<ResultDomain<string>> {
     const response = await api.post<string>(`/users/${userId}/reset-password`);
-    return response.data.data!;
+    return response.data;
   },
 
   /**
    * 上传用户头像
    * @param file 文件
-   * @returns Promise<string> 返回头像URL
+   * @returns Promise<ResultDomain<string>> 返回头像URL
    */
-  async uploadAvatar(file: File): Promise<string> {
+  async uploadAvatar(file: File): Promise<ResultDomain<string>> {
     const formData = new FormData();
     formData.append('file', file);
     const response = await api.upload<string>('/users/avatar', formData);
-    return response.data.data!;
+    return response.data;
   }
 };
 

schoolNewsWeb/src/apis/usercenter/index.ts

@@ -0,0 +1,339 @@
+/**
+ * @description 用户中心相关API
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { api } from '@/apis/index';
+import type { 
+  UserCollection, 
+  UserBrowseRecord, 
+  UserPoints, 
+  PointsRecord, 
+  UserAchievement, 
+  Achievement,
+  UserCenterStatistics,
+  LearningChartData,
+  ResourceLearningStats,
+  ResultDomain
+} from '@/types';
+
+/**
+ * 用户收藏API服务
+ */
+export const userCollectionApi = {
+  /**
+   * 获取用户收藏列表
+   * @param userID 用户ID
+   * @param collectionType 收藏类型
+   * @returns Promise<ResultDomain<UserCollection>>
+   */
+  async getUserCollections(userID: string, collectionType?: number): Promise<ResultDomain<UserCollection>> {
+    const response = await api.get<UserCollection>('/usercenter/collection/list', {
+      userID,
+      collectionType
+    });
+    return response.data;
+  },
+
+  /**
+   * 添加收藏
+   * @param collection 收藏数据
+   * @returns Promise<ResultDomain<UserCollection>>
+   */
+  async addCollection(collection: UserCollection): Promise<ResultDomain<UserCollection>> {
+    const response = await api.post<UserCollection>('/usercenter/collection/add', collection);
+    return response.data;
+  },
+
+  /**
+   * 取消收藏
+   * @param userID 用户ID
+   * @param collectionType 收藏类型
+   * @param collectionID 收藏对象ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async removeCollection(userID: string, collectionType: number, collectionID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.delete<boolean>('/usercenter/collection/remove', {
+      userID,
+      collectionType,
+      collectionID
+    });
+    return response.data;
+  },
+
+  /**
+   * 检查是否已收藏
+   * @param userID 用户ID
+   * @param collectionType 收藏类型
+   * @param collectionID 收藏对象ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async isCollected(userID: string, collectionType: number, collectionID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.get<boolean>('/usercenter/collection/check', {
+      userID,
+      collectionType,
+      collectionID
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 用户浏览记录API服务
+ */
+export const userBrowseRecordApi = {
+  /**
+   * 获取用户浏览记录
+   * @param userID 用户ID
+   * @param browseType 浏览类型
+   * @returns Promise<ResultDomain<UserBrowseRecord>>
+   */
+  async getUserBrowseRecords(userID: string, browseType?: number): Promise<ResultDomain<UserBrowseRecord>> {
+    const response = await api.get<UserBrowseRecord>('/usercenter/browse-record/list', {
+      userID,
+      browseType
+    });
+    return response.data;
+  },
+
+  /**
+   * 添加浏览记录
+   * @param record 浏览记录数据
+   * @returns Promise<ResultDomain<UserBrowseRecord>>
+   */
+  async addBrowseRecord(record: UserBrowseRecord): Promise<ResultDomain<UserBrowseRecord>> {
+    const response = await api.post<UserBrowseRecord>('/usercenter/browse-record/add', record);
+    return response.data;
+  },
+
+  /**
+   * 清空浏览记录
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async clearBrowseRecords(userID: string): Promise<ResultDomain<boolean>> {
+    const response = await api.post<boolean>('/usercenter/browse-record/clear', { userID });
+    return response.data;
+  }
+};
+
+/**
+ * 用户积分API服务
+ */
+export const userPointsApi = {
+  /**
+   * 获取用户积分信息
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<UserPoints>>
+   */
+  async getUserPoints(userID: string): Promise<ResultDomain<UserPoints>> {
+    const response = await api.get<UserPoints>('/usercenter/points/info', { userID });
+    return response.data;
+  },
+
+  /**
+   * 获取用户积分记录
+   * @param userID 用户ID
+   * @param type 积分类型
+   * @returns Promise<ResultDomain<PointsRecord>>
+   */
+  async getUserPointsRecords(userID: string, type?: number): Promise<ResultDomain<PointsRecord>> {
+    const response = await api.get<PointsRecord>('/usercenter/points/records', {
+      userID,
+      type
+    });
+    return response.data;
+  },
+
+  /**
+   * 消费积分
+   * @param userID 用户ID
+   * @param points 积分数量
+   * @param reason 消费原因
+   * @param relatedID 关联对象ID
+   * @param relatedType 关联对象类型
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async consumePoints(
+    userID: string, 
+    points: number, 
+    reason: string, 
+    relatedID?: string, 
+    relatedType?: number
+  ): Promise<ResultDomain<boolean>> {
+    const response = await api.post<boolean>('/usercenter/points/consume', {
+      userID,
+      points,
+      reason,
+      relatedID,
+      relatedType
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 用户成就API服务
+ */
+export const userAchievementApi = {
+  /**
+   * 获取用户成就列表
+   * @param userID 用户ID
+   * @returns Promise<ResultDomain<UserAchievement>>
+   */
+  async getUserAchievements(userID: string): Promise<ResultDomain<UserAchievement>> {
+    const response = await api.get<UserAchievement>('/usercenter/achievement/user-list', { userID });
+    return response.data;
+  },
+
+  /**
+   * 获取所有成就列表
+   * @returns Promise<ResultDomain<Achievement>>
+   */
+  async getAllAchievements(): Promise<ResultDomain<Achievement>> {
+    const response = await api.get<Achievement>('/usercenter/achievement/list');
+    return response.data;
+  },
+
+  /**
+   * 检查用户成就进度
+   * @param userID 用户ID
+   * @param achievementID 成就ID
+   * @returns Promise<ResultDomain<{ progress: number; isCompleted: boolean }>>
+   */
+  async checkAchievementProgress(userID: string, achievementID: string): Promise<ResultDomain<{ progress: number; isCompleted: boolean }>> {
+    const response = await api.get<{ progress: number; isCompleted: boolean }>('/usercenter/achievement/progress', {
+      userID,
+      achievementID
+    });
+    return response.data;
+  }
+};
+
+/**
+ * 个人中心API服务
+ */
+export const userProfileApi = {
+  /**
+   * 获取个人信息
+   * @returns Promise<ResultDomain<any>>
+   */
+  async getUserProfile(): Promise<ResultDomain<any>> {
+    const response = await api.get<any>('/usercenter/profile/info');
+    return response.data;
+  },
+
+  /**
+   * 更新个人信息
+   * @param userInfo 用户信息
+   * @returns Promise<ResultDomain<any>>
+   */
+  async updateUserProfile(userInfo: any): Promise<ResultDomain<any>> {
+    const response = await api.put<any>('/usercenter/profile/info/update', userInfo);
+    return response.data;
+  },
+
+  /**
+   * 上传用户头像
+   * @param file 头像文件
+   * @returns Promise<ResultDomain<string>>
+   */
+  async uploadAvatar(file: File): Promise<ResultDomain<string>> {
+    const formData = new FormData();
+    formData.append('file', file);
+    
+    const response = await api.upload<string>('/usercenter/profile/avatar/upload', formData);
+    return response.data;
+  },
+
+  /**
+   * 更新用户头像
+   * @param avatarUrl 头像URL
+   * @returns Promise<ResultDomain<string>>
+   */
+  async updateAvatar(avatarUrl: string): Promise<ResultDomain<string>> {
+    const response = await api.put<string>('/usercenter/profile/avatar/update', null, {
+      params: { avatarUrl }
+    });
+    return response.data;
+  },
+
+  /**
+   * 修改密码
+   * @param oldPassword 旧密码
+   * @param newPassword 新密码
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async changePassword(oldPassword: string, newPassword: string): Promise<ResultDomain<boolean>> {
+    const response = await api.put<boolean>('/usercenter/profile/password/change', {
+      oldPassword,
+      newPassword
+    });
+    return response.data;
+  },
+
+  /**
+   * 绑定手机号
+   * @param phone 手机号
+   * @param code 验证码
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async bindPhone(phone: string, code: string): Promise<ResultDomain<boolean>> {
+    const response = await api.put<boolean>('/usercenter/profile/phone/bind', {
+      phone,
+      code
+    });
+    return response.data;
+  },
+
+  /**
+   * 绑定邮箱
+   * @param email 邮箱
+   * @param code 验证码
+   * @returns Promise<ResultDomain<boolean>>
+   */
+  async bindEmail(email: string, code: string): Promise<ResultDomain<boolean>> {
+    const response = await api.put<boolean>('/usercenter/profile/email/bind', {
+      email,
+      code
+    });
+    return response.data;
+  },
+
+  /**
+   * 获取学习记录统计
+   * @param timeRange 时间范围
+   * @returns Promise<ResultDomain<UserCenterStatistics>>
+   */
+  async getLearningStatistics(timeRange?: string): Promise<ResultDomain<UserCenterStatistics>> {
+    const response = await api.get<UserCenterStatistics>('/usercenter/profile/learning/statistics', {
+      timeRange
+    });
+    return response.data;
+  },
+
+  /**
+   * 获取学习时长图表数据
+   * @param timeRange 时间范围
+   * @returns Promise<ResultDomain<LearningChartData>>
+   */
+  async getLearningDurationChart(timeRange?: string): Promise<ResultDomain<LearningChartData>> {
+    const response = await api.get<LearningChartData>('/usercenter/profile/learning/duration-chart', {
+      timeRange
+    });
+    return response.data;
+  },
+
+  /**
+   * 获取资源学习次数图表数据
+   * @param timeRange 时间范围
+   * @returns Promise<ResultDomain<ResourceLearningStats>>
+   */
+  async getResourceLearningChart(timeRange?: string): Promise<ResultDomain<ResourceLearningStats>> {
+    const response = await api.get<ResourceLearningStats>('/usercenter/profile/learning/resource-chart', {
+      timeRange
+    });
+    return response.data;
+  }
+};