dellevin/MookNote
1
0
Fork 0
generated from dellevin/template
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完善2

Browse Source
This commit is contained in:
DelLevin-Home
2026-03-07 23:20:24 +08:00
parent dc513fb6f6
commit d28c5e562e
24 changed files with 1983 additions and 636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
lib/utils/backup_service.dart
View File

@@ -7,7 +7,6 @@ import 'package:file_picker/file_picker.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as path;
import 'package:share_plus/share_plus.dart';
import 'package:cross_file/cross_file.dart';
import 'database_helper.dart';
/// 数据备份服务 - 支持导出和导入数据（包含图片）
@@ -55,6 +54,23 @@ class BackupService {
}
}
// 收集笔记图片
for (final note in notes) {
final imagesJson = note['images'] as String?;
if (imagesJson != null && imagesJson.isNotEmpty) {
try {
final images = jsonDecode(imagesJson) as List<dynamic>;
for (final imagePath in images) {
if (imagePath is String && imagePath.isNotEmpty) {
imagePaths.add(imagePath);
}
}
} catch (e) {
// 解析失败，跳过
}
}
}
// 构建备份数据
final backupData = {
'version': 2,
@@ -78,15 +94,24 @@ class BackupService {
final jsonBytes = Uint8List.fromList(utf8.encode(jsonString));
archive.addFile(ArchiveFile('data.json', jsonBytes.length, jsonBytes));
// 添加图片文件
// 添加图片文件，保持目录结构
int imageCount = 0;
final appDir = await getApplicationDocumentsDirectory();
final imagesRoot = path.join(appDir.path, 'images');
for (final imagePath in imagePaths) {
final file = File(imagePath);
if (await file.exists()) {
final bytes = await file.readAsBytes();
final fileName = path.basename(imagePath);
// 使用相对路径存储图片
archive.addFile(ArchiveFile('images/$fileName', bytes.length, bytes));
// 计算相对路径（如 movies/1/poster.jpg）
String relativePath;
if (imagePath.startsWith(imagesRoot)) {
relativePath = imagePath.substring(imagesRoot.length + 1); // +1 去掉开头的 /
} else {
relativePath = path.basename(imagePath);
}
// 使用相对路径存储图片，保持目录结构
archive.addFile(ArchiveFile('images/$relativePath', bytes.length, bytes));
imageCount++;
}
}
@@ -198,7 +223,7 @@ class BackupService {
final jsonString = utf8.decode(dataFile.content as List<int>);
backupData = jsonDecode(jsonString) as Map<String, dynamic>;
// 解压图片到应用目录
// 解压图片到应用目录，保持目录结构
final appDir = await getApplicationDocumentsDirectory();
final imagesDir = Directory(path.join(appDir.path, 'images'));
if (!await imagesDir.exists()) {
@@ -207,9 +232,20 @@ class BackupService {
for (final archiveFile in archive) {
if (archiveFile.name.startsWith('images/')) {
final fileName = path.basename(archiveFile.name);
final outputFile = File(path.join(imagesDir.path, fileName));
// 获取相对路径（如 movies/1/poster.jpg）
final relativePath = archiveFile.name.substring(7); // 去掉 'images/' 前缀
final outputFile = File(path.join(imagesDir.path, relativePath));
// 确保父目录存在
final parentDir = outputFile.parent;
if (!await parentDir.exists()) {
await parentDir.create(recursive: true);
}
await outputFile.writeAsBytes(archiveFile.content as List<int>);
// 记录文件名到新路径的映射（用于更新数据库中的路径）
final fileName = path.basename(archiveFile.name);
imagePathMap[fileName] = outputFile.path;
imageCount++;
}
@@ -258,11 +294,13 @@ class BackupService {
}
}
// 导入笔记数据
// 导入笔记数据（更新图片路径）
if (data.containsKey('notes')) {
final notes = data['notes'] as List<dynamic>;
for (final note in notes) {
await txn.insert('notes', _convertToDbMap(note));
final noteMap = _convertToDbMap(note);
final updatedMap = _updateNoteImagesPath(noteMap, imagePathMap);
await txn.insert('notes', updatedMap);
}
}
@@ -327,6 +365,7 @@ class BackupService {
}
/// 更新图片路径为新的路径
/// 支持新的存储结构：images/movies/{id}/、images/books/{id}/、images/notes/{id}/
Map<String, dynamic> _updateImagePath(
Map<String, dynamic> item,
String pathField,
@@ -340,6 +379,61 @@ class BackupService {
// 如果图片在映射中，更新路径
if (imagePathMap.containsKey(fileName)) {
newItem[pathField] = imagePathMap[fileName];
} else {
// 尝试从旧版备份中恢复（旧版只保存了文件名）
// 检查是否有匹配的文件名（不区分目录结构）
for (final entry in imagePathMap.entries) {
if (path.basename(entry.key) == fileName) {
newItem[pathField] = entry.value;
break;
}
}
}
}
return newItem;
}
/// 更新笔记图片路径为新的路径
/// 支持新的存储结构：images/notes/{id}/
Map<String, dynamic> _updateNoteImagesPath(
Map<String, dynamic> item,
Map<String, String> imagePathMap,
) {
final newItem = Map<String, dynamic>.from(item);
final imagesJson = item['images'] as String?;
if (imagesJson != null && imagesJson.isNotEmpty) {
try {
final images = jsonDecode(imagesJson) as List<dynamic>;
final updatedImages = <String>[];
for (final imagePath in images) {
if (imagePath is String && imagePath.isNotEmpty) {
final fileName = path.basename(imagePath);
// 如果图片在映射中，更新路径
if (imagePathMap.containsKey(fileName)) {
updatedImages.add(imagePathMap[fileName]!);
} else {
// 尝试从旧版备份中恢复（旧版只保存了文件名）
bool found = false;
for (final entry in imagePathMap.entries) {
if (path.basename(entry.key) == fileName) {
updatedImages.add(entry.value);
found = true;
break;
}
}
if (!found) {
updatedImages.add(imagePath);
}
}
}
}
newItem['images'] = jsonEncode(updatedImages);
} catch (e) {
// 解析失败，保持原样
}
}

14
lib/utils/book_dao.dart
View File

@@ -62,8 +62,8 @@ class BookDao {
);
}
// 软删除书籍记录
Future<int> softDeleteBook(String id) async {
// 软删除书籍记录（移入回收站）
Future<int> deleteBook(String id) async {
final db = await _dbHelper.database;
return await db.update(
'books',
@@ -76,16 +76,6 @@ class BookDao {
);
}
// 彻底删除书籍记录
Future<int> deleteBook(String id) async {
final db = await _dbHelper.database;
return await db.delete(
'books',
where: 'id = ?',
whereArgs: [id],
);
}
// 搜索书籍（标题、别名）
Future<List<Book>> searchBooks(String query) async {
final db = await _dbHelper.database;

29
lib/utils/database_helper.dart
View File

@@ -8,6 +8,17 @@ class DatabaseHelper {
DatabaseHelper._init();
/// 重新打开数据库（用于 WebDAV 同步后）
Future<void> reopenDatabase() async {
// 关闭现有连接
if (_database != null) {
await _database!.close();
_database = null;
}
// 重新初始化
_database = await _initDB('mooknote.db');
}
Future<Database> get database async {
if (_database != null) return _database!;
_database = await _initDB('mooknote.db');
@@ -20,7 +31,7 @@ class DatabaseHelper {
return await openDatabase(
path,
version: 8,
version: 9,
onCreate: _createDB,
onUpgrade: _onUpgrade,
);
@@ -59,6 +70,21 @@ class DatabaseHelper {
await _createBookReviewsTable(db);
await _createBookExcerptsTable(db);
}
if (oldVersion < 9) {
// 为笔记表添加图片字段
await _upgradeNotesTableV9(db);
}
}
/// 升级notes表到V9（添加图片字段）
Future<void> _upgradeNotesTableV9(Database db) async {
// 检查是否存在 images 列
final columns = await db.rawQuery('PRAGMA table_info(notes)');
final hasImages = columns.any((col) => col['name'] == 'images');
if (!hasImages) {
await db.execute('ALTER TABLE notes ADD COLUMN images TEXT');
}
}
/// 升级notes表到V6（添加软删除字段）
@@ -344,6 +370,7 @@ class DatabaseHelper {
content TEXT NOT NULL,
content_type TEXT DEFAULT 'markdown',
tags TEXT,
images TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
is_deleted INTEGER DEFAULT 0

163
lib/utils/image_path_helper.dart Normal file
View File

@@ -0,0 +1,163 @@
import 'dart:io';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as p;
/// 图片路径管理助手 - 按分类和ID组织图片存储
///
/// 存储结构：
/// images/movies/{movieId}/xxxx.jpg - 影视海报
/// images/movies/{movieId}/posterimgs/xxxx.jpg - 影视海报墙图片
/// images/books/{bookId}/xxxx.jpg - 书籍封面
/// images/notes/{noteId}/xxxx.jpg - 笔记图片
class ImagePathHelper {
static final ImagePathHelper instance = ImagePathHelper._init();
ImagePathHelper._init();
String? _appDirPath;
/// 获取应用文档目录
Future<String> get _appDir async {
if (_appDirPath != null) return _appDirPath!;
final appDir = await getApplicationDocumentsDirectory();
_appDirPath = appDir.path;
return _appDirPath!;
}
/// 获取图片根目录
Future<String> get imagesRoot async {
final appDir = await _appDir;
return p.join(appDir, 'images');
}
// ==================== 影视相关路径 ====================
/// 获取影视图片目录
/// 路径: images/movies/{movieId}/
Future<String> getMovieImagesDir(String movieId) async {
final root = await imagesRoot;
return p.join(root, 'movies', movieId);
}
/// 获取影视海报路径
/// 路径: images/movies/{movieId}/{fileName}
Future<String> getMoviePosterPath(String movieId, String fileName) async {
final dir = await getMovieImagesDir(movieId);
return p.join(dir, fileName);
}
/// 获取影视海报墙目录
/// 路径: images/movies/{movieId}/posterimgs/
Future<String> getMoviePosterImgsDir(String movieId) async {
final dir = await getMovieImagesDir(movieId);
return p.join(dir, 'posterimgs');
}
/// 获取影视海报墙图片路径
/// 路径: images/movies/{movieId}/posterimgs/{fileName}
Future<String> getMoviePosterImgPath(String movieId, String fileName) async {
final dir = await getMoviePosterImgsDir(movieId);
return p.join(dir, fileName);
}
// ==================== 书籍相关路径 ====================
/// 获取书籍图片目录
/// 路径: images/books/{bookId}/
Future<String> getBookImagesDir(String bookId) async {
final root = await imagesRoot;
return p.join(root, 'books', bookId);
}
/// 获取书籍封面路径
/// 路径: images/books/{bookId}/{fileName}
Future<String> getBookCoverPath(String bookId, String fileName) async {
final dir = await getBookImagesDir(bookId);
return p.join(dir, fileName);
}
// ==================== 笔记相关路径 ====================
/// 获取笔记图片目录
/// 路径: images/notes/{noteId}/
Future<String> getNoteImagesDir(String noteId) async {
final root = await imagesRoot;
return p.join(root, 'notes', noteId);
}
/// 获取笔记图片路径
/// 路径: images/notes/{noteId}/{fileName}
Future<String> getNoteImagePath(String noteId, String fileName) async {
final dir = await getNoteImagesDir(noteId);
return p.join(dir, fileName);
}
// ==================== 目录操作 ====================
/// 确保目录存在
Future<void> ensureDirExists(String dirPath) async {
final dir = Directory(dirPath);
if (!await dir.exists()) {
await dir.create(recursive: true);
}
}
/// 删除影视图片目录（包括海报和海报墙）
/// 删除路径: images/movies/{movieId}/
Future<void> deleteMovieImages(String movieId) async {
final dirPath = await getMovieImagesDir(movieId);
await _deleteDirectory(dirPath);
}
/// 删除书籍图片目录
/// 删除路径: images/books/{bookId}/
Future<void> deleteBookImages(String bookId) async {
final dirPath = await getBookImagesDir(bookId);
await _deleteDirectory(dirPath);
}
/// 删除笔记图片目录
/// 删除路径: images/notes/{noteId}/
Future<void> deleteNoteImages(String noteId) async {
final dirPath = await getNoteImagesDir(noteId);
await _deleteDirectory(dirPath);
}
/// 删除目录及其内容
Future<void> _deleteDirectory(String dirPath) async {
final dir = Directory(dirPath);
if (await dir.exists()) {
await dir.delete(recursive: true);
}
}
/// 移动文件到新位置
Future<String> moveFile(String sourcePath, String targetDir, String fileName) async {
await ensureDirExists(targetDir);
final targetPath = p.join(targetDir, fileName);
final sourceFile = File(sourcePath);
if (await sourceFile.exists()) {
await sourceFile.rename(targetPath);
}
return targetPath;
}
/// 复制文件到新位置
Future<String> copyFile(String sourcePath, String targetDir, String fileName) async {
await ensureDirExists(targetDir);
final targetPath = p.join(targetDir, fileName);
final sourceFile = File(sourcePath);
if (await sourceFile.exists()) {
await sourceFile.copy(targetPath);
}
return targetPath;
}
/// 删除单个文件
Future<void> deleteFile(String filePath) async {
final file = File(filePath);
if (await file.exists()) {
await file.delete();
}
}
}

704
lib/utils/webdav_service.dart
View File

@@ -1,3 +1,4 @@
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;
@@ -5,6 +6,9 @@ import 'package:path_provider/path_provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart' as p;
import 'package:archive/archive.dart';
import 'package:archive/archive_io.dart';
import 'database_helper.dart';
/// WebDAV 同步结果
class SyncResult {
@@ -15,7 +19,7 @@ class SyncResult {
final int downloadedFiles;
final int uploadedImages;
final int downloadedImages;
final bool needReload; // 是否需要重新加载数据
final bool needReload;
SyncResult({
required this.success,
@@ -43,7 +47,7 @@ class _ImageSyncResult {
_ImageSyncResult({required this.uploaded, required this.downloaded});
}
/// WebDAV 服务类
/// WebDAV 服务类 - 支持自动定时备份
class WebDAVService {
static final WebDAVService _instance = WebDAVService._internal();
static WebDAVService get instance => _instance;
@@ -52,8 +56,15 @@ class WebDAVService {
static const String _configKey = 'webdav_config';
static const String _lastSyncKey = 'webdav_last_sync';
static const String _autoSyncKey = 'webdav_auto_sync';
static const String _backupListKey = 'webdav_backup_list';
static const int _maxBackupCount = 10; // 保留最近10条备份
static const Duration _autoSyncInterval = Duration(minutes: 2); // 每2分钟自动备份
Map<String, String>? _cachedConfig;
Timer? _autoSyncTimer;
bool _isAutoSyncEnabled = false;
/// 获取配置
Future<Map<String, String>?> getConfig() async {
@@ -99,7 +110,10 @@ class WebDAVService {
final prefs = await SharedPreferences.getInstance();
await prefs.remove(_configKey);
await prefs.remove(_lastSyncKey);
await prefs.remove(_autoSyncKey);
await prefs.remove(_backupListKey);
_cachedConfig = null;
stopAutoSync();
}
/// 测试连接
@@ -110,13 +124,11 @@ class WebDAVService {
required String path,
}) async {
try {
// 构建 WebDAV URL
final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
var davUrl = '$baseUrl$path';
print('WebDAV: Testing connection to $davUrl');
// 先尝试 PROPFIND 请求（更通用的测试方式）
final client = http.Client();
try {
var propfindRequest = http.Request('PROPFIND', Uri.parse(davUrl));
@@ -132,15 +144,12 @@ class WebDAVService {
var propfindResponse = await client.send(propfindRequest);
print('WebDAV: PROPFIND status ${propfindResponse.statusCode}');
// 处理重定向 (301, 302, 307, 308)
if (propfindResponse.statusCode == 301 ||
propfindResponse.statusCode == 302 ||
propfindResponse.statusCode == 307 ||
propfindResponse.statusCode == 308) {
final location = propfindResponse.headers['location'];
if (location != null) {
print('WebDAV: Redirecting to $location');
// 使用重定向后的 URL 重新请求
davUrl = location;
propfindRequest = http.Request('PROPFIND', Uri.parse(davUrl));
propfindRequest.headers['Authorization'] = _basicAuth(username, password);
@@ -152,7 +161,6 @@ class WebDAVService {
</D:prop>
</D:propfind>''';
propfindResponse = await client.send(propfindRequest);
print('WebDAV: PROPFIND after redirect status ${propfindResponse.statusCode}');
}
}
@@ -161,13 +169,7 @@ class WebDAVService {
} else if (propfindResponse.statusCode == 401) {
return {'success': false, 'message': '认证失败，请检查用户名和密码'};
} else if (propfindResponse.statusCode == 404) {
// 目录不存在，尝试创建
print('WebDAV: Directory not found, trying to create...');
} else if (propfindResponse.statusCode == 301 ||
propfindResponse.statusCode == 302 ||
propfindResponse.statusCode == 307 ||
propfindResponse.statusCode == 308) {
return {'success': false, 'message': '服务器重定向，请尝试使用 ${propfindResponse.headers["location"] ?? "其他地址"}'};
} else {
return {'success': false, 'message': '服务器返回错误: ${propfindResponse.statusCode}'};
}
@@ -175,7 +177,6 @@ class WebDAVService {
print('WebDAV: PROPFIND error: $e');
}
// 尝试创建目录
try {
final mkcolRequest = http.Request('MKCOL', Uri.parse(davUrl));
mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
@@ -206,7 +207,7 @@ class WebDAVService {
}
}
/// 同步数据（双向同步）
/// 同步数据（保留原有方法用于手动同步）
Future<SyncResult> syncData({SyncDirection direction = SyncDirection.bidirectional}) async {
final config = await getConfig();
if (config == null) {
@@ -219,17 +220,13 @@ class WebDAVService {
final password = config['password']!;
final path = config['path']!;
// 获取本地数据库文件路径
final dbPath = await getDatabasesPath();
final dbFile = File(p.join(dbPath, 'mooknote.db'));
print('WebDAV: Looking for database at ${dbFile.path}');
if (!await dbFile.exists()) {
return SyncResult(success: false, message: '本地数据库不存在');
}
// 构建 WebDAV URL
final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
var davUrl = '$baseUrl$path/mooknote.db';
final davImagesUrl = '$baseUrl$path/images';
@@ -241,37 +238,32 @@ class WebDAVService {
int downloadedImages = 0;
try {
// 1. 检查远程数据库是否存在
final remoteDbInfo = await _getRemoteFileInfo(client, davUrl, username, password);
if (direction == SyncDirection.upload) {
// 仅上传模式
print('WebDAV: Upload only mode');
final result = await _uploadFile(client, davUrl, username, password, dbFile);
if (result) {
uploadedFiles++;
// 同步图片
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
uploadedImages = imageResult.uploaded;
downloadedImages = imageResult.downloaded;
}
} else if (direction == SyncDirection.download) {
// 仅下载模式
print('WebDAV: Download only mode');
if (remoteDbInfo != null) {
final result = await _downloadFile(client, davUrl, username, password, dbFile);
if (result) {
downloadedFiles++;
// 同步图片
// 重新打开数据库以应用新数据
await DatabaseHelper.instance.reopenDatabase();
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.download);
uploadedImages = imageResult.uploaded;
downloadedImages = imageResult.downloaded;
}
} else {
return SyncResult(success: false, message: '远程数据库不存在');
}
} else {
// 双向同步模式
} else if (direction == SyncDirection.bidirectional) {
// 双向同步：比较时间戳决定上传还是下载
print('WebDAV: Bidirectional sync mode');
if (remoteDbInfo == null) {
@@ -280,7 +272,6 @@ class WebDAVService {
final result = await _uploadFile(client, davUrl, username, password, dbFile);
if (result) {
uploadedFiles++;
// 上传所有图片
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
uploadedImages = imageResult.uploaded;
}
@@ -300,10 +291,8 @@ class WebDAVService {
final result = await _uploadFile(client, davUrl, username, password, dbFile);
if (result) {
uploadedFiles++;
// 同步图片
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
uploadedImages = imageResult.uploaded;
downloadedImages = imageResult.downloaded;
}
} else if (timeDiff < -10) {
// 远程较新，下载
@@ -311,13 +300,13 @@ class WebDAVService {
final result = await _downloadFile(client, davUrl, username, password, dbFile);
if (result) {
downloadedFiles++;
// 同步图片
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
uploadedImages = imageResult.uploaded;
// 重新打开数据库以应用新数据
await DatabaseHelper.instance.reopenDatabase();
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.download);
downloadedImages = imageResult.downloaded;
}
} else {
// 时间相近，视为相同
// 时间相近，仅同步图片
print('WebDAV: Local and remote are similar, syncing images only...');
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
uploadedImages = imageResult.uploaded;
@@ -326,11 +315,9 @@ class WebDAVService {
}
}
// 保存同步时间
final prefs = await SharedPreferences.getInstance();
await prefs.setString(_lastSyncKey, DateTime.now().toIso8601String());
// 如果下载了数据库文件，需要重新加载
final needReload = downloadedFiles > 0;
return SyncResult(
@@ -366,7 +353,6 @@ class WebDAVService {
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
@@ -380,9 +366,7 @@ class WebDAVService {
}
if (response.statusCode == 207) {
// 解析 PROPFIND 响应获取修改时间
final body = await response.stream.bytesToString();
// 简单解析，提取 getlastmodified
final modifiedMatch = RegExp(r'<d:getlastmodified>([^<]+)</d:getlastmodified>', caseSensitive: false)
.firstMatch(body);
if (modifiedMatch != null) {
@@ -399,6 +383,493 @@ class WebDAVService {
}
}
/// 启动自动同步
Future<void> startAutoSync() async {
if (_autoSyncTimer != null) {
_autoSyncTimer!.cancel();
}
final prefs = await SharedPreferences.getInstance();
_isAutoSyncEnabled = true;
await prefs.setBool(_autoSyncKey, true);
// 立即执行一次备份
await performTimedBackup();
// 设置定时器，每5分钟执行一次
_autoSyncTimer = Timer.periodic(_autoSyncInterval, (timer) async {
if (_isAutoSyncEnabled) {
await performTimedBackup();
}
});
print('WebDAV: 自动备份已启动，每2分钟执行一次');
}
/// 停止自动同步
Future<void> stopAutoSync() async {
_autoSyncTimer?.cancel();
_autoSyncTimer = null;
_isAutoSyncEnabled = false;
final prefs = await SharedPreferences.getInstance();
await prefs.setBool(_autoSyncKey, false);
print('WebDAV: 自动备份已停止');
}
/// 检查自动同步状态
Future<bool> isAutoSyncEnabled() async {
if (_autoSyncTimer != null) {
return _isAutoSyncEnabled;
}
final prefs = await SharedPreferences.getInstance();
return prefs.getBool(_autoSyncKey) ?? false;
}
/// 执行定时备份（按时间命名，保留最近10条）
Future<SyncResult> performTimedBackup() async {
final config = await getConfig();
if (config == null) {
return SyncResult(success: false, message: '未配置 WebDAV');
}
try {
final url = config['url']!;
final username = config['username']!;
final password = config['password']!;
final basePath = config['path']!;
// 获取本地数据库文件路径
final dbPath = await getDatabasesPath();
final dbFile = File(p.join(dbPath, 'mooknote.db'));
if (!await dbFile.exists()) {
return SyncResult(success: false, message: '本地数据库不存在');
}
// 构建 WebDAV URL（使用时间戳命名）
final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
final timestamp = _formatTimestamp(DateTime.now());
final backupFileName = 'mooknote_$timestamp.zip';
final davUrl = '$baseUrl$basePath/$backupFileName';
final davImagesUrl = '$baseUrl$basePath/images';
print('WebDAV: 开始定时备份到 $davUrl');
final client = http.Client();
int uploadedImages = 0;
try {
// 1. 创建完整的备份 ZIP（包含数据库和图片）
final zipBytes = await _createFullBackupZip(dbFile);
if (zipBytes == null) {
return SyncResult(success: false, message: '创建备份文件失败');
}
// 2. 上传备份文件
final success = await _uploadBytes(client, davUrl, username, password, zipBytes);
if (!success) {
return SyncResult(success: false, message: '上传备份文件失败');
}
// 3. 同步图片到 images 目录
final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
uploadedImages = imageResult.uploaded;
// 4. 更新备份列表并清理旧备份
await _updateBackupListAndCleanup(client, baseUrl, basePath, username, password, backupFileName);
// 5. 保存同步时间
final prefs = await SharedPreferences.getInstance();
await prefs.setString(_lastSyncKey, DateTime.now().toIso8601String());
print('WebDAV: 定时备份完成 - $backupFileName');
return SyncResult(
success: true,
message: '备份完成: $backupFileName',
lastSyncTime: DateTime.now(),
uploadedFiles: 1,
uploadedImages: uploadedImages,
needReload: false,
);
} finally {
client.close();
}
} catch (e) {
print('WebDAV: 定时备份错误: $e');
return SyncResult(success: false, message: '备份失败: $e');
}
}
/// 创建完整的备份 ZIP（包含数据库和所有图片）
/// 支持新的图片存储结构：images/movies/{id}/、images/books/{id}/、images/notes/{id}/
Future<List<int>?> _createFullBackupZip(File dbFile) async {
try {
final archive = Archive();
// 添加数据库文件
final dbBytes = await dbFile.readAsBytes();
archive.addFile(ArchiveFile('mooknote.db', dbBytes.length, dbBytes));
// 添加所有图片（递归遍历子目录）
final appDir = await getApplicationDocumentsDirectory();
final imagesDir = Directory('${appDir.path}/images');
if (await imagesDir.exists()) {
await _addImagesToArchive(archive, imagesDir, 'images');
}
// 添加备份信息
final backupInfo = {
'version': 2,
'backupTime': DateTime.now().toIso8601String(),
'appName': 'MookNote',
'type': 'timed_backup',
'structure': 'hierarchical', // 标记为分层结构
};
final infoJson = jsonEncode(backupInfo);
final infoBytes = utf8.encode(infoJson);
archive.addFile(ArchiveFile('backup_info.json', infoBytes.length, infoBytes));
// 压缩
final zipEncoder = ZipEncoder();
return zipEncoder.encode(archive);
} catch (e) {
print('WebDAV: 创建备份 ZIP 失败: $e');
return null;
}
}
/// 递归添加图片到归档
Future<void> _addImagesToArchive(Archive archive, Directory dir, String relativePath) async {
await for (final entity in dir.list()) {
if (entity is File) {
final fileName = p.basename(entity.path);
final bytes = await entity.readAsBytes();
final archivePath = '$relativePath/$fileName';
archive.addFile(ArchiveFile(archivePath, bytes.length, bytes));
print('WebDAV: 添加文件到备份 - $archivePath');
} else if (entity is Directory) {
final dirName = p.basename(entity.path);
await _addImagesToArchive(archive, entity, '$relativePath/$dirName');
}
}
}
/// 更新备份列表并清理旧备份
Future<void> _updateBackupListAndCleanup(
http.Client client,
String baseUrl,
String basePath,
String username,
String password,
String newBackupName,
) async {
try {
final prefs = await SharedPreferences.getInstance();
// 获取现有备份列表
List<String> backupList = [];
final listJson = prefs.getString(_backupListKey);
if (listJson != null) {
backupList = List<String>.from(jsonDecode(listJson));
}
// 添加新备份
backupList.add(newBackupName);
// 如果超过10条，删除最旧的备份
while (backupList.length > _maxBackupCount) {
final oldBackup = backupList.removeAt(0);
final deleteUrl = '$baseUrl$basePath/$oldBackup';
await _deleteFile(client, deleteUrl, username, password);
print('WebDAV: 删除旧备份 $oldBackup');
}
// 保存更新后的列表
await prefs.setString(_backupListKey, jsonEncode(backupList));
print('WebDAV: 备份列表已更新，当前 ${backupList.length} 个备份');
} catch (e) {
print('WebDAV: 更新备份列表失败: $e');
}
}
/// 删除远程文件
Future<void> _deleteFile(
http.Client client,
String url,
String username,
String password,
) async {
try {
var request = http.Request('DELETE', Uri.parse(url));
request.headers['Authorization'] = _basicAuth(username, password);
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
if (location != null) {
request = http.Request('DELETE', Uri.parse(location));
request.headers['Authorization'] = _basicAuth(username, password);
response = await client.send(request);
}
}
} catch (e) {
print('WebDAV: 删除文件失败: $e');
}
}
/// 上传字节数据
Future<bool> _uploadBytes(
http.Client client,
String url,
String username,
String password,
List<int> bytes,
) async {
try {
var request = http.Request('PUT', Uri.parse(url));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Content-Type'] = 'application/zip';
request.bodyBytes = bytes;
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
if (location != null) {
request = http.Request('PUT', Uri.parse(location));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Content-Type'] = 'application/zip';
request.bodyBytes = bytes;
response = await client.send(request);
}
}
return response.statusCode == 201 || response.statusCode == 204;
} catch (e) {
print('WebDAV: 上传失败: $e');
return false;
}
}
/// 格式化时间戳用于文件名
String _formatTimestamp(DateTime dateTime) {
return '${dateTime.year}${_pad(dateTime.month)}${_pad(dateTime.day)}_${_pad(dateTime.hour)}${_pad(dateTime.minute)}${_pad(dateTime.second)}';
}
String _pad(int number) {
return number.toString().padLeft(2, '0');
}
/// 同步图片（支持新的目录结构）
/// 同步 images/movies/{id}/、images/books/{id}/、images/notes/{id}/ 下的所有图片
Future<_ImageSyncResult> _syncImages(
http.Client client,
String imagesUrl,
String username,
String password,
SyncDirection direction,
) async {
int uploaded = 0;
int downloaded = 0;
try {
// 获取本地图片目录
final appDir = await getApplicationDocumentsDirectory();
final localImagesDir = Directory('${appDir.path}/images');
if (!await localImagesDir.exists()) {
await localImagesDir.create(recursive: true);
}
// 递归获取本地所有图片文件（包含子目录）
final localImages = <String, File>{}; // 相对路径 -> 文件
await _collectLocalImages(localImagesDir, localImages, '');
print('WebDAV: Local images: ${localImages.length}');
// 递归获取远程所有图片文件
final remoteImages = await _listRemoteImagesRecursive(client, imagesUrl, username, password, '');
print('WebDAV: Remote images: ${remoteImages.length}');
if (direction == SyncDirection.upload) {
// 仅上传：上传所有本地图片
for (final entry in localImages.entries) {
final relativePath = entry.key;
final remoteUrl = '$imagesUrl/$relativePath';
// 确保远程父目录存在
final parentPath = p.dirname(relativePath);
if (parentPath != '.' && parentPath.isNotEmpty) {
final parentUrl = '$imagesUrl/$parentPath';
await _ensureRemoteDir(client, parentUrl, username, password);
}
final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
if (success) uploaded++;
}
} else if (direction == SyncDirection.download) {
// 仅下载：下载所有远程图片
for (final relativePath in remoteImages) {
final remoteUrl = '$imagesUrl/$relativePath';
final localFile = File('${localImagesDir.path}/$relativePath');
// 确保父目录存在
await localFile.parent.create(recursive: true);
final success = await _downloadFile(client, remoteUrl, username, password, localFile);
if (success) downloaded++;
}
}
} catch (e) {
print('WebDAV: Sync images error: $e');
}
return _ImageSyncResult(uploaded: uploaded, downloaded: downloaded);
}
/// 递归收集本地图片文件
Future<void> _collectLocalImages(Directory dir, Map<String, File> result, String relativePath) async {
await for (final entity in dir.list()) {
if (entity is File) {
final fileName = p.basename(entity.path);
final path = relativePath.isEmpty ? fileName : '$relativePath/$fileName';
result[path] = entity;
} else if (entity is Directory) {
final dirName = p.basename(entity.path);
final newRelativePath = relativePath.isEmpty ? dirName : '$relativePath/$dirName';
await _collectLocalImages(entity, result, newRelativePath);
}
}
}
/// 获取远程图片列表（递归获取所有子目录中的图片）
Future<List<String>> _listRemoteImagesRecursive(
http.Client client,
String imagesUrl,
String username,
String password,
String relativePath,
) async {
final images = <String>[];
final currentUrl = relativePath.isEmpty ? imagesUrl : '$imagesUrl/$relativePath';
try {
// 创建图片目录（如果不存在）
final mkcolRequest = http.Request('MKCOL', Uri.parse(currentUrl));
mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
await client.send(mkcolRequest);
// 列出目录内容
var request = http.Request('PROPFIND', Uri.parse(currentUrl));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Depth'] = '1';
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
if (location != null) {
final newUrl = location;
request = http.Request('PROPFIND', Uri.parse(newUrl));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Depth'] = '1';
response = await client.send(request);
}
}
if (response.statusCode == 207) {
final body = await response.stream.bytesToString();
// 解析响应，提取文件和目录
final hrefMatches = RegExp(r'<d:href>([^<]+)</d:href>', caseSensitive: false)
.allMatches(body);
for (final match in hrefMatches) {
final href = match.group(1)!;
final name = p.basename(href);
// 跳过当前目录自身
if (name.isEmpty) continue;
if (relativePath.isEmpty && name == 'images') continue;
// 检查是文件还是目录
final isDirectory = body.substring(
match.start,
match.end + 200 < body.length ? match.end + 200 : body.length,
).contains('<d:collection');
if (isDirectory) {
// 递归获取子目录中的图片
final newRelativePath = relativePath.isEmpty ? name : '$relativePath/$name';
final subImages = await _listRemoteImagesRecursive(
client, imagesUrl, username, password, newRelativePath,
);
images.addAll(subImages);
} else {
// 是文件，添加到列表
final filePath = relativePath.isEmpty ? name : '$relativePath/$name';
images.add(filePath);
}
}
}
} catch (e) {
print('WebDAV: List remote images error: $e');
}
return images;
}
/// 确保远程目录存在
Future<void> _ensureRemoteDir(
http.Client client,
String dirUrl,
String username,
String password,
) async {
try {
var request = http.Request('MKCOL', Uri.parse(dirUrl));
request.headers['Authorization'] = _basicAuth(username, password);
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
if (location != null) {
request = http.Request('MKCOL', Uri.parse(location));
request.headers['Authorization'] = _basicAuth(username, password);
response = await client.send(request);
}
}
// 201 = 创建成功, 405 = 目录已存在, 409 = 父目录不存在需要先创建
if (response.statusCode == 409) {
// 需要创建父目录
final parentPath = p.dirname(dirUrl);
if (parentPath != dirUrl) {
await _ensureRemoteDir(client, parentPath, username, password);
// 再次尝试创建当前目录
request = http.Request('MKCOL', Uri.parse(dirUrl));
request.headers['Authorization'] = _basicAuth(username, password);
await client.send(request);
}
}
} catch (e) {
print('WebDAV: 创建目录失败: $e');
}
}
/// 上传文件
Future<bool> _uploadFile(
http.Client client,
@@ -474,155 +945,6 @@ class WebDAVService {
}
}
/// 同步图片
Future<_ImageSyncResult> _syncImages(
http.Client client,
String imagesUrl,
String username,
String password,
SyncDirection direction,
) async {
int uploaded = 0;
int downloaded = 0;
try {
// 获取本地图片目录
final appDir = await getApplicationDocumentsDirectory();
final localImagesDir = Directory('${appDir.path}/images');
if (!await localImagesDir.exists()) {
await localImagesDir.create(recursive: true);
}
// 获取本地图片列表
final localImages = <String, File>{};
if (await localImagesDir.exists()) {
await for (final entity in localImagesDir.list()) {
if (entity is File) {
final name = p.basename(entity.path);
localImages[name] = entity;
}
}
}
print('WebDAV: Local images: ${localImages.length}');
// 获取远程图片列表
final remoteImages = await _listRemoteImages(client, imagesUrl, username, password);
print('WebDAV: Remote images: ${remoteImages.length}');
if (direction == SyncDirection.upload) {
// 仅上传：上传所有本地图片
for (final entry in localImages.entries) {
final remoteUrl = '$imagesUrl/${entry.key}';
final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
if (success) uploaded++;
}
} else if (direction == SyncDirection.download) {
// 仅下载：下载所有远程图片
for (final name in remoteImages) {
final remoteUrl = '$imagesUrl/$name';
final localFile = File('${localImagesDir.path}/$name');
final success = await _downloadFile(client, remoteUrl, username, password, localFile);
if (success) downloaded++;
}
} else {
// 双向同步：比较时间戳
// 上传本地有但远程没有的
for (final entry in localImages.entries) {
if (!remoteImages.contains(entry.key)) {
final remoteUrl = '$imagesUrl/${entry.key}';
final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
if (success) uploaded++;
}
}
// 下载远程有但本地没有的
for (final name in remoteImages) {
if (!localImages.containsKey(name)) {
final remoteUrl = '$imagesUrl/$name';
final localFile = File('${localImagesDir.path}/$name');
final success = await _downloadFile(client, remoteUrl, username, password, localFile);
if (success) downloaded++;
}
}
}
} catch (e) {
print('WebDAV: Sync images error: $e');
}
return _ImageSyncResult(uploaded: uploaded, downloaded: downloaded);
}
/// 获取远程图片列表
Future<List<String>> _listRemoteImages(
http.Client client,
String imagesUrl,
String username,
String password,
) async {
final images = <String>[];
try {
// 创建图片目录（如果不存在）
final mkcolRequest = http.Request('MKCOL', Uri.parse(imagesUrl));
mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
await client.send(mkcolRequest);
// 列出目录内容
var request = http.Request('PROPFIND', Uri.parse(imagesUrl));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Depth'] = '1';
var response = await client.send(request);
// 处理重定向
if (response.statusCode == 301 || response.statusCode == 302 ||
response.statusCode == 307 || response.statusCode == 308) {
final location = response.headers['location'];
if (location != null) {
imagesUrl = location;
request = http.Request('PROPFIND', Uri.parse(imagesUrl));
request.headers['Authorization'] = _basicAuth(username, password);
request.headers['Depth'] = '1';
response = await client.send(request);
}
}
if (response.statusCode == 207) {
final body = await response.stream.bytesToString();
// 解析响应，提取文件名
final hrefMatches = RegExp(r'<d:href>([^<]+)</d:href>', caseSensitive: false)
.allMatches(body);
for (final match in hrefMatches) {
final href = match.group(1)!;
final name = p.basename(href);
if (name.isNotEmpty && name != 'images') {
images.add(name);
}
}
}
} catch (e) {
print('WebDAV: List remote images error: $e');
}
return images;
}
/// 获取上次同步时间
Future<DateTime?> getLastSyncTime() async {
final prefs = await SharedPreferences.getInstance();
final timeStr = prefs.getString(_lastSyncKey);
if (timeStr != null) {
try {
return DateTime.parse(timeStr);
} catch (e) {
return null;
}
}
return null;
}
/// Basic Auth 编码
String _basicAuth(String username, String password) {
final credentials = base64Encode(utf8.encode('$username:$password'));