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[]> {
+  async getCurrentUserMenuTree(): Promise<ResultDomain<MenuTreeNode>> {
-    const response = await api.get<SysMenu>('/menus/user-tree');
+    const response = await api.get<MenuTreeNode>('/menus/user-tree');
-    return response.data.dataList! as MenuTreeNode[];
+    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[]> {
+  async getMenuTree(): Promise<ResultDomain<MenuTreeNode>> {
-    const response = await api.get<SysMenu>('/menus/tree');
+    const response = await api.get<MenuTreeNode>('/menus/tree');
-    return response.data.dataList! as MenuTreeNode[];
+    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;
+  }
+};

schoolNewsWeb/src/types/ai/index.ts

@@ -0,0 +1,169 @@
+/**
+ * @description 智能体相关类型定义
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { BaseDTO } from '../base';
+
+/**
+ * 智能体配置实体
+ */
+export interface AiAgentConfig extends BaseDTO {
+  /** 智能体名称 */
+  name?: string;
+  /** 智能体头像 */
+  avatar?: string;
+  /** 系统提示词 */
+  systemPrompt?: string;
+  /** 模型名称 */
+  modelName?: string;
+  /** 模型提供商 */
+  modelProvider?: string;
+  /** 温度值 */
+  temperature?: number;
+  /** 最大tokens */
+  maxTokens?: number;
+  /** Top P值 */
+  topP?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * 对话会话实体
+ */
+export interface AiConversation extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 会话标题 */
+  title?: string;
+  /** 状态（0已结束 1进行中） */
+  status?: number;
+  /** 消息数量 */
+  messageCount?: number;
+  /** 最后消息时间 */
+  lastMessageTime?: string;
+}
+
+/**
+ * 对话消息实体
+ */
+export interface AiMessage extends BaseDTO {
+  /** 会话ID */
+  conversationID?: string;
+  /** 用户ID */
+  userID?: string;
+  /** 角色（user用户 assistant助手 system系统） */
+  role?: string;
+  /** 消息内容 */
+  content?: string;
+  /** 关联文件ID（JSON数组） */
+  fileIDs?: string;
+  /** 引用知识ID（JSON数组） */
+  knowledgeIDs?: string;
+  /** Token数量 */
+  tokenCount?: number;
+}
+
+/**
+ * 知识库实体
+ */
+export interface AiKnowledge extends BaseDTO {
+  /** 知识标题 */
+  title?: string;
+  /** 知识内容 */
+  content?: string;
+  /** 知识类型（1文本 2文件） */
+  type?: number;
+  /** 文件ID */
+  fileID?: string;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+  /** 创建者 */
+  creator?: string;
+}
+
+/**
+ * 上传文件实体
+ */
+export interface AiUploadFile extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 文件名 */
+  fileName?: string;
+  /** 文件路径 */
+  filePath?: string;
+  /** 文件大小 */
+  fileSize?: number;
+  /** 文件类型 */
+  fileType?: string;
+  /** 状态（0处理中 1成功 2失败） */
+  status?: number;
+  /** 错误信息 */
+  errorMessage?: string;
+}
+
+/**
+ * 使用统计实体
+ */
+export interface AiUsageStatistics extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 统计日期 */
+  statisticsDate?: string;
+  /** 对话次数 */
+  conversationCount?: number;
+  /** 消息数量 */
+  messageCount?: number;
+  /** Token使用量 */
+  tokenUsage?: number;
+  /** 文件上传次数 */
+  fileUploadCount?: number;
+}
+
+/**
+ * 对话请求参数
+ */
+export interface ChatRequest {
+  /** 会话ID */
+  conversationID?: string;
+  /** 消息内容 */
+  message?: string;
+  /** 文件ID列表 */
+  fileIDs?: string[];
+  /** 是否流式返回 */
+  stream?: boolean;
+}
+
+/**
+ * 对话响应参数
+ */
+export interface ChatResponse {
+  /** 消息ID */
+  messageID?: string;
+  /** 消息内容 */
+  content?: string;
+  /** Token使用量 */
+  tokenUsage?: number;
+  /** 是否完成 */
+  isComplete?: boolean;
+}
+
+/**
+ * 文件上传响应
+ */
+export interface FileUploadResponse {
+  /** 文件ID */
+  fileID?: string;
+  /** 文件名 */
+  fileName?: string;
+  /** 文件大小 */
+  fileSize?: number;
+  /** 处理状态 */
+  status?: number;
+}

schoolNewsWeb/src/types/enums/index.ts

@@ -76,3 +76,117 @@ export enum LoginType {
   PASSWORD = 'password'
 }
 
+/**
+ * 资源状态枚举
+ */
+export enum ResourceStatus {
+  /** 草稿 */
+  DRAFT = 0,
+  /** 已发布 */
+  PUBLISHED = 1,
+  /** 下架 */
+  OFFLINE = 2
+}
+
+/**
+ * 课程状态枚举
+ */
+export enum CourseStatus {
+  /** 未上线 */
+  OFFLINE = 0,
+  /** 已上线 */
+  ONLINE = 1,
+  /** 已下架 */
+  DISABLED = 2
+}
+
+/**
+ * 学习任务状态枚举
+ */
+export enum LearningTaskStatus {
+  /** 草稿 */
+  DRAFT = 0,
+  /** 进行中 */
+  IN_PROGRESS = 1,
+  /** 已结束 */
+  COMPLETED = 2
+}
+
+/**
+ * 收藏类型枚举
+ */
+export enum CollectionType {
+  /** 资源 */
+  RESOURCE = 1,
+  /** 课程 */
+  COURSE = 2
+}
+
+/**
+ * 资源类型枚举
+ */
+export enum ResourceType {
+  /** 资源 */
+  RESOURCE = 1,
+  /** 课程 */
+  COURSE = 2,
+  /** 章节 */
+  CHAPTER = 3
+}
+
+/**
+ * Banner链接类型枚举
+ */
+export enum BannerLinkType {
+  /** 资源 */
+  RESOURCE = 1,
+  /** 课程 */
+  COURSE = 2,
+  /** 外部链接 */
+  EXTERNAL = 3
+}
+
+/**
+ * 智能体消息角色枚举
+ */
+export enum AiMessageRole {
+  /** 用户 */
+  USER = 'user',
+  /** 助手 */
+  ASSISTANT = 'assistant',
+  /** 系统 */
+  SYSTEM = 'system'
+}
+
+/**
+ * 积分变动类型枚举
+ */
+export enum PointsType {
+  /** 获得 */
+  EARN = 1,
+  /** 消费 */
+  CONSUME = 2
+}
+
+/**
+ * 文件状态枚举
+ */
+export enum FileStatus {
+  /** 处理中 */
+  PROCESSING = 0,
+  /** 成功 */
+  SUCCESS = 1,
+  /** 失败 */
+  FAILED = 2
+}
+
+/**
+ * 数据采集状态枚举
+ */
+export enum CollectionStatus {
+  /** 失败 */
+  FAILED = 0,
+  /** 成功 */
+  SUCCESS = 1
+}
+

schoolNewsWeb/src/types/index.ts

@@ -25,6 +25,18 @@ export * from './permission';
 // 认证相关
 export * from './auth';
 
+// 资源相关
+export * from './resource';
+
+// 学习相关
+export * from './study';
+
+// 智能体相关
+export * from './ai';
+
+// 用户中心相关
+export * from './usercenter';
+
 // 枚举类型
 export * from './enums';
 

schoolNewsWeb/src/types/resource/index.ts

@@ -0,0 +1,213 @@
+/**
+ * @description 资源相关类型定义
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { BaseDTO } from '../base';
+
+/**
+ * 资源实体
+ */
+export interface Resource extends BaseDTO {
+  /** 资源标题 */
+  title?: string;
+  /** 资源内容 */
+  content?: string;
+  /** 资源简介 */
+  summary?: string;
+  /** 封面图片 */
+  coverImage?: string;
+  /** 分类ID */
+  categoryID?: string;
+  /** 作者 */
+  author?: string;
+  /** 来源 */
+  source?: string;
+  /** 来源URL */
+  sourceUrl?: string;
+  /** 浏览次数 */
+  viewCount?: number;
+  /** 点赞次数 */
+  likeCount?: number;
+  /** 收藏次数 */
+  collectCount?: number;
+  /** 状态（0草稿 1已发布 2下架） */
+  status?: number;
+  /** 是否推荐 */
+  isRecommend?: boolean;
+  /** 是否轮播 */
+  isBanner?: boolean;
+  /** 发布时间 */
+  publishTime?: string;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * Banner实体
+ */
+export interface Banner extends BaseDTO {
+  /** Banner标题 */
+  title?: string;
+  /** Banner图片URL */
+  imageUrl?: string;
+  /** 链接类型（1资源 2课程 3外部链接） */
+  linkType?: number;
+  /** 关联ID（资源ID或课程ID） */
+  linkID?: string;
+  /** 外部链接URL */
+  linkUrl?: string;
+  /** 排序号 */
+  orderNum?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * 资源分类实体
+ */
+export interface ResourceCategory extends BaseDTO {
+  /** 分类唯一标识 */
+  categoryID?: string;
+  /** 分类名称 */
+  name?: string;
+  /** 父分类ID */
+  parentID?: string;
+  /** 分类描述 */
+  description?: string;
+  /** 分类图标 */
+  icon?: string;
+  /** 排序号 */
+  orderNum?: number;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * 资源标签实体
+ */
+export interface ResourceTag extends BaseDTO {
+  /** 资源ID */
+  resourceID?: string;
+  /** 标签ID */
+  tagID?: string;
+}
+
+/**
+ * 标签实体
+ */
+export interface Tag extends BaseDTO {
+  /** 标签名称 */
+  name?: string;
+  /** 标签描述 */
+  description?: string;
+  /** 标签颜色 */
+  color?: string;
+  /** 排序号 */
+  orderNum?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+}
+
+/**
+ * 资源推荐实体
+ */
+export interface ResourceRecommend extends BaseDTO {
+  /** 资源ID */
+  resourceID?: string;
+  /** 推荐类型（1首页推荐 2分类推荐） */
+  recommendType?: number;
+  /** 排序号 */
+  orderNum?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+}
+
+/**
+ * 数据采集配置实体
+ */
+export interface DataCollectionConfig extends BaseDTO {
+  /** 配置名称 */
+  name?: string;
+  /** 采集来源 */
+  source?: string;
+  /** 采集频率（天/周） */
+  frequency?: string;
+  /** 采集规则 */
+  rules?: string;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+}
+
+/**
+ * 数据采集日志实体
+ */
+export interface DataCollectionLog extends BaseDTO {
+  /** 配置ID */
+  configID?: string;
+  /** 采集时间 */
+  collectTime?: string;
+  /** 采集数量 */
+  collectCount?: number;
+  /** 采集状态（0失败 1成功） */
+  status?: number;
+  /** 错误信息 */
+  errorMessage?: string;
+}
+
+/**
+ * 资源搜索参数
+ */
+export interface ResourceSearchParams {
+  /** 关键词 */
+  keyword?: string;
+  /** 分类ID */
+  categoryID?: string;
+  /** 状态 */
+  status?: number;
+  /** 是否推荐 */
+  isRecommend?: boolean;
+  /** 是否轮播 */
+  isBanner?: boolean;
+  /** 作者 */
+  author?: string;
+  /** 开始时间 */
+  startTime?: string;
+  /** 结束时间 */
+  endTime?: string;
+  /** 页码 */
+  page?: number;
+  /** 每页条数 */
+  size?: number;
+}
+
+/**
+ * 资源统计信息
+ */
+export interface ResourceStatistics {
+  /** 总资源数 */
+  totalResources?: number;
+  /** 今日新增 */
+  todayNew?: number;
+  /** 已发布 */
+  published?: number;
+  /** 草稿 */
+  draft?: number;
+  /** 下架 */
+  offline?: number;
+  /** 总浏览量 */
+  totalViews?: number;
+  /** 总点赞数 */
+  totalLikes?: number;
+  /** 总收藏数 */
+  totalCollections?: number;
+}

schoolNewsWeb/src/types/study/index.ts

@@ -0,0 +1,223 @@
+/**
+ * @description 学习相关类型定义
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { BaseDTO } from '../base';
+
+/**
+ * 课程实体
+ */
+export interface Course extends BaseDTO {
+  /** 课程唯一标识 */
+  courseID?: string;
+  /** 课程名称 */
+  name?: string;
+  /** 课程封面图片 */
+  coverImage?: string;
+  /** 课程描述 */
+  description?: string;
+  /** 课程内容 */
+  content?: string;
+  /** 课程时长（分钟） */
+  duration?: number;
+  /** 授课老师 */
+  teacher?: string;
+  /** 状态（0未上线 1已上线 2已下架） */
+  status?: number;
+  /** 浏览次数 */
+  viewCount?: number;
+  /** 学习人数 */
+  learnCount?: number;
+  /** 排序号 */
+  orderNum?: number;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * 课程章节实体
+ */
+export interface CourseChapter extends BaseDTO {
+  /** 章节唯一标识 */
+  chapterID?: string;
+  /** 课程ID */
+  courseID?: string;
+  /** 章节名称 */
+  name?: string;
+  /** 章节内容 */
+  content?: string;
+  /** 章节时长（分钟） */
+  duration?: number;
+  /** 排序号 */
+  orderNum?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+}
+
+/**
+ * 课程标签实体
+ */
+export interface CourseTag extends BaseDTO {
+  /** 课程ID */
+  courseID?: string;
+  /** 标签ID */
+  tagID?: string;
+}
+
+/**
+ * 学习任务实体
+ */
+export interface LearningTask extends BaseDTO {
+  /** 任务唯一标识 */
+  taskID?: string;
+  /** 任务名称 */
+  name?: string;
+  /** 任务描述 */
+  description?: string;
+  /** 开始时间 */
+  startTime?: string;
+  /** 结束时间 */
+  endTime?: string;
+  /** 状态（0草稿 1进行中 2已结束） */
+  status?: number;
+  /** 创建者 */
+  creator?: string;
+  /** 更新者 */
+  updater?: string;
+}
+
+/**
+ * 学习记录实体
+ */
+export interface LearningRecord extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 资源类型（1资源 2课程 3章节） */
+  resourceType?: number;
+  /** 资源ID */
+  resourceID?: string;
+  /** 任务ID */
+  taskID?: string;
+  /** 学习时长（秒） */
+  duration?: number;
+  /** 学习进度（0-100） */
+  progress?: number;
+  /** 是否完成 */
+  isComplete?: boolean;
+  /** 完成时间 */
+  completeTime?: string;
+  /** 最后学习时间 */
+  lastLearnTime?: string;
+}
+
+/**
+ * 学习统计实体
+ */
+export interface LearningStatistics extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 统计日期 */
+  statisticsDate?: string;
+  /** 学习时长（秒） */
+  totalDuration?: number;
+  /** 学习资源数 */
+  resourceCount?: number;
+  /** 完成任务数 */
+  taskCount?: number;
+  /** 获得积分 */
+  points?: number;
+}
+
+/**
+ * 任务用户关联实体
+ */
+export interface TaskUser extends BaseDTO {
+  /** 任务ID */
+  taskID?: string;
+  /** 用户ID */
+  userID?: string;
+  /** 完成状态（0未完成 1已完成） */
+  status?: number;
+  /** 完成时间 */
+  completeTime?: string;
+}
+
+/**
+ * 任务资源关联实体
+ */
+export interface TaskResource extends BaseDTO {
+  /** 任务ID */
+  taskID?: string;
+  /** 资源ID */
+  resourceID?: string;
+  /** 资源类型（1资源 2课程） */
+  resourceType?: number;
+  /** 排序号 */
+  orderNum?: number;
+}
+
+/**
+ * 任务课程关联实体
+ */
+export interface TaskCourse extends BaseDTO {
+  /** 任务ID */
+  taskID?: string;
+  /** 课程ID */
+  courseID?: string;
+  /** 排序号 */
+  orderNum?: number;
+}
+
+/**
+ * 学习计划实体
+ */
+export interface LearningPlan extends BaseDTO {
+  /** 计划名称 */
+  name?: string;
+  /** 计划描述 */
+  description?: string;
+  /** 开始时间 */
+  startTime?: string;
+  /** 结束时间 */
+  endTime?: string;
+  /** 状态（0草稿 1进行中 2已结束） */
+  status?: number;
+  /** 创建者 */
+  creator?: string;
+}
+
+/**
+ * 学习进度统计
+ */
+export interface LearningProgress {
+  /** 用户ID */
+  userID?: string;
+  /** 任务ID */
+  taskID?: string;
+  /** 总任务数 */
+  totalTasks?: number;
+  /** 已完成任务数 */
+  completedTasks?: number;
+  /** 完成百分比 */
+  completionRate?: number;
+  /** 学习时长 */
+  totalDuration?: number;
+}
+
+/**
+ * 学习记录统计
+ */
+export interface LearningRecordStatistics {
+  /** 日期 */
+  date?: string;
+  /** 学习时长 */
+  duration?: number;
+  /** 学习资源数 */
+  resourceCount?: number;
+  /** 完成任务数 */
+  taskCount?: number;
+}

schoolNewsWeb/src/types/usercenter/index.ts

@@ -0,0 +1,143 @@
+/**
+ * @description 用户中心相关类型定义
+ * @author system
+ * @since 2025-10-15
+ */
+
+import { BaseDTO } from '../base';
+
+/**
+ * 用户收藏实体
+ */
+export interface UserCollection extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 收藏类型（1资源 2课程） */
+  collectionType?: number;
+  /** 收藏对象ID */
+  collectionID?: string;
+}
+
+/**
+ * 用户浏览记录实体
+ */
+export interface UserBrowseRecord extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 浏览类型（1资源 2课程） */
+  browseType?: number;
+  /** 浏览对象ID */
+  browseID?: string;
+  /** 浏览时长（秒） */
+  duration?: number;
+  /** 浏览时间 */
+  browseTime?: string;
+}
+
+/**
+ * 用户积分实体
+ */
+export interface UserPoints extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 积分余额 */
+  balance?: number;
+  /** 总获得积分 */
+  totalEarned?: number;
+  /** 总消费积分 */
+  totalConsumed?: number;
+}
+
+/**
+ * 积分记录实体
+ */
+export interface PointsRecord extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 积分变动 */
+  points?: number;
+  /** 变动类型（1获得 2消费） */
+  type?: number;
+  /** 变动原因 */
+  reason?: string;
+  /** 关联对象ID */
+  relatedID?: string;
+  /** 关联对象类型 */
+  relatedType?: number;
+}
+
+/**
+ * 用户成就实体
+ */
+export interface UserAchievement extends BaseDTO {
+  /** 用户ID */
+  userID?: string;
+  /** 成就ID */
+  achievementID?: string;
+  /** 获得时间 */
+  achieveTime?: string;
+}
+
+/**
+ * 成就实体
+ */
+export interface Achievement extends BaseDTO {
+  /** 成就名称 */
+  name?: string;
+  /** 成就描述 */
+  description?: string;
+  /** 成就图标 */
+  icon?: string;
+  /** 成就类型 */
+  type?: number;
+  /** 获得条件 */
+  condition?: string;
+  /** 奖励积分 */
+  rewardPoints?: number;
+  /** 状态（0禁用 1启用） */
+  status?: number;
+}
+
+/**
+ * 个人中心统计信息
+ */
+export interface UserCenterStatistics {
+  /** 收藏数量 */
+  collectionCount?: number;
+  /** 浏览记录数量 */
+  browseCount?: number;
+  /** 学习时长 */
+  learningDuration?: number;
+  /** 完成任务数 */
+  completedTasks?: number;
+  /** 获得积分 */
+  earnedPoints?: number;
+  /** 获得成就数 */
+  achievementCount?: number;
+}
+
+/**
+ * 学习记录图表数据
+ */
+export interface LearningChartData {
+  /** 日期 */
+  date?: string;
+  /** 学习时长（分钟） */
+  duration?: number;
+  /** 学习资源数 */
+  resourceCount?: number;
+}
+
+/**
+ * 资源学习统计
+ */
+export interface ResourceLearningStats {
+  /** 资源ID */
+  resourceID?: string;
+  /** 资源标题 */
+  resourceTitle?: string;
+  /** 学习次数 */
+  learnCount?: number;
+  /** 学习时长 */
+  learnDuration?: number;
+}

schoolNewsWeb/src/views/manage/system/DeptManageView.vue

@@ -256,7 +256,8 @@ function buildParentDeptOptions(depts: SysDept[]): any[] {
 async function loadDeptList() {
   try {
     loading.value = true;
-    const rawData = await deptApi.getAllDepts();
+    const result = await deptApi.getAllDepts();
+    const rawData = result.dataList || [];
     console.log('原始部门数据:', rawData);
     // 将扁平数据转换为树形结构
     deptList.value = buildTree(rawData);
@@ -447,11 +448,12 @@ async function handleBindRole(row: SysDept) {
   
   try {
     // 获取所有角色
-    roleList.value = await roleApi.getAllRoles();
+    const roleResult = await roleApi.getAllRoles();
+    roleList.value = roleResult.dataList || [];
     
     // 获取已绑定的角色
     const bindingResult = await deptApi.getDeptByRole(row);
-    bindList.value.roles = bindingResult || [];
+    bindList.value.roles = bindingResult.dataList || [];
     
     // 设置已选中的角色
     selectedRoles.value = bindList.value.roles.map(role => role.roleID).filter((id): id is string => !!id);

schoolNewsWeb/src/views/manage/system/MenuManageView.vue

@@ -332,7 +332,8 @@ function getMenuTypeText(type: number | undefined): string {
 async function loadMenuList() {
   try {
     loading.value = true;
-    const rawData = await menuApi.getAllMenuList();
+    const result = await menuApi.getAllMenuList();
+    const rawData = result.dataList || [];
     console.log('原始菜单数据:', rawData);
     // 将扁平数据转换为树形结构
     menuList.value = buildTree(rawData);
@@ -534,11 +535,12 @@ async function handleBindPermission(row: SysMenu) {
         code: undefined,
         description: undefined,
     };
-    permissionList.value = await permissionApi.getPermissionList(permission);
+    const permissionResult = await permissionApi.getPermissionList(permission);
+    permissionList.value = permissionResult.dataList || [];
     
     // 获取已绑定的权限
     const bindingResult = await menuApi.getMenuPermission(row.menuID!);
-    bindList.value.permissions = bindingResult || [];
+    bindList.value.permissions = bindingResult.dataList || [];
     
     // 设置已选中的权限
     selectedPermissions.value = bindList.value.permissions.map(permission => permission.permissionID).filter((id): id is string => !!id);

schoolNewsWeb/src/views/manage/system/PermissionManageView.vue

@@ -288,7 +288,8 @@ const formRules: FormRules = {
 async function loadPermissionList() {
   try {
     loading.value = true;
-    permissionList.value = await permissionApi.getPermissionList(queryFilter.value);
+    const result = await permissionApi.getPermissionList(queryFilter.value);
+    permissionList.value = result.dataList || [];
   } catch (error) {
     console.error('加载权限列表失败:', error);
     ElMessage.error('加载权限列表失败');
@@ -318,10 +319,11 @@ async function handleBindMenu(row: SysPermission) {
   try {
     // 获取已绑定的菜单
     const bindingResult = await permissionApi.getPermissionBindingList(row);
-    bindList.value.menus = bindingResult.menus || [];
+    bindList.value.menus = bindingResult.data?.menus || [];
     
     // 获取所有菜单
-    menuList.value = await menuApi.getAllMenuList();
+    const menuResult = await menuApi.getAllMenuList();
+    menuList.value = menuResult.dataList || [];
     
     // 设置已选中的菜单
     selectedMenus.value = bindList.value.menus.map(menu => menu.menuID).filter((id): id is string => !!id);
@@ -343,10 +345,11 @@ async function handleBindRole(row: SysPermission) {
   try {
     // 获取已绑定的角色
     const bindingResult = await permissionApi.getPermissionBindingList(row);
-    bindList.value.roles = bindingResult.roles || [];
+    bindList.value.roles = bindingResult.data?.roles || [];
     
     // 获取所有角色
-    roleList.value = await roleApi.getAllRoles();
+    const roleResult = await roleApi.getAllRoles();
+    roleList.value = roleResult.dataList || [];
     
     // 设置已选中的角色
     selectedRoles.value = bindList.value.roles.map(role => role.id).filter((id): id is string => !!id);

schoolNewsWeb/src/views/manage/system/RoleManageView.vue

@@ -199,7 +199,8 @@ const formRules: FormRules = {
 async function loadRoleList() {
   try {
     loading.value = true;
-    roleList.value = await roleApi.getAllRoles();
+    const result = await roleApi.getAllRoles();
+    roleList.value = result.dataList || [];
   } catch (error) {
     console.error('加载角色列表失败:', error);
     ElMessage.error('加载角色列表失败');
@@ -296,14 +297,15 @@ async function handleBindPermission(row: SysRole) {
       code: undefined,
       description: undefined,
     };
-    permissionList.value = await permissionApi.getPermissionList(permission);
+    const permissionResult = await permissionApi.getPermissionList(permission);
+    permissionList.value = permissionResult.dataList || [];
     
     // 获取已绑定的权限
     const bindingResult = await roleApi.getRolePermission({
       roleID: row.roleID
     });
     console.log('已绑定的权限:', bindingResult);
-    bindList.value.permissions = bindingResult || [];
+    bindList.value.permissions = bindingResult.dataList || [];
     
     // 设置已选中的权限
     selectedPermissions.value = bindList.value.permissions.map(permission => permission.permissionID).filter((id): id is string => !!id);

schoolNewsWeb/src/views/manage/system/UserManageView.vue

@@ -245,8 +245,8 @@ function toggleSelection(item: DeptRoleBindItem) {
 async function loadUserList() {
   try {
     loading.value = true;
-    const users = await userApi.getUserList({id: ""});
+    const result = await userApi.getUserList({id: ""});
-    userList.value = users;
+    userList.value = result.dataList || [];
   } catch (error) {
     console.error('加载用户列表失败:', error);
     ElMessage.error('加载用户列表失败');
@@ -258,11 +258,14 @@ async function loadUserList() {
 // 加载部门和角色数据用于名称映射
 async function loadDeptAndRoleData() {
   try {
-    const [depts, roles] = await Promise.all([
+    const [deptResult, roleResult] = await Promise.all([
       deptApi.getAllDepts(),
       roleApi.getAllRoles()
     ]);
     
+    const depts = deptResult.dataList || [];
+    const roles = roleResult.dataList || [];
+    
     const deptMap = new Map(depts.map(d => [d.deptID, d.name || '未知部门']));
     const roleMap = new Map(roles.map(r => [r.roleID, r.name || '未知角色']));
     
@@ -276,11 +279,13 @@ async function loadDeptAndRoleData() {
 // 加载部门角色绑定列表
 async function loadDeptRoleList(): Promise<DeptRoleBindItem[]> {
   try {
-    const [deptRoles, { deptMap, roleMap }] = await Promise.all([
+    const [deptRoleResult, { deptMap, roleMap }] = await Promise.all([
       deptApi.getDeptRoleList({id: ""}),
       loadDeptAndRoleData()
     ]);
     
+    const deptRoles = deptRoleResult.dataList || [];
+    
     return deptRoles.map(item => ({
       ...item,
       deptName: deptMap.get(item.deptID || '') || `部门${item.deptID}`,
@@ -390,7 +395,8 @@ async function handleBindDeptRole(row: UserVO) {
     bindList.value = await loadDeptRoleList();
     
     // 加载已绑定部门角色
-    const deptRoles = await userApi.getUserDeptRole({userID: currentUser.value.id});
+    const deptRoleResult = await userApi.getUserDeptRole({userID: currentUser.value.id});
+    const deptRoles = deptRoleResult.dataList || [];
     
     // 初始化选中状态为已绑定的项
     selectedBindings.value = bindList.value
@@ -417,7 +423,8 @@ async function saveBindings() {
     submitting.value = true;
     
     // 获取当前已绑定的部门角色
-    const currentBoundItems = await userApi.getUserDeptRole({userID: currentUser.value.id});
+    const currentBoundResult = await userApi.getUserDeptRole({userID: currentUser.value.id});
+    const currentBoundItems = currentBoundResult.dataList || [];
     const currentBoundKeys = currentBoundItems.map(item => `${item.deptID}_${item.roleID}`);
     
     // 找出需要绑定的项（新增的）