Skip to content

B
book-app
提交 7d3acb1f authored 作者: yueweilu's avatar yueweilu
1 浏览文件
操作

Revert "使用通义灵码天假注释"

This reverts commit 3e998548.
上级 8277b513
隐藏空白字符变更
内嵌 并排
正在显示 包含 148 行增加 和 971 行删除
lib/apis/account.dart
浏览文件 @ 7d3acb1f
......@@ -2,105 +2,76 @@ part of apis;
abstract class AccountAPI {
/// 登录功能
/// 1、登录
///
/// 参数：
/// - phone: 手机号码，必填。
/// - type: 登录类型，必填。'1'代表密码登录，'2'代表验证码登录。
/// - password: 登录密码，可选。仅在类型为'1'时需要。
/// - code: 验证码，可选。仅在类型为'2'时需要。
/// - uuid: 验证码的唯一标识，可选。仅在类型为'2'时需要。
///
/// 返回值：
/// - UserModel: 登录成功时返回的用户模型实例。
/// - 如果登录失败或出现异常，可能返回空的UserModel实例。
static Future<UserModel> login({
static Future <UserModel> login({
required String phone,
required String type,
String? password,
String? code,
String? uuid,
}) async {
Map<String, dynamic> params = {
'phone': phone,
'type': type,
// 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,
};
// 根据登录类型添加不同的登录参数
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;
}
/// 注销当前用户账号
///
/// 本函数用于通过向服务器发送请求来注销当前用户的账号。
/// 注销成功时，返回值为true；注销失败时，返回值为false。
/// 3、注销
///
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;
}
/// 发送验证码
///
/// 参数：
/// - phone: 需要发送验证码的手机号码，类型为 String，必需。
/// - type: 验证码的类型，例如注册、重置密码等，类型为 String，必需。
/// 4、发送验证码
///
/// 返回值：
/// - Future<bool>: 若发送成功返回 true，否则返回 false。
static Future sendCode({
required String phone,
required String type,
}) async {
// 生成设备唯一标识符
String uuid = '';
final DeviceInfoPlugin device = DeviceInfoPlugin();
if(Platform.isIOS){
......@@ -111,11 +82,9 @@ 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: {
......@@ -123,35 +92,23 @@ 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;
}
/// 重置密码
///
/// 使用该方法可以通过手机、验证码、新密码和确认新密码来重置用户的密码。
///
/// 参数:
/// - phone: 需要重置密码的用户的手机号码。
/// - code: 验证码，发送到用户手机上的用于验证身份的代码。
/// - password: 用户选择的新密码。
/// - rePassword: 确认新密码，需要与新密码一致以确认输入无误。
/// 5、重置密码
///
/// 返回值:
/// - 当密码重置成功时返回 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: {
......@@ -160,35 +117,20 @@ 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;
}
/// 验证验证码
///
/// 通过手机号和验证码向服务器验证验证码的正确性。
///
/// 参数：
/// - phone: 手机号，必填。
/// - code: 验证码，必填。
///
/// 返回值：
/// - 若验证成功，返回true。
/// - 若验证失败，返回false。
/// 6、验证验证码
static Future checkCode({
required String phone,
required String code,
}) async {
// 向服务器发送验证请求
final result = await HttpService.to.post(
'/v1/members/login/checkPhoneCode',
params: {
......@@ -198,8 +140,6 @@ abstract class AccountAPI {
excludeToken: true,
showLoading: true,
);
// 检查验证结果
if (result.data is Map && result.data['is_success'] == 1){
return true;
}
......@@ -210,5 +150,4 @@ abstract class AccountAPI {
}
\ No newline at end of file
lib/apis/common.dart
浏览文件 @ 7d3acb1f
......@@ -2,46 +2,29 @@ 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: {
......@@ -49,49 +32,29 @@ 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'];
}
/// 获取用户的学习历史记录
///
/// - `page`: 请求的页码，默认为1。
/// - `limit`: 每页返回的数据条数，默认为10。
/// 4、最近学习
///
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: {
......@@ -99,52 +62,36 @@ 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]);
});
}
/// 将指定的消息标记为已读
///
/// 参数：
/// id - 消息的唯一标识符，必须提供
/// 5、消息未读变已读
///
/// 返回值：
/// 布尔值，表示操作是否成功。如果操作成功，消息将被标记为已读，返回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;
}
......@@ -153,35 +100,24 @@ 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'];
});
}
/// 搜索书籍的函数
///
/// 参数：
/// - page: 请求的页码，默认为1。
/// - limit: 每页返回的结果数量，默认为20。
/// - keyWord: 搜索关键词，必需。
/// 8、搜索书籍
///
/// 返回值：一个 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: {
......@@ -190,126 +126,80 @@ 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 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;
}
/// 上传文件到服务器
///
/// 参数：
/// - path: 上传文件的路径
/// - fileTypes: 文件类型限制，用于指定可以上传的文件类型
///
/// 返回值：上传成功返回文件的URL字符串，失败则返回空字符串
/// 10、上传文件
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'];
}
/// 获取OSS临时token的方法
/// 该方法为静态方法，无需实例化对象即可调用
///
/// 参数：无
/// 返回值：一个Future，异步返回一个OssModel类型的对象。如果请求失败或返回数据格式不正确，则返回一个空的OssModel对象。
/// 11、获取OSS临时token
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'];
}
// 如果结果处理失败，返回null
// 在这里执行刷新token的逻辑
// 如果刷新成功，返回新的token；如果刷新失败，返回null
return null;
}
}
\ No newline at end of file
lib/apis/course.dart
浏览文件 @ 7d3acb1f
......@@ -2,35 +2,24 @@ 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: {
'page': page,
'page_size': limit,
},
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]);
});
}
int page = 1,
int limit = 20,
}) async {
final result = await HttpService.to.post(
'/v1/members/Information/myCourse',
params: {
'page': page,
'page_size': limit,
},
showLoading: true
);
if (result.data is! Map && result.data['list'] is! List) return [];
return List.generate(result.data['list'].length, (index){
return CourseModel.fromJson(result.data['list'][index]);
});
}
}
\ No newline at end of file
lib/apis/library.dart
浏览文件 @ 7d3acb1f
......@@ -3,61 +3,34 @@ 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]);
});
}
/// 获取书籍列表的函数
///
/// 参数：
/// - page: 请求的页码，默认为1。
/// - limit: 每页的书籍数量，默认为10。
/// - sortField: 排序字段，默认为空字符串。
/// - sort: 排序方式，默认为空字符串。
/// - isFree: 是否免费，默认为空字符串。
/// - labelId: 标签ID，默认为空字符串。
/// - categoryId: 类别ID，必需参数。
/// 3、书籍列表
///
/// 返回值：
/// - 返回一个Future，该Future解析为CourseModel类型的列表。
static Future <List<CourseModel>> books({
int page = 1,
int limit = 10,
......@@ -67,13 +40,11 @@ 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;
}
......@@ -83,33 +54,27 @@ 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,
......@@ -123,22 +88,14 @@ 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 {
......@@ -148,87 +105,49 @@ 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]);
});
}
/// 获取书籍详情的函数。
///
/// 通过给定的书籍ID，异步请求服务器获取书籍的详细信息。
/// 6、获取书籍详情
///
/// 参数:
/// - 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);
}
/// 获取指定书籍和章节的笔记列表
///
/// 参数：
/// - page: 请求的页码，默认为1
/// - limit: 每页的笔记数量，默认为10
/// - bookId: 书籍的唯一标识符，必需
/// - chapterId: 章节的唯一标识符，必需
/// 7、阅读页 章节笔记列表
///
/// 返回值：
/// - 返回一个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: {
......@@ -239,32 +158,19 @@ 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: {
......@@ -275,30 +181,17 @@ 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]);
});
}
/// 添加阅读时长
///
/// 参数：
/// - bookId: 书籍的唯一标识符，必需。
/// - readTypes: 阅读类型，用于记录不同的阅读方式或场景，必需。
///
/// 返回值：
/// - 返回一个Future<bool>，若添加阅读时长成功，则返回true，否则返回false。
/// 9、添加阅读时长
static Future <bool> addReadTime({
required String bookId,
required String readTypes
}) async {
// 向服务器发送POST请求，以添加阅读时长
final result = await HttpService.to.post(
'/v1/book/Information/addReadTime',
params: {
......@@ -306,28 +199,13 @@ abstract class LibraryAPI {
'read_types':readTypes
},
);
// 检查请求结果，若添加成功则返回true，否则返回false
if (result.data is Map && result.data['is_success'] == 1){
return true;
}
return false;
}
/// 发布讨论回复
///
/// 请求参数：
/// - bookId: 书籍ID，必需
/// - chapterId: 章节ID，必需
/// - commentId: 评论ID，必需，用于指定回复的评论
/// - quoteContent: 引用内容，必需，即回复中被引用的原文内容
/// - title: 回复标题，必需
/// - content: 回复内容，必需
///
/// 返回值：一个包含操作结果的Map<String,dynamic>对象。
/// 如果请求成功，Map中'is_success'键的值为1；
/// 如果请求失败，返回空Map。
/// 10、发布讨论回复
static Future <Map<String,dynamic>> addDiscuss({
required String bookId,
required String chapterId,
......@@ -336,7 +214,6 @@ abstract class LibraryAPI {
required String title,
required String content,
}) async {
// 发起POST请求，向服务器添加讨论回复
final result = await HttpService.to.post(
'/v1/book/Information/addComment',
params: {
......@@ -347,53 +224,29 @@ 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 {};
}
/// 获取离线书籍下载地址和秘钥串的函数
///
/// 参数：
/// - bookId：必需，书籍的唯一标识符。
///
/// 返回值：
/// 返回一个 Future，该 Future 解析为 [BookDownloadModel] 类的实例，
/// 如果请求失败或数据格式不符合预期，则返回一个空的 [BookDownloadModel] 实例。
/// 11、获取离线书籍下载地址 和 秘钥串
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);
}
/// 根据书籍地址下载书籍的函数
///
/// 参数：
/// - url: 书籍的下载地址，类型为 String，必需。
/// - savePath: 书籍下载后保存的路径，类型为 String，必需。
/// - onReceiveProgress: 下载进度的回调函数，为可选参数。类型为 ProgressCallback。
///
/// 返回值：无返回值。
///
/// 使用 HttpService 的 download 方法进行书籍的下载。
/// 12、根据书籍地址下载书籍
static Future <void> downBookByUrl({
required String url,
required String savePath,
......@@ -401,47 +254,25 @@ abstract class LibraryAPI {
}) async {
await HttpService.to.download(url, savePath: savePath,onReceiveProgress: onReceiveProgress);
}
/// 离线重连时上传笔记、高亮、划线内容到服务器
///
/// 参数：
/// - bookId: 书籍的唯一标识符，必需。
/// - readTypes: 阅读类型，表示上传的内容类型，如笔记、高亮、划线等，必需。
///
/// 返回值：
/// - 布尔值，表示上传是否成功。若成功，返回true；否则返回false。
/// 13、离线重连 上传笔记、高亮、划线
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;
}
/// 添加笔记、高亮、划线的内容
///
/// 参数：
/// - bookId: 书籍的唯一标识符，必需。
/// - chapterId: 章节的唯一标识符，必需。
/// - types: 笔记类型，'3'代表高亮，其他值待定义，可选，默认为'3'。
/// - content: 要添加的笔记、高亮或划线的文本内容，必需。
/// - isOpen: 笔记是否开启，必需。可能用于控制笔记的显示与隐藏。
/// - color: 高亮文本的颜色，十六进制颜色码，默认为'#FF0000'。
/// - positioning: 笔记的位置信息，必需。用于标识笔记在书籍中的位置。
/// - noteContent: 笔记的详细内容，必需。
///
/// 返回值：
/// - Future<bool>: 添加笔记操作的成功与否。成功返回true，失败返回false。
/// 14、添加笔记、高亮、划线的内容
static Future <bool> addNote({
required String bookId,
required String chapterId,
......@@ -452,7 +283,6 @@ abstract class LibraryAPI {
required String positioning,
required String noteContent,
}) async {
// 发起POST请求，向服务器添加笔记信息
final result = await HttpService.to.post(
'/v1/book/Information/addNotes',
params: {
......@@ -464,63 +294,39 @@ 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;
}
/// 批量上传离线笔记、高亮、划线的内容
///
/// 参数:
/// - node: 必需，表示要上传的离线笔记、高亮、划线等内容的节点信息。
///
/// 返回值:
/// - 返回一个Future，该Future解析为一个Map列表。如果请求成功，列表中每个元素包含离线笔记、高亮、划线等的具体内容；
/// 如果请求失败或返回的数据格式不符合预期，则返回空列表。
/// 15、批量上传离线笔记、高亮、划线的内容
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]);
});
}
/// 搜索全文
///
/// 参数：
/// - page: 当前页码，默认为1。
/// - limit: 每页显示的数量，默认为10。
/// - bookId: 书籍ID，必需。
/// - key: 搜索关键字，必需。
///
/// 返回值：一个包含[SearchAllModel]对象的列表。如果请求失败或无结果，则返回空列表。
/// 16、 搜索全文
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: {
......@@ -530,59 +336,36 @@ 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]);
});
}
/// 评论点赞或取消点赞的函数
///
/// 参数：
/// - bookId: 书籍ID，标识评论所属的书籍。
/// - type: 类型标识，用于区分点赞类型，例如1表示点赞，2表示取消点赞。
/// - commentId: 评论ID，标识要进行操作的评论。
///
/// 返回值：
/// - 返回一个Future<bool>，操作成功返回true，失败返回false。
/// 17、评论 点赞 取消
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: {
'book_id':bookId,
'type':type,
'comment_id':commentId
},
);
// 检查请求结果，如果操作成功，则返回true，否则返回false
if (result.data is Map && result.data['is_success'] == 1){
return true;
}
return false;
required num bookId,
required num type,
required num commentId,
}) async {
final result = await HttpService.to.post(
'/v1/book/Information/clickPraise',
params: {
'book_id':bookId,
'type':type,
'comment_id':commentId
},
);
if (result.data is Map && result.data['is_success'] == 1){
return true;
}
return false;
}
/// 删除讨论回复的函数
///
/// 参数：
/// - bookId: 书籍ID，必需，用于指定要删除评论的书籍。
/// - commentId: 评论ID，必需，用于指定要删除的具体评论。
///
/// 返回值：
/// - 返回一个Future<bool>类型的异步结果，如果评论删除成功，则返回true；否则返回false。
/// 18、删除讨论回复
static Future <bool> delComment({
required num bookId,
required num commentId,
}) async {
// 向服务器发送删除评论的请求
final result = await HttpService.to.post(
'/v1/book/Information/delComment',
params: {
......@@ -590,8 +373,6 @@ abstract class LibraryAPI {
'comment_id':commentId
},
);
// 检查删除操作是否成功
if (result.data is Map && result.data['is_success'] == 1){
return true;
}
......@@ -599,5 +380,4 @@ abstract class LibraryAPI {
}
}
\ No newline at end of file
lib/apis/mine.dart
浏览文件 @ 7d3acb1f
part of apis;
abstract class MineAPI {
/// 获取用户的个人信息以及8个数据
/// 1、个人信息以及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);
}
/// 获取我的收藏列表
///
/// 参数:
/// - page: 当前页码，默认为1
/// - limit: 每页数量，默认为10
///
/// 返回值: 返回一个Future，该Future解析为CourseModel类型的列表。如果请求失败或数据格式不正确，返回空列表。
/// 2、我的收藏
static Future<List<CourseModel>> love({
int page = 1,
int limit = 10,
}) async {
// 发起POST请求获取我的收藏列表
final result = await HttpService.to.post(
'/v1/members/Information/myCollection',
params: {
......@@ -41,29 +24,18 @@ 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]);
});
}
/// 获取我的笔记列表
///
/// 参数:
/// - page: 当前页码，默认为1
/// - limit: 每页数量，默认为10
/// 3、笔记
///
/// 返回值: 返回一个`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: {
......@@ -71,28 +43,18 @@ 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]);
});
}
/// 获取用户的错题列表
///
/// 参数:
/// - page: 当前页码，默认为1
/// - limit: 每页数量，默认为10
/// 4、错题
///
static Future<List<CourseModel>> wrong({
int page = 1,
int limit = 10,
}) async {
// 向服务器发送请求，获取用户的错题列表
final result = await HttpService.to.post(
'/v1/members/Information/myWrongQuestion',
params: {
......@@ -100,28 +62,18 @@ 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]);
});
}
/// 获取紫金币记录
///
/// 参数:
/// page: 当前页码，默认为1。
/// limit: 每页数量，默认为10。
/// 5、紫金币记录
///
static Future<List<RecordModel>> coin({
int page = 1,
int limit = 10,
}) async {
// 向服务器发送请求，获取紫金币记录
final result = await HttpService.to.post(
'/v1/members/Information/getBeanList',
params: {
......@@ -129,30 +81,18 @@ 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]);
});
}
/// 获取积分记录的函数
///
/// 参数:
/// - page: 请求的页码，默认为1。
/// - limit: 每页的记录数量，默认为10。
/// 6、积分记录
///
/// 返回值:
/// - 返回一个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: {
......@@ -160,31 +100,18 @@ 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: {
......@@ -192,76 +119,41 @@ 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);
}
/// 获取版本介绍列表的函数
///
/// 参数:
/// page - 请求的页码，默认为1
/// limit - 每页的限制数量，默认为10
///
/// 返回值:
/// 返回一个 Future，该 Future 解析为 VersionModel 对象的列表。如果请求失败或数据格式不正确，则返回空列表。
/// 10、版本介绍
static Future<List<VersionModel>> versions({
int page = 1,
int limit = 10,
......@@ -273,26 +165,16 @@ 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]);
});
}
/// 修改用户信息
///
/// 参数：
/// - name: 用户名，可选
/// - sex: 性别，数字类型，可选
/// - headImg: 头像图片地址，字符串类型，可选
/// 11、修改用户信息
///
/// 返回值：操作是否成功的布尔值。成功返回true，失败返回false。
static Future<bool> changeInfo(
{String? name, num? sex, String? headImg}) async {
// 准备请求参数
Map<String, dynamic> params = {};
if (name != null) {
params['name'] = name;
......@@ -303,33 +185,21 @@ 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;
}
/// 获取指定书籍和类型的笔记详情列表
///
/// 参数：
/// - page: 请求的页码，默认为1
/// - limit: 每页的笔记数量，默认为10
/// - bookId: 书籍的唯一标识符，required
/// - types: 笔记的类型，required
/// 12、笔记详情列表
///
/// 返回值：
/// - 返回一个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: {
......@@ -339,33 +209,19 @@ 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]);
});
}
/// 讨论详情列表的获取方法
///
/// 参数：
/// - page: 请求的页码，默认为1
/// - limit: 每页的讨论数量，默认为10
/// - bookId: 书籍的唯一标识符，必需
/// - types: 讨论类型的标识，例如"comment"或"review"，必需
/// 13、讨论详情列表
///
/// 返回值：
/// - 返回一个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: {
......@@ -375,71 +231,40 @@ 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;
}
/// 修改手机号的函数
///
/// 参数：
/// - phone: 新的手机号码，必填。
/// - code: 验证码，必填。
///
/// 返回值：
/// 布尔值，表示手机号码是否修改成功。成功返回true，失败返回false。
/// 15、修改手机号
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;
}
/// 获取帮助中心的列表信息
///
/// 参数：
/// - page: 当前页码，默认为1
/// - limit: 每页显示的数量，默认为10
///
/// 返回值：一个包含[HelpCenterModel]对象的列表。如果请求失败或数据格式不正确，返回空列表。
/// 16、帮助中心
static Future<List<HelpCenterModel>> helpCenters({
int page = 1,
int limit = 10,
......@@ -451,58 +276,34 @@ 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]);
});
}
/// 获取帮助中心的内容
///
/// 参数：
/// - id： 帮助中心内容的唯一标识符
///
/// 返回值：
/// 返回一个Future，该Future完成时会提供HelpCenterContentModel类型的对象，
/// 如果获取内容失败，则返回一个空的HelpCenterContentModel实例。
/// 17、帮助中心内容
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;
}
......@@ -510,113 +311,68 @@ abstract class MineAPI {
}
/// 获取订单列表的函数
///
/// 参数：
/// - page: 当前页码，默认为1。
/// - limit: 每页的数量，默认为10。
/// - status: 订单的状态，默认为1。
/// - keys: 搜索关键字，可选。
///
/// 返回值：
/// 返回一个Future，该Future解析为一个OrderListModel类型的列表。
/// 19、订单列表
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]);
});
}
/// 获取紫荆币充值列表的函数
///
/// 参数：
/// - type: 充值配置的类型，必填。
///
/// 返回值：
/// 返回一个 Future，该 Future 解析为 CoinModel 类型的列表。
/// 20、紫荆币充值列表
///
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]);
});
}
/// 取消订单支付
///
/// 参数：
/// - ordersnum: 订单号，必填。
///
/// 返回值：
/// - 返回一个 Future<bool>，若取消支付成功则为 true，否则为 false。
/// 21、订单取消支付
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;
}
/// 创建紫荆币充值订单
///
/// 参数：
/// - identifying: 用户标识，必填。
/// - type: 订单类型，必填。
///
/// 返回值：
/// 返回一个[PayOrderModel]实例，如果请求失败则返回一个空的[PayOrderModel]实例。
/// 22、紫荆币充值创建订单
static Future<PayOrderModel> createRechargeOrder(
{
required String identifying,
required String type,
}) async {
// 向服务器发送POST请求，创建充值订单
final result = await HttpService.to.post(
'/v1/orders/Orders/createBeanorders',
params: {
......@@ -625,76 +381,44 @@ abstract class MineAPI {
},
showLoading: true
);
// 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
if (result.data is! Map) return PayOrderModel();
// 将返回的数据转换为PayOrderModel实例并返回
return PayOrderModel.fromJson(result.data);
}
/// 获取订单详情的函数
///
/// 参数：
/// - orderNum: 订单编号，必须提供
///
/// 返回值：
/// - 返回一个Future，该Future完成时会提供一个OrderInfoModel类型的对象，
/// 如果获取失败，会返回一个空的OrderInfoModel实例。
/// 23、获取订单详情
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);
}
/// 上传订单评价
///
/// 参数：
/// - evaluate: 必需，评价内容的字符串表示
///
/// 返回值：
/// - 返回一个Future<bool>，若评价上传成功则为true，否则为false。
/// 24、上传订单评价
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;
}
/// 删除笔记、高亮、划线的内容
///
/// 参数：
/// - notesId: 笔记的唯一标识符，必需。
/// - bookId: 图书的唯一标识符，必需。
///
/// 返回值：
/// 返回一个Future<bool>类型，如果删除成功，则返回true；否则返回false。
/// 25、删除笔记、高亮、划线的内容
static Future<bool> delNotes({
required String notesId,
required String bookId,
}) async {
// 发起删除笔记的POST请求
final result = await HttpService.to.post(
'/v1/book/Information/delNotes',
params: {
......@@ -702,30 +426,13 @@ abstract class MineAPI {
'book_id':bookId
},
);
// 检查删除操作是否成功
if (result.data is Map && result.data['is_success'] == 1) {
return true;
}
return false;
}
/// 修改笔记、高亮、划线的内容
///
/// 调用此函数来更新特定书籍中的笔记内容。
///
/// 参数：
/// - content: 要修改的原文内容。
/// - notesId: 笔记的唯一标识符。
/// - bookId: 书籍的唯一标识符。
/// - noteContent: 修改后的笔记、高亮或划线内容。
/// - isOpen: 笔记的可见状态，默认为 '0' 表示关闭。
/// - positioning: 笔记在书中的位置信息，默认为空字符串。
/// - color: 高亮或划线的颜色，默认为 '#FF0000'。
///
/// 返回值：
/// - 返回一个 Future<bool>，如果修改成功，则返回 true，否则返回 false。
/// 25、修改笔记、高亮、划线的内容
static Future<bool> editNotes({
required String content,
required String notesId,
......@@ -735,7 +442,6 @@ abstract class MineAPI {
String positioning = '',
String color= '#FF0000',
}) async {
// 发起 POST 请求，提交笔记的修改内容
final result = await HttpService.to.post(
'/v1/book/Information/editNotes',
params: {
......@@ -749,27 +455,17 @@ abstract class MineAPI {
},
showLoading: true
);
// 检查请求结果，成功则返回 true，否则返回 false
if (result.data is Map && result.data['is_success'] == 1) {
return true;
}
return false;
}
/// 获取支付信息的函数
///
/// 参数：
/// - ordersNum: 需要支付的订单号，必填
///
/// 返回值：
/// - 返回一个Future，该Future完成时会提供一个PayOrderModel类型的对象，
/// 如果获取数据失败或数据格式不符合预期，则返回一个空的PayOrderModel实例。
/// 26、获取支付信息
static Future <PayOrderModel> getPayInfo({
required String ordersNum,
}) async {
// 向服务器发送POST请求，获取支付信息
final result = await HttpService.to.post(
'/v1/orders/Orders/payAgain',
params: {
......@@ -777,25 +473,14 @@ abstract class MineAPI {
},
// showLoading: true
);
// 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
if (result.data is! Map) return PayOrderModel();
// 将获取到的数据转换为PayOrderModel类型并返回
return PayOrderModel.fromJson(result.data);
}
/// 实现紫荆币支付的功能。
///
/// 参数：
/// - ordersNum: 需要支付的订单编号，必填。
///
/// 返回值：
/// - 支付成功返回 true，否则返回 false。
/// 27、紫荆币支付
static Future<bool> coinPay({
required String ordersNum,
}) async {
// 向服务器发送支付请求
final result = await HttpService.to.post(
'/v1/book/Information/editNotes',
params: {
......@@ -803,15 +488,11 @@ 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
浏览文件 @ 7d3acb1f
......@@ -2,69 +2,45 @@ 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;
}
/// 删除书架
///
/// 参数：
/// - cartId: 购物车的唯一标识符，必须提供。
/// 2、删除书架
///
/// 返回值：
/// 布尔值，表示删除操作是否成功。成功返回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;
}
/// 获取购物车中的课程列表
///
/// 参数:
/// - page: 当前页码，默认为1
/// - limit: 每页的数量，默认为10
///
/// 返回值: 返回一个`Future`，这个`Future`解析为`List<CourseModel>`。
/// 如果请求成功，会返回课程列表的模型数组；如果请求失败或数据格式不正确，则返回空数组。
/// 3、书架列表
static Future <List<CourseModel>> cart({
int page = 1,
int limit = 10,
}) async {
// 向服务器发送POST请求，获取购物车列表数据
final result = await HttpService.to.post(
'/v1/orders/Orders/getCartListAll',
params: {
......@@ -72,29 +48,18 @@ 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: {
......@@ -102,69 +67,37 @@ 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);
}
/// 获取支付时可选的优惠券列表
///
/// 参数：
/// - page: 当前页码，默认为1
/// - limit: 每页数量，默认为10
/// - type: 优惠券类型，此次支付所适用的类型
/// - price: 支付金额，用于筛选适用的优惠券
///
/// 返回值：一个 Future 对象，成功时返回 CouponListModel 类型的对象，表示优惠券列表信息。
/// 6、 支付时选的优惠券列表
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);
}
/// 获取优惠券可使用和不可使用数量
///
/// 参数：
/// - price: 需要获取优惠券数量的商品价格，类型为String，必传。
///
/// 返回值：
/// - CouponNumModel: 优惠券数量模型对象。如果请求成功，将返回包含可使用和不可使用优惠券数量的模型；如果请求失败或返回数据格式不符，将返回一个空的CouponNumModel实例。
/// 7、获取优惠券可使用和不可使用数量
static Future<CouponNumModel> couponNum({
required String price
}) async {
......@@ -174,32 +107,20 @@ abstract class ShopAPI {
'price':price
},
);
// 判断返回的数据是否为Map类型
if (result.data is! Map ) return CouponNumModel();
// 从返回的Map数据中构建CouponNumModel对象并返回
return CouponNumModel.fromJson(result.data);
}
/// 创建订单
///
/// 参数：
/// - bookIdsList: 图书ID列表，表示用户购买的书籍ID集合。
/// - totalPrice: 总价格，表示购买所有书籍的总价。
/// - couponRecId: 优惠券记录ID，表示使用的优惠券的唯一标识。
/// - integral: 积分，表示使用了多少积分进行抵扣。
/// - type: 订单类型，标识是普通订单还是其他类型订单。
/// 8、创建订单
///
/// 返回值：返回一个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: {
......@@ -210,45 +131,25 @@ abstract class ShopAPI {
'type':type,
},
);
// 如果返回的数据不是Map类型，则返回一个空的PayOrderModel实例
if (result.data is! Map) return PayOrderModel();
// 将返回的数据解析为PayOrderModel类型并返回
return PayOrderModel.fromJson(result.data);
}
/// 获取订单状态
///
/// 通过提供的订单号和收据信息，异步获取订单的当前状态。
///
/// 参数:
/// - orderNumber: 订单号，必填。
/// - receipt: 收据信息，必填。
///
/// 返回值:
/// - OrderStatusModel: 订单状态模型的实例，包含订单的详细状态信息。
static Future<OrderStatusModel> orderStatus({
/// 9、获取订单状态
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
},
);
// 如果返回的数据不是Map类型，则返回一个空的订单状态模型实例
if (result.data is! Map) return OrderStatusModel();
// 将返回的JSON数据转换为OrderStatusModel实例并返回
if (result.data is! Map ) return OrderStatusModel();
return OrderStatusModel.fromJson(result.data);
}
}
\ No newline at end of file
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论