使用通义灵码天假注释

lib/apis/account.dart

@@ -2,76 +2,105 @@ part of apis;
 
 abstract class AccountAPI {
 
-  /// 1、登录
+    /// 登录功能
   ///
-  static Future <UserModel> login({
+  /// 参数：
+  /// - phone: 手机号码，必填。
+  /// - type: 登录类型，必填。'1'代表密码登录，'2'代表验证码登录。
+  /// - password: 登录密码，可选。仅在类型为'1'时需要。
+  /// - code: 验证码，可选。仅在类型为'2'时需要。
+  /// - uuid: 验证码的唯一标识，可选。仅在类型为'2'时需要。
+  ///
+  /// 返回值：
+  /// - UserModel: 登录成功时返回的用户模型实例。
+  /// - 如果登录失败或出现异常，可能返回空的UserModel实例。
+  static Future<UserModel> login({
     required String phone,
     required String type,
     String? password,
     String? code,
     String? uuid,
   }) async {
-    // assert((password != null && code == null) ||
-    //     (password == null && code != null),
-    // 'Provide either a password or a verification code, not both.');
-
-    Map<String,dynamic> params = {
-      'phone' : phone,
-      'type' : type,
+    Map<String, dynamic> params = {
+      'phone': phone,
+      'type': type,
     };
 
+    // 根据登录类型添加不同的登录参数
+    if (type == '1') {
       // 密码登录
-    if(type == '1'){
       params['password'] = password;
-    }
+    } else if (type == '2') {
       // 验证码登录
-    if(type == '2'){
       params['code'] = code;
       params['uuid'] = uuid;
     }
+
+    // 发起登录请求
     final result = await HttpService.to.post(
       '/v1/members/login/login',
       excludeToken: true,
       showLoading: true,
       params: params
     );
+
+    // 处理登录响应
     if (result.data is! Map) return UserModel();
     return UserModel.fromJson(result.data);
   }
 
-  /// 2、退出登录
+
+  /// 退出登录
   ///
+  /// 无参数。
+  /// 返回一个Future，如果退出登录成功，则返回true；否则返回false。
   static Future logout() async{
     final result = await HttpService.to.post(
       '/v1/members/login/logout',
       params: {}
     );
+    // 检查退出登录操作是否成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
-  /// 3、注销
+
+  /// 注销当前用户账号
+  ///
+  /// 本函数用于通过向服务器发送请求来注销当前用户的账号。
+  /// 注销成功时，返回值为true；注销失败时，返回值为false。
   ///
   static Future delete() async{
+    // 向服务器发送注销请求
     final result = await HttpService.to.post(
       '/v1/members/login/del',
       params: {}
     );
+    // 检查注销请求的响应结果
     if (result.data is Map && result.data['is_success'] == 1){
+      // 注销成功，返回true
       return true;
     }
+    // 注销失败，返回false
     return false;
   }
 
-  /// 4、发送验证码
+
+  /// 发送验证码
+  ///
+  /// 参数：
+  /// - phone: 需要发送验证码的手机号码，类型为 String，必需。
+  /// - type: 验证码的类型，例如注册、重置密码等，类型为 String，必需。
   ///
+  /// 返回值：
+  /// - Future<bool>: 若发送成功返回 true，否则返回 false。
   static Future sendCode({
     required String phone,
     required String type,
   }) async {
-
+    // 生成设备唯一标识符
     String uuid = '';
     final DeviceInfoPlugin device = DeviceInfoPlugin();
     if(Platform.isIOS){
@@ -82,9 +111,11 @@ abstract class AccountAPI {
       const androidIdPlugin = AndroidId();
       final AndroidDeviceInfo androidInfo = await device.androidInfo;
       uuid = await androidIdPlugin.getId()??'';
+      // 将设备ID与Android设备指纹组合以增加唯一性
       uuid = '$uuid${androidInfo.fingerprint}';
     }
 
+    // 调用HTTP服务发送验证码
     final result = await HttpService.to.post(
       '/v1/members/login/sendCode',
       params: {
@@ -92,23 +123,35 @@ abstract class AccountAPI {
         'types': type,
         'uuid':uuid
       },
-      excludeToken: true,
-      showLoading: true,
+      excludeToken: true, // 不包含令牌信息
+      showLoading: true, // 显示加载提示
     );
+    // 检查发送结果
     if (result.data is Map && result.data['is_success'] == 1){
-      return true;
+      return true; // 成功
     }
-    return false;
+    return false; // 失败
   }
 
-  /// 5、重置密码
+  /// 重置密码
+  ///
+  /// 使用该方法可以通过手机、验证码、新密码和确认新密码来重置用户的密码。
+  ///
+  /// 参数:
+  ///   - phone: 需要重置密码的用户的手机号码。
+  ///   - code: 验证码，发送到用户手机上的用于验证身份的代码。
+  ///   - password: 用户选择的新密码。
+  ///   - rePassword: 确认新密码，需要与新密码一致以确认输入无误。
   ///
+  /// 返回值:
+  ///   - 当密码重置成功时返回 true，否则返回 false。
   static Future resetPassword({
     required String phone,
     required String code,
     required String password,
     required String rePassword,
   }) async {
+    // 向服务器发送POST请求，提交手机、验证码、新密码和确认新密码以重置密码
     final result = await HttpService.to.post(
       '/v1/members/login/editPassword',
       params: {
@@ -117,20 +160,35 @@ abstract class AccountAPI {
         'password': password,
         'repassword': rePassword
       },
-      excludeToken: true,
-      showLoading: true,
+      excludeToken: true, // 不包含令牌信息，因为这是密码重置操作
+      showLoading: true, // 显示加载中的提示
     );
+
+    // 检查服务器返回的结果，如果操作成功，则返回true
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
+
+    // 如果操作失败或有错误，则返回false
     return false;
   }
 
-  /// 6、验证验证码
+  /// 验证验证码
+  ///
+  /// 通过手机号和验证码向服务器验证验证码的正确性。
+  ///
+  /// 参数：
+  /// - phone: 手机号，必填。
+  /// - code: 验证码，必填。
+  ///
+  /// 返回值：
+  /// - 若验证成功，返回true。
+  /// - 若验证失败，返回false。
   static Future checkCode({
     required String phone,
     required String code,
   }) async {
+    // 向服务器发送验证请求
     final result = await HttpService.to.post(
       '/v1/members/login/checkPhoneCode',
       params: {
@@ -140,6 +198,8 @@ abstract class AccountAPI {
       excludeToken: true,
       showLoading: true,
     );
+
+    // 检查验证结果
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
@@ -150,4 +210,5 @@ abstract class AccountAPI {
 
 
 
+
 }
\ No newline at end of file

lib/apis/common.dart

@@ -2,29 +2,46 @@ part of apis;
 
 abstract class CommonAPI {
 
-  /// 1、广告位接口
+  /// 广告位接口的获取列表方法
   ///
+  /// 参数:
+  ///   type: 广告类型，必填参数。
+  ///
+  /// 返回值:
+  ///   返回一个 Future，该 Future 解析为 AdModel 对象的列表。
   static Future <List<AdModel>> list({
     required String type,
   }) async {
+    // 向服务器发送 POST 请求，获取广告列表
     final result = await HttpService.to.post(
       '/v1/ad/ad/getListAll',
       params: {
         'type': type,
       },
     );
+
+    // 如果返回的数据不是预期格式，则直接返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的 JSON 数据转换为 AdModel 对象列表并返回
     return List.generate(result.data['list'].length, (index){
       return AdModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 2、消息接口
+  /// 消息接口的实现，用于获取消息列表。
   ///
+  /// 参数:
+  /// - page: 请求的页码，默认为1。
+  /// - limit: 每页显示的数量，默认为10。
+  ///
+  /// 返回值:
+  /// - 返回一个`Future`，该`Future`解析为`List<MsgModel>`类型的消息列表。
   static Future <List<MsgModel>> msgs({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送POST请求，获取消息列表
     final result = await HttpService.to.post(
       '/v1/message/Message/getList',
       params: {
@@ -32,29 +49,49 @@ abstract class CommonAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回结果是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为`MsgModel`对象列表
     return List.generate(result.data['list'].length, (index){
       return MsgModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 3、消息未读数
+
+  /// 获取未读消息的数量
   ///
+  /// 该函数为静态函数，不需要实例化对象即可调用。
+  /// 无参数输入。
+  ///
+  /// 返回值为一个Future，该Future最终解析为一个int类型，
+  /// 表示未读消息的数量。如果获取失败或数据格式不符合预期，则返回0。
   static Future <int> num() async {
+    // 使用HttpService向指定接口发送POST请求，获取消息数量
     final result = await HttpService.to.post(
       '/v1/message/Message/getMessageNums',
       params: {},
     );
+
+    // 如果返回的数据不是Map类型，则认为获取失败，返回0
     if (result.data is! Map ) return 0;
+
+    // 从返回的Map数据中提取并返回未读消息数量
     return result.data['num'];
   }
 
-  /// 4、最近学习
+
+  /// 获取用户的学习历史记录
+  ///
+  /// - `page`: 请求的页码，默认为1。
+  /// - `limit`: 每页返回的数据条数，默认为10。
   ///
-  static Future <List<StudyHistoryModel>> history({
+  static Future<List<StudyHistoryModel>> history({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送POST请求，获取学习历史记录
     final result = await HttpService.to.post(
       '/v1/members/Information/myReadRecord',
       params: {
@@ -62,36 +99,52 @@ abstract class CommonAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为StudyHistoryModel对象列表并返回
     return List.generate(result.data['list'].length, (index){
       return StudyHistoryModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 5、消息未读变已读
+
+  /// 将指定的消息标记为已读
+  ///
+  /// 参数：
+  ///   id - 消息的唯一标识符，必须提供
   ///
+  /// 返回值：
+  ///   布尔值，表示操作是否成功。如果操作成功，消息将被标记为已读，返回true；否则返回false。
   static Future <bool> read({
     required String id
   }) async {
+    // 向服务器发送请求，以更新消息的状态为已读
     final result = await HttpService.to.post(
       '/v1/message/Message/editOneStatus',
       params: {
         'id':id
       },
     );
+    // 检查服务器返回的结果，确定是否成功更新消息状态
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
+
   /// 6、清除搜索记录
   ///
+  /// 无参数
+  /// 返回值：[Future<bool>]，表示清除操作是否成功。成功返回true，失败返回false。
   static Future <bool> clear() async {
     final result = await HttpService.to.post(
       '/v1/book/Information/serachDel',
       params: {},
     );
+    // 判断返回结果是否表示成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
@@ -100,24 +153,35 @@ abstract class CommonAPI {
 
   /// 7、搜索历史记录
   ///
+  /// 无参数
+  /// 返回值：[Future<List<String>>]，表示搜索历史记录的列表。如果获取失败或无记录，返回空列表。
   static Future <List<String>> searchRecords() async {
     final result = await HttpService.to.post(
       '/v1/book/Information/serachRecord',
       params: {},
     );
+    // 检查返回数据格式是否正确
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 生成搜索记录名称的列表
     return List.generate(result.data['list'].length, (index){
       return result.data['list'][index]['name'];
     });
   }
 
-  /// 8、搜索书籍
+  /// 搜索书籍的函数
+  ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1。
+  /// - limit: 每页返回的结果数量，默认为20。
+  /// - keyWord: 搜索关键词，必需。
   ///
+  /// 返回值：一个 Future 对象，解析为 CourseModel 类型的列表。
   static Future <List<CourseModel>> searchBooks({
     int page = 1,
     int limit = 20,
     required String keyWord
   }) async {
+    // 向服务器发送搜索请求
     final result = await HttpService.to.post(
       '/v1/book/Information/searchBook',
       params: {
@@ -126,80 +190,126 @@ abstract class CommonAPI {
         'keyword':keyWord
       },
     );
+
+    // 如果返回结果不是预期的 Map 类型或没有 'list' 键，则返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的 JSON 数据转换为 CourseModel 对象列表
     return List.generate(result.data['list'].length, (index){
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 9、收藏 取消收藏
+
+  /// 收藏或取消收藏书籍
   ///
+  /// 参数：
+  /// - bookId: 书籍的唯一标识符，必需。
+  /// - love: 表示收藏状态，"1" 表示收藏，"0" 表示取消收藏，必需。
+  ///
+  /// 返回值：操作成功返回 true，失败返回 false。
   static Future <bool> love({
     required String bookId,
     required String love
   }) async {
+    // 向服务器发送收藏或取消收藏的请求
     final result = await HttpService.to.post(
       '/v1/book/Information/collection',
       params: {
-        'book_id':bookId,
-        'is_select':love
+        'book_id': bookId,
+        'is_select': love
       },
     );
+
+    // 检查请求结果，如果请求失败或操作未成功，则返回 false
     if (result.data is! Map || result.data['is_success'] == 0){
       return false;
     }
+
+    // 请求成功且操作成功，返回 true
     return true;
   }
 
-  /// 10、上传文件
+
+  /// 上传文件到服务器
+  ///
+  /// 参数：
+  /// - path: 上传文件的路径
+  /// - fileTypes: 文件类型限制，用于指定可以上传的文件类型
+  ///
+  /// 返回值：上传成功返回文件的URL字符串，失败则返回空字符串
   static Future <String> upload({
     required String path,
     required String fileTypes
   }) async {
+    // 调用HttpService的upload方法进行文件上传
     final result = await HttpService.to.upload(
         '/v1/members/Information/uploadFile',
         path: path,
         fileTypes: fileTypes
     );
+
+    // 检查返回结果是否为Map类型
     if (result.data is! Map) return '';
+
+    // 返回文件的URL
     return result.data['filesUrl'];
   }
 
-  /// 11、获取OSS临时token
+
+  /// 获取OSS临时token的方法
+  /// 该方法为静态方法，无需实例化对象即可调用
+  ///
+  /// 参数：无
+  /// 返回值：一个Future，异步返回一个OssModel类型的对象。如果请求失败或返回数据格式不正确，则返回一个空的OssModel对象。
   static Future <OssModel> oss() async {
+    // 向指定接口发送POST请求，获取OSS上传所需的临时token
     final result = await HttpService.to.post(
       '/v1/common/Alioss/getUploadToken',
     );
+
+    // 判断返回的数据是否为Map类型，若不是则返回一个空的OssModel对象
     if (result.data is! Map ) return OssModel();
+
+    // 将返回的Map数据转换为OssModel对象并返回
     return OssModel.fromJson(result.data);
   }
 
+  /// 刷新令牌的函数
+  /// 无参数
+  /// 返回值：刷新后的token字符串，如果刷新失败或无token返回null
   static Future<String?> refreshToken() async {
-
+    // 打印日志，标记开始刷新token
     Console.log('--------refreshToken----------------');
+    // 向服务器发送请求，以当前的access_token换取新的token
     final result = await HttpService.to.post(
         '/v1/members/login/getToken',
         params: {
           'access_token':StorageService.to.getString(kLocalAccessToken)
         }
     );
+    // 检查返回的结果是否是Map类型
     if (result.data is Map) {
+      // 从返回的结果中提取token和access_token
       final String token = result.data['token'];
       final String accessToken = result.data['access_token'];
+      // 如果新获取的token和access_token都为空，则登出用户并返回null
       if(token.isEmpty && accessToken.isEmpty){
         UserStore.to.logout();
         return null;
       }
+      // 等待异步设置新的token和access_token
       await Future.wait([
         UserStore.to.setToken(result.data['token']),
         UserStore.to.setAccessToken(result.data['access_token']),
       ]);
+      // 返回新获取的token
       return result.data['token'];
     }
-    // 在这里执行刷新token的逻辑
-    // 如果刷新成功，返回新的token；如果刷新失败，返回null
+    // 如果结果处理失败，返回null
     return null;
   }
 
 
+
 }
\ No newline at end of file

lib/apis/course.dart

@@ -2,12 +2,19 @@ part of apis;
 
 abstract class CourseAPI {
 
-  /// 1、获取课程 内书籍列表
+  /// 获取课程内的书籍列表的异步方法。
   ///
+  /// 参数:
+  /// - page: 请求的页码，默认为1。
+  /// - limit: 每页的项数，默认为20。
+  ///
+  /// 返回值: 一个 Future 对象，解析为一个 CourseModel 类型的列表。
+  /// 如果请求失败或返回的数据不符合预期，则返回空列表。
   static Future <List<CourseModel>> list({
       int page = 1,
       int limit = 20,
     }) async {
+      // 向服务器发送 POST 请求，获取课程信息
       final result = await HttpService.to.post(
         '/v1/members/Information/myCourse',
         params: {
@@ -16,7 +23,11 @@ abstract class CourseAPI {
         },
         showLoading: true
       );
+
+      // 检查返回的数据是否符合预期格式
       if (result.data is! Map && result.data['list'] is! List) return [];
+
+      // 将返回的 JSON 数据转换为 CourseModel 对象列表
       return List.generate(result.data['list'].length, (index){
          return CourseModel.fromJson(result.data['list'][index]);
       });

lib/apis/library.dart

@@ -3,34 +3,61 @@ part of apis;
 
 abstract class LibraryAPI {
 
-  /// 1、图书分类
+  /// 获取所有图书分类的列表
   ///
+  /// 该函数不需要任何参数，通过向服务器发送请求以获取所有图书分类的信息。
+  /// 返回值是一个`Future`，该`Future`完成时会返回一个`List<CategoryModel>`。
+  /// 如果请求成功，会将服务器返回的分类列表转换为`CategoryModel`对象的列表；
+  /// 如果请求失败或返回数据格式不符合预期，则返回一个空列表。
   static Future <List<CategoryModel>> categories() async {
     final result = await HttpService.to.post(
       '/v1/book/category/getCategoryListAll',
       params: {},
     );
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 根据返回的数据列表，生成CategoryModel对象列表
     return List.generate(result.data['list'].length, (index){
       return CategoryModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 2、图书标签
+
+  /// 获取全部图书标签的异步方法
   ///
+  /// 该方法不需要任何参数，通过向服务器发送请求以获取标签列表。
+  /// 返回值为一个 `Future`，该 `Future` 在完成时会解析为一个 `List<LabelModel>`。
+  /// 如果请求失败或返回的数据格式不符合预期，则返回空列表 `[]`。
   static Future <List<LabelModel>> labels() async {
+    // 向服务器发送POST请求以获取标签列表
     final result = await HttpService.to.post(
       '/v1/book/category/getLabelListAll',
       params: {},
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 根据返回的数据列表，创建并返回LabelModel的列表
     return List.generate(result.data['list'].length, (index){
       return LabelModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 3、书籍列表
+
+  /// 获取书籍列表的函数
+  ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1。
+  /// - limit: 每页的书籍数量，默认为10。
+  /// - sortField: 排序字段，默认为空字符串。
+  /// - sort: 排序方式，默认为空字符串。
+  /// - isFree: 是否免费，默认为空字符串。
+  /// - labelId: 标签ID，默认为空字符串。
+  /// - categoryId: 类别ID，必需参数。
   ///
+  /// 返回值：
+  /// - 返回一个Future，该Future解析为CourseModel类型的列表。
   static Future <List<CourseModel>> books({
     int page = 1,
     int limit = 10,
@@ -40,11 +67,13 @@ abstract class LibraryAPI {
     String labelId = '',
     required String categoryId
   }) async {
+    // 构建请求参数
     Map<String,dynamic> params = {
       'page' : page,
       'page_size' : limit,
       'category_id':categoryId
     };
+    // 如果相应参数非空，则添加到请求参数中
     if (sortField.isNotEmpty){
       params['sort_field'] = sortField;
     }
@@ -54,27 +83,33 @@ abstract class LibraryAPI {
     if (isFree.isNotEmpty){
       params['is_free'] = isFree;
     }
-    if (sort.isNotEmpty){
-      params['sort'] = sort;
-    }
     if (labelId.isNotEmpty){
       params['label_id'] = labelId;
     }
 
-
+    // 发起POST请求获取书籍列表
     final result = await HttpService.to.post(
       '/v1/book/category/getBookList',
       params: params,
       showLoading: true
     );
+    // 请求结果异常处理，如果不是预期格式则返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 将返回的JSON数据转换为CourseModel列表并返回
     return List.generate(result.data['list'].length, (index){
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 4、评分及书评
+  /// 获取指定书籍的评分及书评列表
   ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1
+  /// - limit: 每页返回的数量，默认为10
+  /// - bookId: 需要查询评分和书评的书籍ID，必须提供
+  ///
+  /// 返回值：
+  /// - 返回一个Future，该Future解析为ScoreModel类型的列表。如果请求失败或数据格式不正确，返回空列表。
   static Future <List<ScoreModel>> scores({
     int page = 1,
     int limit = 10,
@@ -88,14 +123,22 @@ abstract class LibraryAPI {
         'book_id':bookId
       },
     );
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 将返回的JSON数据转换为ScoreModel列表
     return List.generate(result.data['list'].length, (index){
       return ScoreModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 5、获取书籍目录
+
+  /// 获取书籍目录
+  ///
+  /// 参数:
+  ///   - bookId: 需要获取目录的书籍的唯一标识符，类型为String，必需。
   ///
+  /// 返回值:
+  ///   - 一个Future，该Future解析为一个ChapterModel类型的列表。如果请求失败或数据格式不符合预期，则返回空列表。
   static Future <List<ChapterModel>> chapters({
     required String bookId
   }) async {
@@ -105,49 +148,87 @@ abstract class LibraryAPI {
         'book_id':bookId
       },
     );
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 根据返回的数据列表，生成ChapterModel列表
     return List.generate(result.data['list'].length, (index){
       return ChapterModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 6、获取书籍详情
+
+  /// 获取书籍详情的函数。
+  ///
+  /// 通过给定的书籍ID，异步请求服务器获取书籍的详细信息。
   ///
+  /// 参数:
+  /// - bookId: 需要获取详情的书籍的唯一标识符，不能为空。
+  ///
+  /// 返回值:
+  /// - 一个`Future`，异步返回一个`BookDetailModel`类型的对象，
+  ///   如果请求成功，该对象包含书籍的详细信息；如果请求失败或返回数据格式不符，
+  ///   则返回一个空的`BookDetailModel`实例。
   static Future <BookDetailModel> details({
     required String bookId
   }) async {
+    // 向服务器发送POST请求，获取指定书籍的详细信息
     final result = await HttpService.to.post(
       '/v1/book/Information/getBookInformation',
       params: {
         'book_id':bookId
       },
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的BookDetailModel实例
     if (result.data is! Map) return BookDetailModel();
+
+    // 将获取到的数据转换为BookDetailModel实例并返回
     return BookDetailModel.fromJson(result.data);
   }
 
-  /// 6、学习报告
+
+  /// 学习报告
   ///
+  /// 用于获取指定书籍的学习报告。
+  ///
+  /// [bookId] - 必需，指定要获取学习报告的书籍ID。
+  ///
+  /// 返回一个[ReportModel]的Future。如果请求成功，返回学习报告的数据模型；如果请求失败或数据格式不正确，返回一个空的[ReportModel]实例。
   static Future <ReportModel> report({
     required String bookId
   }) async {
+    // 向服务器发送POST请求，获取指定书籍的学习报告
     final result = await HttpService.to.post(
       '/v1/members/Information/myStudyReport',
       params: {
         'book_id':bookId
       },
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的ReportModel实例
     if (result.data is! Map) return ReportModel();
+
+    // 将返回的Map数据转换为ReportModel实例并返回
     return ReportModel.fromJson(result.data);
   }
 
-  /// 7、阅读页 章节笔记列表
+
+  /// 获取指定书籍和章节的笔记列表
   ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1
+  /// - limit: 每页的笔记数量，默认为10
+  /// - bookId: 书籍的唯一标识符，必需
+  /// - chapterId: 章节的唯一标识符，必需
+  ///
+  /// 返回值：
+  /// - 返回一个Future，该Future解析为NoteModel类型的列表。如果请求失败或无笔记，则返回空列表。
   static Future<List<NoteModel>> noteList(
       {int page = 1,
         int limit = 10,
         required String bookId,
         required String chapterId}) async {
+    // 向服务器发送POST请求，获取章节笔记列表
     final result = await HttpService.to.post(
       '/v1/book/Information/getChapterNotesList',
       params: {
@@ -158,19 +239,32 @@ abstract class LibraryAPI {
       },
       // showLoading: true
     );
+
+    // 检查返回结果是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为NoteModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return NoteModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 8、阅读页 章节讨论列表
+
+  /// 获取指定书籍和章节的讨论列表
   ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1
+  /// - limit: 每页的讨论数量，默认为10
+  /// - bookId: 书籍的唯一标识
+  /// - chapterId: 章节的唯一标识
+  ///
+  /// 返回值：一个包含讨论模型列表的Future。如果请求失败或无数据，则返回空列表。
   static Future<List<DiscussModel>> discussList(
       {int page = 1,
         int limit = 10,
         required String bookId,
         required String chapterId}) async {
+    // 向服务器发送POST请求，获取章节讨论列表
     final result = await HttpService.to.post(
       '/v1/book/Information/getChapterCommentList',
       params: {
@@ -181,17 +275,30 @@ abstract class LibraryAPI {
       },
       // showLoading: true,
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为DiscussModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return DiscussModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 9、添加阅读时长
+
+  /// 添加阅读时长
+  ///
+  /// 参数：
+  ///   - bookId: 书籍的唯一标识符，必需。
+  ///   - readTypes: 阅读类型，用于记录不同的阅读方式或场景，必需。
+  ///
+  /// 返回值：
+  ///   - 返回一个Future<bool>，若添加阅读时长成功，则返回true，否则返回false。
   static Future <bool> addReadTime({
     required String bookId,
     required String readTypes
   }) async {
+    // 向服务器发送POST请求，以添加阅读时长
     final result = await HttpService.to.post(
       '/v1/book/Information/addReadTime',
       params: {
@@ -199,13 +306,28 @@ abstract class LibraryAPI {
         'read_types':readTypes
       },
     );
+
+    // 检查请求结果，若添加成功则返回true，否则返回false
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
-  /// 10、发布讨论回复
+
+  /// 发布讨论回复
+  ///
+  /// 请求参数：
+  /// - bookId: 书籍ID，必需
+  /// - chapterId: 章节ID，必需
+  /// - commentId: 评论ID，必需，用于指定回复的评论
+  /// - quoteContent: 引用内容，必需，即回复中被引用的原文内容
+  /// - title: 回复标题，必需
+  /// - content: 回复内容，必需
+  ///
+  /// 返回值：一个包含操作结果的Map<String,dynamic>对象。
+  /// 如果请求成功，Map中'is_success'键的值为1；
+  /// 如果请求失败，返回空Map。
   static Future <Map<String,dynamic>> addDiscuss({
     required String bookId,
     required String chapterId,
@@ -214,6 +336,7 @@ abstract class LibraryAPI {
     required String title,
     required String content,
   }) async {
+    // 发起POST请求，向服务器添加讨论回复
     final result = await HttpService.to.post(
       '/v1/book/Information/addComment',
       params: {
@@ -224,29 +347,53 @@ abstract class LibraryAPI {
         'title':title,
         'content':content
       },
-        showLoading: true
+        showLoading: true // 在发送请求时显示加载指示器
     );
+
+    // 检查请求结果，成功则返回数据，否则返回空Map
     if (result.data is Map && result.data['is_success'] == 1){
       return result.data;
     }
     return {};
   }
 
-  /// 11、获取离线书籍下载地址 和 秘钥串
+
+  /// 获取离线书籍下载地址和秘钥串的函数
+  ///
+  /// 参数：
+  ///  - bookId：必需，书籍的唯一标识符。
+  ///
+  /// 返回值：
+  ///   返回一个 Future，该 Future 解析为 [BookDownloadModel] 类的实例，
+  ///   如果请求失败或数据格式不符合预期，则返回一个空的 [BookDownloadModel] 实例。
   static Future <BookDownloadModel> getbookDownloadParam({
     required String bookId,
   }) async {
+    // 向服务器发送 POST 请求，获取书籍的下载参数
     final result = await HttpService.to.post(
       '/v1/book/Information/bookDownload',
       params: {
         'book_id':bookId,
       },
     );
+
+    // 如果返回的数据不是 Map 类型，则返回一个空的 BookDownloadModel 实例
     if (result.data is! Map) return BookDownloadModel();
+
+    // 将返回的 JSON 数据转换为 BookDownloadModel 实例并返回
     return BookDownloadModel.fromJson(result.data);
   }
 
-  /// 12、根据书籍地址下载书籍
+  /// 根据书籍地址下载书籍的函数
+  ///
+  /// 参数：
+  /// - url: 书籍的下载地址，类型为 String，必需。
+  /// - savePath: 书籍下载后保存的路径，类型为 String，必需。
+  /// - onReceiveProgress: 下载进度的回调函数，为可选参数。类型为 ProgressCallback。
+  ///
+  /// 返回值：无返回值。
+  ///
+  /// 使用 HttpService 的 download 方法进行书籍的下载。
   static Future <void> downBookByUrl({
     required String url,
     required String savePath,
@@ -254,25 +401,47 @@ abstract class LibraryAPI {
   }) async {
     await HttpService.to.download(url, savePath: savePath,onReceiveProgress: onReceiveProgress);
   }
-
-  /// 13、离线重连 上传笔记、高亮、划线
+  /// 离线重连时上传笔记、高亮、划线内容到服务器
+  ///
+  /// 参数：
+  /// - bookId: 书籍的唯一标识符，必需。
+  /// - readTypes: 阅读类型，表示上传的内容类型，如笔记、高亮、划线等，必需。
+  ///
+  /// 返回值：
+  /// - 布尔值，表示上传是否成功。若成功，返回true；否则返回false。
   static Future <bool> uploadContent({
     required String bookId,
     required String readTypes
   }) async {
+    // 使用HttpService向服务器发送POST请求，上传离线笔记等信息
     final result = await HttpService.to.post(
       '/v1/book/Information/addOfflineNotes',
       params: {
         'book_id':bookId,
       },
     );
+    // 检查上传结果，如果服务器返回成功标志，则上传成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
-  /// 14、添加笔记、高亮、划线的内容
+
+  /// 添加笔记、高亮、划线的内容
+  ///
+  /// 参数：
+  /// - bookId: 书籍的唯一标识符，必需。
+  /// - chapterId: 章节的唯一标识符，必需。
+  /// - types: 笔记类型，'3'代表高亮，其他值待定义，可选，默认为'3'。
+  /// - content: 要添加的笔记、高亮或划线的文本内容，必需。
+  /// - isOpen: 笔记是否开启，必需。可能用于控制笔记的显示与隐藏。
+  /// - color: 高亮文本的颜色，十六进制颜色码，默认为'#FF0000'。
+  /// - positioning: 笔记的位置信息，必需。用于标识笔记在书籍中的位置。
+  /// - noteContent: 笔记的详细内容，必需。
+  ///
+  /// 返回值：
+  /// - Future<bool>: 添加笔记操作的成功与否。成功返回true，失败返回false。
   static Future <bool> addNote({
     required String bookId,
     required String chapterId,
@@ -283,6 +452,7 @@ abstract class LibraryAPI {
     required String positioning,
     required String noteContent,
   }) async {
+    // 发起POST请求，向服务器添加笔记信息
     final result = await HttpService.to.post(
       '/v1/book/Information/addNotes',
       params: {
@@ -294,39 +464,63 @@ abstract class LibraryAPI {
         'color':color,
         'positioning':positioning,
         'note_content':noteContent
-
       },
       showLoading: true
     );
+
+    // 检查请求结果，如果服务器返回的data是Map类型且'id'字段非空，则操作成功
     if (result.data is Map && result.data['id']!= ''){
       return true;
     }
     return false;
   }
 
-  /// 15、批量上传离线笔记、高亮、划线的内容
+
+  /// 批量上传离线笔记、高亮、划线的内容
+  ///
+  /// 参数:
+  /// - node: 必需，表示要上传的离线笔记、高亮、划线等内容的节点信息。
+  ///
+  /// 返回值:
+  /// - 返回一个Future，该Future解析为一个Map列表。如果请求成功，列表中每个元素包含离线笔记、高亮、划线等的具体内容；
+  ///   如果请求失败或返回的数据格式不符合预期，则返回空列表。
   static Future <List<Map<String,dynamic>>> uploadOffline({
     required String node,
   }) async {
+    // 向服务器发送POST请求，上传离线笔记等信息
     final result = await HttpService.to.post(
       '/v1/book/Information/addOfflineNotes',
       params: {
         'nodes_list':node,
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的数据列表转换为Map列表，并返回
     return List.generate(result.data['list'].length, (index){
       return Map<String,dynamic>.from(result.data['list'][index]);
     });
   }
 
-  /// 16、 搜索全文
+
+  /// 搜索全文
+  ///
+  /// 参数：
+  /// - page: 当前页码，默认为1。
+  /// - limit: 每页显示的数量，默认为10。
+  /// - bookId: 书籍ID，必需。
+  /// - key: 搜索关键字，必需。
+  ///
+  /// 返回值：一个包含[SearchAllModel]对象的列表。如果请求失败或无结果，则返回空列表。
   static Future<List<SearchAllModel>> searchAll({
     int page = 1,
     int limit = 10,
     required String bookId,
     required String key
   }) async {
+    // 向服务器发送POST请求，搜索指定书籍中的全文
     final result = await HttpService.to.post(
       '/v1/book/Information/searchContent',
       params: {
@@ -336,18 +530,31 @@ abstract class LibraryAPI {
         'key': key
       },
     );
+
+    // 检查返回结果是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为[SearchAllModel]对象列表并返回
     return List.generate(result.data['list'].length, (index) {
       return SearchAllModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 17、评论 点赞 取消
+  /// 评论点赞或取消点赞的函数
+  ///
+  /// 参数：
+  /// - bookId: 书籍ID，标识评论所属的书籍。
+  /// - type: 类型标识，用于区分点赞类型，例如1表示点赞，2表示取消点赞。
+  /// - commentId: 评论ID，标识要进行操作的评论。
+  ///
+  /// 返回值：
+  /// - 返回一个Future<bool>，操作成功返回true，失败返回false。
   static Future <bool> commentLove({
       required num bookId,
       required num type,
       required num commentId,
     }) async {
+      // 向服务器发送点赞或取消点赞的请求
       final result = await HttpService.to.post(
         '/v1/book/Information/clickPraise',
         params: {
@@ -356,16 +563,26 @@ abstract class LibraryAPI {
           'comment_id':commentId
         },
       );
+
+      // 检查请求结果，如果操作成功，则返回true，否则返回false
       if (result.data is Map && result.data['is_success'] == 1){
         return true;
       }
       return false;
   }
-  /// 18、删除讨论回复
+  /// 删除讨论回复的函数
+  ///
+  /// 参数：
+  ///   - bookId: 书籍ID，必需，用于指定要删除评论的书籍。
+  ///   - commentId: 评论ID，必需，用于指定要删除的具体评论。
+  ///
+  /// 返回值：
+  ///   - 返回一个Future<bool>类型的异步结果，如果评论删除成功，则返回true；否则返回false。
   static Future <bool> delComment({
     required num bookId,
     required num commentId,
   }) async {
+    // 向服务器发送删除评论的请求
     final result = await HttpService.to.post(
       '/v1/book/Information/delComment',
       params: {
@@ -373,6 +590,8 @@ abstract class LibraryAPI {
         'comment_id':commentId
       },
     );
+
+    // 检查删除操作是否成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
@@ -380,4 +599,5 @@ abstract class LibraryAPI {
   }
 
 
+
 }
\ No newline at end of file

lib/apis/mine.dart

 part of apis;
 
 abstract class MineAPI {
-  /// 1、个人信息以及8个数据
+  /// 获取用户的个人信息以及8个数据
   ///
+  /// 该函数没有参数。
+  /// [返回值]
+  ///   - 返回一个`Future`，该`Future`完成时会返回一个`UserInfoModel`实例。
+  ///     如果请求失败或返回的数据格式不正确，则返回一个空的`UserInfoModel`实例。
   static Future<UserInfoModel> userInfo() async {
+    // 向服务器发送POST请求，获取用户的统计信息
     final result = await HttpService.to.post(
       '/v1/members/Information/getMyStatistics',
       params: {},
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的UserInfoModel实例
     if (result.data is! Map) return UserInfoModel();
+
+    // 将获取到的数据转换为UserInfoModel实例并返回
     return UserInfoModel.fromJson(result.data);
   }
 
-  /// 2、我的收藏
+
+  /// 获取我的收藏列表
+  ///
+  /// 参数:
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页数量，默认为10
+  ///
+  /// 返回值: 返回一个Future，该Future解析为CourseModel类型的列表。如果请求失败或数据格式不正确，返回空列表。
   static Future<List<CourseModel>> love({
     int page = 1,
     int limit = 10,
   }) async {
+    // 发起POST请求获取我的收藏列表
     final result = await HttpService.to.post(
       '/v1/members/Information/myCollection',
       params: {
@@ -24,18 +41,29 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为CourseModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 3、笔记
+
+  /// 获取我的笔记列表
+  ///
+  /// 参数:
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页数量，默认为10
   ///
+  /// 返回值: 返回一个`Future`，其包含一个`CourseModel`类型的列表。
   static Future<List<CourseModel>> note({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送POST请求，获取我的笔记列表
     final result = await HttpService.to.post(
       '/v1/members/Information/myNotes',
       params: {
@@ -43,18 +71,28 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 如果返回的数据不是预期格式，则直接返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的笔记数据列表转换为`CourseModel`对象列表并返回
     return List.generate(result.data['list'].length, (index) {
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 4、错题
+
+  /// 获取用户的错题列表
+  ///
+  /// 参数:
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页数量，默认为10
   ///
   static Future<List<CourseModel>> wrong({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送请求，获取用户的错题列表
     final result = await HttpService.to.post(
       '/v1/members/Information/myWrongQuestion',
       params: {
@@ -62,18 +100,28 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回结果是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为CourseModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 5、紫金币记录
+
+  /// 获取紫金币记录
+  ///
+  /// 参数:
+  ///   page: 当前页码，默认为1。
+  ///   limit: 每页数量，默认为10。
   ///
   static Future<List<RecordModel>> coin({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送请求，获取紫金币记录
     final result = await HttpService.to.post(
       '/v1/members/Information/getBeanList',
       params: {
@@ -81,18 +129,30 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回结果是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为RecordModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return RecordModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 6、积分记录
+
+  /// 获取积分记录的函数
+  ///
+  /// 参数:
+  ///   - page: 请求的页码，默认为1。
+  ///   - limit: 每页的记录数量，默认为10。
   ///
+  /// 返回值:
+  ///   - 返回一个Future，该Future解析为RecordModel类型的列表。
   static Future<List<RecordModel>> point({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送POST请求，获取积分记录列表
     final result = await HttpService.to.post(
       '/v1/members/Information/getIntegralList',
       params: {
@@ -100,18 +160,31 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 如果返回的数据不是Map类型，或没有'list'字段，则返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON列表转换为RecordModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return RecordModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 7、讨论
+
+  /// 讨论接口
   ///
+  /// 获取用户的评论信息列表。可以通过指定页数和每页的数量来分页获取数据。
+  ///
+  /// 参数:
+  /// - page: 当前页数，默认为1。
+  /// - limit: 每页的数量，默认为10。
+  ///
+  /// 返回值: 返回一个`Future`，该`Future`解析为`CourseModel`类型的列表。
   static Future<List<CourseModel>> discuss({
     int page = 1,
     int limit = 10,
   }) async {
+    // 发起网络请求，获取评论信息
     final result = await HttpService.to.post(
       '/v1/members/Information/myComment',
       params: {
@@ -119,41 +192,76 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为`CourseModel`列表
     return List.generate(result.data['list'].length, (index) {
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 8、优惠券列表
+
+  /// 获取优惠券列表的函数
   ///
+  /// 参数:
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页数量，默认为10
+  ///   - type: 优惠券类型，必需参数
+  ///
+  /// 返回值: 返回一个Future，该Future解析为CouponModel类型的列表。
   static Future<List<CouponModel>> coupon({
     int page = 1,
     int limit = 10,
     required int type,
   }) async {
+    // 向服务器发送POST请求，获取优惠券列表
     final result = await HttpService.to.post(
       '/v1/coupon/Coupon/getCouponRecordListSAll',
       params: {'page': page, 'page_size': limit, 'type': type},
     );
+
+    // 如果返回的数据不是Map类型，或没有list键，则返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON列表转换为CouponModel列表
     return List.generate(result.data['list'].length, (index) {
       return CouponModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 9、获取最新版本
+
+  /// 获取最新版本的信息。
+  ///
+  /// 该方法会向服务器发送请求，以获取最新的版本信息。
+  /// 无参数。
   ///
+  /// @return [Future<UModel>] 一个未来的[UModel]对象，包含从服务器获取的版本信息。
+  /// 如果请求失败或返回的数据格式不符合预期，则返回一个空的[UModel]对象。
   static Future<UModel> update() async {
+    // 向服务器发送获取版本信息的请求
     final result = await HttpService.to.post(
       '/v1/members/Information/getVersion',
       params: {},
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的UModel对象
     if (result.data is! Map) return UModel();
+
+    // 将获取到的数据转换为UModel对象并返回
     return UModel.fromJson(result.data);
   }
 
-  /// 10、版本介绍
+
+  /// 获取版本介绍列表的函数
+  ///
+  /// 参数:
+  ///   page - 请求的页码，默认为1
+  ///   limit - 每页的限制数量，默认为10
+  ///
+  /// 返回值:
+  ///   返回一个 Future，该 Future 解析为 VersionModel 对象的列表。如果请求失败或数据格式不正确，则返回空列表。
   static Future<List<VersionModel>> versions({
     int page = 1,
     int limit = 10,
@@ -165,16 +273,26 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 根据返回的数据列表，生成 VersionModel 对象列表
     return List.generate(result.data['list'].length, (index) {
       return VersionModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 11、修改用户信息
+
+  /// 修改用户信息
+  ///
+  /// 参数：
+  /// - name: 用户名，可选
+  /// - sex: 性别，数字类型，可选
+  /// - headImg: 头像图片地址，字符串类型，可选
   ///
+  /// 返回值：操作是否成功的布尔值。成功返回true，失败返回false。
   static Future<bool> changeInfo(
       {String? name, num? sex, String? headImg}) async {
+    // 准备请求参数
     Map<String, dynamic> params = {};
     if (name != null) {
       params['name'] = name;
@@ -185,21 +303,33 @@ abstract class MineAPI {
     if (headImg != null) {
       params['head_img'] = headImg;
     }
+    // 发送修改信息的请求
     final result = await HttpService.to
         .post('/v1/members/Information/editInformation', params: params);
+    // 检查请求结果是否成功
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 12、笔记详情列表
+
+  /// 获取指定书籍和类型的笔记详情列表
+  ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1
+  /// - limit: 每页的笔记数量，默认为10
+  /// - bookId: 书籍的唯一标识符，required
+  /// - types: 笔记的类型，required
   ///
+  /// 返回值：
+  /// - 返回一个Future，该Future解析为NoteModel类型的列表。如果请求失败或返回数据不符合预期，则返回空列表。
   static Future<List<NoteModel>> noteList(
       {int page = 1,
       int limit = 10,
       required String bookId,
       required String types}) async {
+    // 向服务器发送POST请求，获取指定条件下的笔记列表
     final result = await HttpService.to.post(
       '/v1/members/Information/myBookNotes',
       params: {
@@ -209,19 +339,33 @@ abstract class MineAPI {
         'types': types
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为NoteModel列表并返回
     return List.generate(result.data['list'].length, (index) {
       return NoteModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 13、讨论详情列表
+
+  /// 讨论详情列表的获取方法
+  ///
+  /// 参数：
+  /// - page: 请求的页码，默认为1
+  /// - limit: 每页的讨论数量，默认为10
+  /// - bookId: 书籍的唯一标识符，必需
+  /// - types: 讨论类型的标识，例如"comment"或"review"，必需
   ///
+  /// 返回值：
+  /// - 返回一个Future，该Future解析为一个[DiscussModel]类型的列表。如果请求失败或返回数据格式不正确，则返回空列表。
   static Future<List<DiscussModel>> discussList(
       {int page = 1,
       int limit = 10,
       required String bookId,
       required String types}) async {
+    // 发起网络请求获取讨论列表
     final result = await HttpService.to.post(
       '/v1/members/Information/myBookComment',
       params: {
@@ -231,40 +375,71 @@ abstract class MineAPI {
         'type': types
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON数据转换为[DiscussModel]对象列表并返回
     return List.generate(result.data['list'].length, (index) {
       return DiscussModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 14、修改密码
+
+  /// 修改密码的函数
   ///
+  /// 参数：
+  ///   password: 需要修改的新密码，必填。
+  ///   rePassword: 确认新密码，必填。
+  /// 返回值：
+  ///   修改成功返回 true，失败返回 false。
   static Future<bool> changePwd(
       {required String password, required String rePassword}) async {
+    // 向服务器发送修改密码的请求
     final result = await HttpService.to.post(
       '/v1/members/Information/changePasswd',
       params: {'password': password, 'repassword': rePassword},
     );
+
+    // 检查返回结果，判断密码是否修改成功
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 15、修改手机号
+
+  /// 修改手机号的函数
+  ///
+  /// 参数：
+  ///   - phone: 新的手机号码，必填。
+  ///   - code: 验证码，必填。
+  ///
+  /// 返回值：
+  ///   布尔值，表示手机号码是否修改成功。成功返回true，失败返回false。
   static Future<bool> changePhone(
       {required String phone, required String code}) async {
+    // 向服务器发送请求，以修改手机号
     final result = await HttpService.to.post(
       '/v1/members/Information/editPhone',
       params: {'phone': phone, 'code': code},
     );
+
+    // 检查返回结果，判断手机号是否修改成功
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 16、帮助中心
+
+  /// 获取帮助中心的列表信息
+  ///
+  /// 参数：
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页显示的数量，默认为10
+  ///
+  /// 返回值：一个包含[HelpCenterModel]对象的列表。如果请求失败或数据格式不正确，返回空列表。
   static Future<List<HelpCenterModel>> helpCenters({
     int page = 1,
     int limit = 10,
@@ -276,34 +451,58 @@ abstract class MineAPI {
         'page_size': limit,
       },
     );
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 根据返回的数据列表，生成[HelpCenterModel]对象列表
     return List.generate(result.data['list'].length, (index) {
       return HelpCenterModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 17、帮助中心内容
+
+  /// 获取帮助中心的内容
+  ///
+  /// 参数：
+  ///   - id： 帮助中心内容的唯一标识符
+  ///
+  /// 返回值：
+  ///   返回一个Future，该Future完成时会提供HelpCenterContentModel类型的对象，
+  ///   如果获取内容失败，则返回一个空的HelpCenterContentModel实例。
   static Future<HelpCenterContentModel> helpCenterContent(String id) async {
+    // 向服务器发送POST请求，以获取指定ID的帮助中心内容信息
     final result = await HttpService.to.post(
       '/v1/common/Help/getInfoById',
       params: {
         'id': id,
       },
     );
+
+    // 如果返回的数据不是Map类型，则直接返回一个空的HelpCenterContentModel实例
     if (result.data is! Map) return HelpCenterContentModel();
+
+    // 将获得的数据转换为HelpCenterContentModel实例并返回
     return HelpCenterContentModel.fromJson(result.data);
   }
 
 
-  /// 18、意见反馈
+
+  /// 提供一个意见反馈的功能。
   ///
+  /// 参数:
+  /// - proposal: 提交的意见内容，可以是null。
+  /// 返回值:
+  /// 返回一个Future<bool>，如果提交成功则返回true，否则返回false。
   static Future<bool> feedback(String? proposal) async {
+    // 创建一个空的参数映射，用于存放提交的意见内容
     Map<String, dynamic> params = {};
+    // 如果提供了意见内容，则将其添加到参数映射中
     if (proposal != null) {
       params['proposal'] = proposal;
     }
+    // 向服务器发送POST请求，提交意见内容
     final result = await HttpService.to
         .post('/v1/members/Information/proposal', params: params);
+    // 检查服务器返回的结果，如果提交成功则返回true，否则返回false
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
@@ -311,68 +510,113 @@ abstract class MineAPI {
   }
 
 
-  /// 19、订单列表
+
+  /// 获取订单列表的函数
+  ///
+  /// 参数：
+  ///   - page: 当前页码，默认为1。
+  ///   - limit: 每页的数量，默认为10。
+  ///   - status: 订单的状态，默认为1。
+  ///   - keys: 搜索关键字，可选。
+  ///
+  /// 返回值：
+  ///   返回一个Future，该Future解析为一个OrderListModel类型的列表。
   static Future<List<OrderListModel>> orderList({
     int page = 1,
     int limit = 10,
     int status = 1,
     String? keys
   }) async {
+    // 构建请求参数
     Map<String, dynamic> params = {
       'page': page,
       'page_size': limit,
       'status':status,
     };
+    // 如果提供了搜索关键字，则添加到请求参数中
     if (keys != null) {
       params['keys'] = keys;
     }
+    // 发起POST请求获取订单列表
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getOrdersList',
       params: params,
     );
+    // 当返回的数据格式不符合预期时，返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+    // 将返回的列表数据转换为OrderListModel类型的列表
     return List.generate(result.data['list'].length, (index) {
       return OrderListModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 20、紫荆币充值列表
+
+  /// 获取紫荆币充值列表的函数
+  ///
+  /// 参数：
+  ///   - type: 充值配置的类型，必填。
+  ///
+  /// 返回值：
+  ///   返回一个 Future，该 Future 解析为 CoinModel 类型的列表。
   ///
   static Future<List<CoinModel>> coinsRechargeList(
       {
         required String type,
       }) async {
+    // 向服务器发送 POST 请求以获取充值配置列表
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getRechargeConfig',
       params: {
         'config_type': type,
       },
     );
+
+    // 如果返回的数据不是 Map 类型或没有 'list' 键，则返回空列表
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 从返回的 JSON 数据中构建 CoinModel 对象列表并返回
     return List.generate(result.data['list'].length, (index) {
       return CoinModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 21、订单取消支付
+
+  /// 取消订单支付
+  ///
+  /// 参数：
+  /// - ordersnum: 订单号，必填。
+  ///
+  /// 返回值：
+  /// - 返回一个 Future<bool>，若取消支付成功则为 true，否则为 false。
   static Future<bool> cancelPay(
       {required String ordersnum}) async {
+    // 向服务器发送取消支付的请求
     final result = await HttpService.to.post(
       '/v1/orders/Orders/cancelPay',
       params: {'ordersnum': ordersnum, },
     );
+
+    // 检查取消支付操作是否成功
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 22、紫荆币充值创建订单
+  /// 创建紫荆币充值订单
+  ///
+  /// 参数：
+  ///   - identifying: 用户标识，必填。
+  ///   - type: 订单类型，必填。
+  ///
+  /// 返回值：
+  ///   返回一个[PayOrderModel]实例，如果请求失败则返回一个空的[PayOrderModel]实例。
   static Future<PayOrderModel> createRechargeOrder(
       {
         required String identifying,
         required String type,
       }) async {
+    // 向服务器发送POST请求，创建充值订单
     final result = await HttpService.to.post(
       '/v1/orders/Orders/createBeanorders',
       params: {
@@ -381,44 +625,76 @@ abstract class MineAPI {
       },
       showLoading: true
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
     if (result.data is! Map) return PayOrderModel();
+
+    // 将返回的数据转换为PayOrderModel实例并返回
     return PayOrderModel.fromJson(result.data);
   }
 
 
-  /// 23、获取订单详情
+
+  /// 获取订单详情的函数
+  ///
+  /// 参数：
+  /// - orderNum: 订单编号，必须提供
+  ///
+  /// 返回值：
+  /// - 返回一个Future，该Future完成时会提供一个OrderInfoModel类型的对象，
+  ///   如果获取失败，会返回一个空的OrderInfoModel实例。
   static Future<OrderInfoModel> getOrderInfo(
       {
         required String orderNum,
       }) async {
+    // 向服务器发送POST请求，获取订单详情
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getInfoOrdersnum',
       params: {
         'ordersnum': orderNum,
       },
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的OrderInfoModel实例
     if (result.data is! Map) return OrderInfoModel();
+
+    // 将获取到的数据转换为OrderInfoModel实例并返回
     return OrderInfoModel.fromJson(result.data);
   }
 
-  /// 24、上传订单评价
+  /// 上传订单评价
+  ///
+  /// 参数：
+  /// - evaluate: 必需，评价内容的字符串表示
+  ///
+  /// 返回值：
+  /// - 返回一个Future<bool>，若评价上传成功则为true，否则为false。
   static Future<bool> UpOrderEvaluate(
       {required String evaluate}) async {
     final result = await HttpService.to.post(
       '/v1/orders/Orders/rating',
       params: {'rat_json': evaluate, },
     );
+    // 检查上传结果，如果成功则返回true，否则返回false
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 25、删除笔记、高亮、划线的内容
+  /// 删除笔记、高亮、划线的内容
+  ///
+  /// 参数：
+  ///   - notesId: 笔记的唯一标识符，必需。
+  ///   - bookId: 图书的唯一标识符，必需。
+  ///
+  /// 返回值：
+  ///   返回一个Future<bool>类型，如果删除成功，则返回true；否则返回false。
   static Future<bool> delNotes({
     required String notesId,
     required String bookId,
   }) async {
+    // 发起删除笔记的POST请求
     final result = await HttpService.to.post(
       '/v1/book/Information/delNotes',
       params: {
@@ -426,13 +702,30 @@ abstract class MineAPI {
         'book_id':bookId
       },
     );
+
+    // 检查删除操作是否成功
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 25、修改笔记、高亮、划线的内容
+
+  /// 修改笔记、高亮、划线的内容
+  ///
+  /// 调用此函数来更新特定书籍中的笔记内容。
+  ///
+  /// 参数：
+  /// - content: 要修改的原文内容。
+  /// - notesId: 笔记的唯一标识符。
+  /// - bookId: 书籍的唯一标识符。
+  /// - noteContent: 修改后的笔记、高亮或划线内容。
+  /// - isOpen: 笔记的可见状态，默认为 '0' 表示关闭。
+  /// - positioning: 笔记在书中的位置信息，默认为空字符串。
+  /// - color: 高亮或划线的颜色，默认为 '#FF0000'。
+  ///
+  /// 返回值：
+  /// - 返回一个 Future<bool>，如果修改成功，则返回 true，否则返回 false。
   static Future<bool> editNotes({
     required String content,
     required String notesId,
@@ -442,6 +735,7 @@ abstract class MineAPI {
     String positioning = '',
     String color= '#FF0000',
   }) async {
+    // 发起 POST 请求，提交笔记的修改内容
     final result = await HttpService.to.post(
       '/v1/book/Information/editNotes',
       params: {
@@ -455,17 +749,27 @@ abstract class MineAPI {
       },
       showLoading: true
     );
+
+    // 检查请求结果，成功则返回 true，否则返回 false
     if (result.data is Map && result.data['is_success'] == 1) {
       return true;
     }
     return false;
   }
 
-  /// 26、获取支付信息
+
+  /// 获取支付信息的函数
+  ///
+  /// 参数：
+  /// - ordersNum: 需要支付的订单号，必填
+  ///
+  /// 返回值：
+  /// - 返回一个Future，该Future完成时会提供一个PayOrderModel类型的对象，
+  ///   如果获取数据失败或数据格式不符合预期，则返回一个空的PayOrderModel实例。
   static Future <PayOrderModel> getPayInfo({
     required String ordersNum,
-
   }) async {
+    // 向服务器发送POST请求，获取支付信息
     final result = await HttpService.to.post(
       '/v1/orders/Orders/payAgain',
       params: {
@@ -473,14 +777,25 @@ abstract class MineAPI {
       },
       // showLoading: true
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
     if (result.data is! Map) return PayOrderModel();
+
+    // 将获取到的数据转换为PayOrderModel类型并返回
     return PayOrderModel.fromJson(result.data);
   }
 
-  /// 27、紫荆币支付
+  /// 实现紫荆币支付的功能。
+  ///
+  /// 参数：
+  ///   - ordersNum: 需要支付的订单编号，必填。
+  ///
+  /// 返回值：
+  ///   - 支付成功返回 true，否则返回 false。
   static Future<bool> coinPay({
     required String ordersNum,
   }) async {
+    // 向服务器发送支付请求
     final result = await HttpService.to.post(
         '/v1/book/Information/editNotes',
         params: {
@@ -488,11 +803,15 @@ abstract class MineAPI {
         },
         // showLoading: true
     );
+
+    // 检查支付结果
     if (result.data is Map && result.data['is_success'] == 1) {
-      return true;
+      return true; // 支付成功
     }
-    return false;
+
+    return false; // 支付失败
   }
 
+
 }
 

lib/apis/shop.dart

@@ -2,45 +2,69 @@ part of apis;
 
 abstract class ShopAPI {
 
-  /// 1、加入书架
+  /// 加入书架
   ///
+  /// 参数：
+  ///   - bookId: 书籍的唯一标识符，必须提供。
+  ///
+  /// 返回值：
+  ///   布尔值，表示加入书架操作是否成功。成功返回true，失败返回false。
   static Future <bool> addCart({
     required String  bookId,
   }) async {
+    // 向服务器发送请求，将书籍添加到购物车
     final result = await HttpService.to.post(
       '/v1/orders/Orders/addCart',
       params: {
         'book_id':bookId,
       },
     );
+    // 检查服务器响应，判断添加操作是否成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
-  /// 2、删除书架
+
+  /// 删除书架
+  ///
+  /// 参数：
+  ///   - cartId: 购物车的唯一标识符，必须提供。
   ///
+  /// 返回值：
+  ///   布尔值，表示删除操作是否成功。成功返回true，失败返回false。
   static Future <bool> delCart({
     required String cartId,
   }) async {
+    // 向服务器发送删除购物车的请求
     final result = await HttpService.to.post(
       '/v1/orders/Orders/delCart',
       params: {
         'cart_id':cartId,
       },
     );
+    // 检查服务器返回的结果，判断删除是否成功
     if (result.data is Map && result.data['is_success'] == 1){
       return true;
     }
     return false;
   }
 
-  /// 3、书架列表
+
+  /// 获取购物车中的课程列表
+  ///
+  /// 参数:
+  ///   - page: 当前页码，默认为1
+  ///   - limit: 每页的数量，默认为10
+  ///
+  /// 返回值: 返回一个`Future`，这个`Future`解析为`List<CourseModel>`。
+  /// 如果请求成功，会返回课程列表的模型数组；如果请求失败或数据格式不正确，则返回空数组。
   static Future <List<CourseModel>> cart({
     int page = 1,
     int limit = 10,
   }) async {
+    // 向服务器发送POST请求，获取购物车列表数据
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getCartListAll',
       params: {
@@ -48,18 +72,29 @@ abstract class ShopAPI {
         'page_size': limit,
       },
     );
+
+    // 检查返回的数据是否符合预期格式
     if (result.data is! Map && result.data['list'] is! List) return [];
+
+    // 将返回的JSON列表转换为`CourseModel`列表
     return List.generate(result.data['list'].length, (index){
       return CourseModel.fromJson(result.data['list'][index]);
     });
   }
 
-  /// 4、获取使用积分
+
+  /// 获取使用积分的函数
   ///
+  /// 参数：
+  /// - price: 商品价格，必填。
+  /// - couponRecId: 优惠券记录ID，必填。
+  ///
+  /// 返回值：一个 Future 对象，成功时返回 [CreditPointModel] 类的实例，失败时可能返回空实例。
   static Future <CreditPointModel> creditPoints({
     required String price,
     required String couponRecId,
   }) async {
+    // 向服务器发送 POST 请求，获取积分信息
     final result = await HttpService.to.post(
       '/v1/coupon/Coupon/getIntegral',
       params: {
@@ -67,37 +102,69 @@ abstract class ShopAPI {
         'coupon_rec_id': couponRecId
       },
     );
+
+    // 如果返回的数据不是 Map 类型，则返回一个空的 CreditPointModel 实例
     if (result.data is! Map ) return CreditPointModel();
+
+    // 将获取到的数据转换为 CreditPointModel 实例并返回
     return CreditPointModel.fromJson(result.data);
   }
 
-  /// 5、优惠券和积分是否展示
+
+  /// 查询优惠券和积分是否展示的设置
   ///
+  /// 该函数没有参数。
+  /// [返回值]
+  ///   - 返回一个`Future<ShowModel>`，表示异步获取的优惠券和积分展示设置的信息。
   static Future <ShowModel> show() async {
+    // 发起网络请求，获取优惠券和积分展示的设置信息
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getSetting',
       params: {},
     );
+    // 如果返回的数据不是Map类型，则返回一个空的ShowModel实例
     if (result.data is! Map ) return ShowModel();
+    // 将获取到的数据转换为ShowModel对象并返回
     return ShowModel.fromJson(result.data);
   }
 
-  /// 6、 支付时选的优惠券列表
+
+  /// 获取支付时可选的优惠券列表
+  ///
+  /// 参数：
+  /// - page: 当前页码，默认为1
+  /// - limit: 每页数量，默认为10
+  /// - type: 优惠券类型，此次支付所适用的类型
+  /// - price: 支付金额，用于筛选适用的优惠券
+  ///
+  /// 返回值：一个 Future 对象，成功时返回 CouponListModel 类型的对象，表示优惠券列表信息。
   static Future<CouponListModel> coupon({
     int page = 1,
     int limit = 10,
     required String type,
     required String price
   }) async {
+    // 向服务器发送 POST 请求，获取优惠券列表数据
     final result = await HttpService.to.post(
       '/v1/coupon/Coupon/getCouponAll',
       params: {'page': page, 'page_size': limit, 'type': type,'price':price},
     );
+
+    // 如果请求结果不是 Map 类型，则返回一个空的 CouponListModel
     if (result.data is! Map ) return CouponListModel();
+
+    // 将请求结果转换为 CouponListModel 对象并返回
     return CouponListModel.fromJson(result.data);
   }
 
-  /// 7、获取优惠券可使用和不可使用数量
+
+  /// 获取优惠券可使用和不可使用数量
+  ///
+  /// 参数：
+  /// - price: 需要获取优惠券数量的商品价格，类型为String，必传。
+  ///
+  /// 返回值：
+  /// - CouponNumModel: 优惠券数量模型对象。如果请求成功，将返回包含可使用和不可使用优惠券数量的模型；如果请求失败或返回数据格式不符，将返回一个空的CouponNumModel实例。
   static Future<CouponNumModel> couponNum({
     required String price
   }) async {
@@ -107,20 +174,32 @@ abstract class ShopAPI {
         'price':price
       },
     );
+    // 判断返回的数据是否为Map类型
     if (result.data is! Map ) return CouponNumModel();
+    // 从返回的Map数据中构建CouponNumModel对象并返回
     return CouponNumModel.fromJson(result.data);
   }
 
-  /// 8、创建订单
+
+  /// 创建订单
+  ///
+  /// 参数：
+  /// - bookIdsList: 图书ID列表，表示用户购买的书籍ID集合。
+  /// - totalPrice: 总价格，表示购买所有书籍的总价。
+  /// - couponRecId: 优惠券记录ID，表示使用的优惠券的唯一标识。
+  /// - integral: 积分，表示使用了多少积分进行抵扣。
+  /// - type: 订单类型，标识是普通订单还是其他类型订单。
   ///
+  /// 返回值：返回一个Future，该Future解析为PayOrderModel类型，表示支付订单的模型。
   static Future <PayOrderModel> createOrder({
     required String bookIdsList,
     required String totalPrice,
     required String couponRecId,
     required String integral,
-    required String type
+    required String type,
 
   }) async {
+    // 向服务器发送POST请求，创建订单
     final result = await HttpService.to.post(
       '/v1/orders/Orders/createOrders',
       params: {
@@ -131,25 +210,45 @@ abstract class ShopAPI {
         'type':type,
       },
     );
+
+    // 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
     if (result.data is! Map) return PayOrderModel();
+
+    // 将返回的数据解析为PayOrderModel类型并返回
     return PayOrderModel.fromJson(result.data);
   }
 
-  /// 9、获取订单状态
-  static Future <OrderStatusModel> orderStatus({
+
+  /// 获取订单状态
+  ///
+  /// 通过提供的订单号和收据信息，异步获取订单的当前状态。
+  ///
+  /// 参数:
+  /// - orderNumber: 订单号，必填。
+  /// - receipt: 收据信息，必填。
+  ///
+  /// 返回值:
+  /// - OrderStatusModel: 订单状态模型的实例，包含订单的详细状态信息。
+  static Future<OrderStatusModel> orderStatus({
     required String orderNumber,
-    required String receipt
+    required String receipt,
   }) async {
+    // 向服务器发送POST请求，获取订单状态
     final result = await HttpService.to.post(
       '/v1/orders/Orders/getOrdersStatus',
       params: {
-        'ordersnum':orderNumber,
-        'receipt':receipt
+        'ordersnum': orderNumber,
+        'receipt': receipt,
       },
     );
-    if (result.data is! Map ) return OrderStatusModel();
+
+    // 如果返回的数据不是Map类型，则返回一个空的订单状态模型实例
+    if (result.data is! Map) return OrderStatusModel();
+
+    // 将返回的JSON数据转换为OrderStatusModel实例并返回
     return OrderStatusModel.fromJson(result.data);
   }
 
 
+
 }
\ No newline at end of file