Files
flypic/backend/src/services/FileService.js
T
2025-12-07 11:37:00 +08:00

1047 lines
35 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 文件操作服务
* 提供删除、重命名、移动、复制等文件操作功能
*/
const fs = require('fs');
const path = require('path');
const { processImage } = require('../../utils/scanner');
const { constants } = require('../config');
const logger = require('../utils/logger');
// 临时备份目录(用于撤销恢复)
const TEMP_BACKUP_DIR = constants.PATHS.TEMP_BACKUP_DIR;
class FileService {
constructor(dbPool, configManager) {
this.dbPool = dbPool;
this.configManager = configManager;
}
/**
* 恢复文件(从临时备份恢复)
* @param {string} libraryId - 素材库ID
* @param {Array} items - 待恢复项 [{type: 'file'|'folder', path: 'relative/path'}]
*/
async restoreItems(libraryId, items) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const backupDir = path.join(libraryPath, TEMP_BACKUP_DIR);
const results = { success: [], failed: [] };
if (!fs.existsSync(backupDir)) {
throw new Error('备份目录不存在,无法恢复');
}
for (const item of items) {
try {
const backupPath = path.join(backupDir, item.path);
const originalPath = path.join(libraryPath, item.path);
const metaPath = backupPath + '.meta.json';
console.log(`🔄 开始恢复: ${item.path} (${item.type})`);
// 检查备份是否存在
if (!fs.existsSync(backupPath)) {
results.failed.push({ path: item.path, error: '备份不存在(可能已超过5分钟被清理)' });
continue;
}
// 确保目标目录存在
const targetDir = path.dirname(originalPath);
if (!fs.existsSync(targetDir)) {
fs.mkdirSync(targetDir, { recursive: true });
}
// 读取元数据文件(包含数据库记录)
let imageRecords = null;
let folderRecords = null;
if (fs.existsSync(metaPath)) {
try {
const metaContent = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
imageRecords = metaContent.imageRecords;
folderRecords = metaContent.folderRecords;
console.log(` 读取到 ${Array.isArray(imageRecords) ? imageRecords.length : (imageRecords ? 1 : 0)} 条图片记录`);
console.log(` 读取到 ${folderRecords ? folderRecords.length : 0} 条文件夹记录`);
} catch (error) {
console.warn(`读取meta失败 ${metaPath}:`, error);
}
}
// 移动回原位置
try {
fs.renameSync(backupPath, originalPath);
} catch (renameError) {
console.log(` ⚠️ rename失败,使用复制方式`);
// rename 失败时使用复制+删除
if (item.type === 'folder') {
this._copyDirSync(backupPath, originalPath);
fs.rmSync(backupPath, { recursive: true, force: true });
} else {
fs.copyFileSync(backupPath, originalPath);
fs.unlinkSync(backupPath);
}
}
// 恢复数据库记录(先文件夹后图片)
if (folderRecords && folderRecords.length > 0) {
for (const folderRecord of folderRecords) {
try {
const stmt = db.db.prepare(
'INSERT OR REPLACE INTO folders (path, parent_path, name, image_count, last_scan) VALUES (?, ?, ?, ?, ?)'
);
stmt.run(
folderRecord.path,
folderRecord.parent_path || null,
folderRecord.name,
folderRecord.image_count || 0,
folderRecord.last_scan || Date.now()
);
} catch (error) {
console.warn(`恢复文件夹记录失败: ${folderRecord.path}`, error);
}
}
} else if (item.type === 'folder') {
// 空文件夹没有数据库记录,需要重新创建
try {
const folderName = path.basename(item.path);
const parentPath = path.dirname(item.path);
const stmt = db.db.prepare(
'INSERT OR REPLACE INTO folders (path, parent_path, name, image_count, last_scan) VALUES (?, ?, ?, ?, ?)'
);
stmt.run(
item.path,
parentPath === '.' ? null : parentPath,
folderName,
0,
Date.now()
);
console.log(` 创建空文件夹记录: ${item.path}`);
} catch (error) {
console.warn(`创建文件夹记录失败: ${item.path}`, error);
}
}
if (imageRecords) {
const records = Array.isArray(imageRecords) ? imageRecords : [imageRecords];
for (const record of records) {
try {
db.insertImage(record);
} catch (error) {
console.warn(`恢复图片记录失败: ${record.path}`, error);
}
}
}
// 删除元数据文件
if (fs.existsSync(metaPath)) {
fs.unlinkSync(metaPath);
}
results.success.push(item.path);
console.log(`✅ 恢复成功: ${item.path}`);
} catch (error) {
console.error(`恢复失败 ${item.path}:`, error);
results.failed.push({ path: item.path, error: error.message });
}
}
// 如果备份目录为空,删除它
try {
const files = fs.readdirSync(backupDir);
if (files.length === 0) {
fs.rmdirSync(backupDir);
}
} catch (error) {
// 忽略错误
}
// 更新文件夹计数(关键:确保计数准确)
if (results.success.length > 0) {
db.updateAllFolderCounts();
}
return results;
}
/**
* 清理过期的临时文件(超过5分钟的移入回收站)
* @param {string} libraryId - 素材库ID
*/
async cleanExpiredTempFiles(libraryId) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const backupDir = path.join(libraryPath, TEMP_BACKUP_DIR);
if (!fs.existsSync(backupDir)) {
return { cleaned: 0, failed: 0, thumbnailsCleaned: 0 };
}
const EXPIRY_TIME = constants.FILE_OPERATIONS.TEMP_FILE_EXPIRY_MS;
const now = Date.now();
let cleaned = 0;
let failed = 0;
let thumbnailsCleaned = 0; // 统计清理的缩略图数量
// 递归扫描备份目录
const scanDir = async (dir) => {
const files = fs.readdirSync(dir);
for (const file of files) {
const fullPath = path.join(dir, file);
// 跳过 meta 文件
if (file.endsWith('.meta.json')) continue;
const metaPath = fullPath + '.meta.json';
// 检查是否有对应的 meta 文件
if (fs.existsSync(metaPath)) {
try {
const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
const age = now - meta.deletedAt;
// 超过配置的过期时间,移入系统回收站
if (age > EXPIRY_TIME) {
try {
// 1. 清理缩略图(在移入回收站前)
if (meta.imageRecords) {
const records = Array.isArray(meta.imageRecords) ? meta.imageRecords : [meta.imageRecords];
for (const record of records) {
if (record.thumbnail_path) {
try {
const thumbnailFullPath = path.join(libraryPath, record.thumbnail_path);
if (fs.existsSync(thumbnailFullPath)) {
fs.unlinkSync(thumbnailFullPath);
thumbnailsCleaned++;
logger.debug(`已清理缩略图: ${record.thumbnail_path}`);
}
} catch (thumbError) {
logger.warn(`清理缩略图失败 ${record.thumbnail_path}:`, thumbError.message);
}
}
}
}
// 2. 移入系统回收站
// trash v8 是 ESM 模块,需要使用动态 import
const { default: trash } = await import('trash');
await trash([fullPath]);
fs.unlinkSync(metaPath); // 删除 meta 文件
cleaned++;
logger.info(`已将过期文件移入回收站: ${meta.originalPath}`);
} catch (error) {
logger.error(`清理失败 ${meta.originalPath}:`, error);
failed++;
}
}
} catch (error) {
logger.error(`读取 meta 失败 ${metaPath}:`, error);
}
} else if (fs.statSync(fullPath).isDirectory()) {
// 递归处理子目录
await scanDir(fullPath);
}
}
};
await scanDir(backupDir);
// 清理完成后,递归删除所有空文件夹
const removeEmptyDirs = (dir) => {
try {
// 检查目录是否存在
if (!fs.existsSync(dir)) {
return;
}
// 读取目录内容
let entries;
try {
entries = fs.readdirSync(dir);
} catch (error) {
// 目录可能已被删除或无权限访问
return;
}
// 先递归处理所有子目录
for (const entry of entries) {
const fullPath = path.join(dir, entry);
try {
// 检查是否存在且为目录
if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
removeEmptyDirs(fullPath);
}
} catch (error) {
// 文件可能在处理过程中被删除,忽略
continue;
}
}
// 再次检查当前目录是否为空(因为子目录可能已被删除)
let remainingFiles;
try {
remainingFiles = fs.readdirSync(dir);
} catch (error) {
// 目录可能已被删除
return;
}
// 如果目录为空,则删除它(除了根 temp_backup 目录)
if (remainingFiles.length === 0) {
if (dir === backupDir) {
// 根目录也删除(如果完全为空)
try {
fs.rmdirSync(dir);
logger.debug(`已删除空的备份目录: ${TEMP_BACKUP_DIR}`);
} catch (error) {
// 忽略根目录删除失败
}
} else {
// 子目录删除
try {
fs.rmdirSync(dir);
const relativePath = path.relative(backupDir, dir);
logger.debug(`已删除空文件夹: ${relativePath}`);
} catch (error) {
// 忽略删除失败(可能权限问题)
}
}
}
} catch (error) {
// 忽略所有其他错误
}
};
// 执行清理空文件夹
try {
removeEmptyDirs(backupDir);
} catch (error) {
logger.warn('[cleanExpiredTempFiles] 清理空文件夹时出错:', error.message);
}
return { cleaned, failed, thumbnailsCleaned };
}
/**
* 获取数据库实例
*/
_getDatabase(libraryId) {
const config = this.configManager.load();
const library = config.libraries.find(lib => lib.id === libraryId);
if (!library) {
throw new Error(`素材库不存在: ${libraryId}`);
}
return this.dbPool.acquire(library.path);
}
/**
* 删除文件或文件夹(移到临时文件夹,5分钟内可撤销)
* @param {string} libraryId - 素材库ID
* @param {Array} items - 待删除项 [{type: 'file'|'folder', path: 'relative/path'}]
*/
async deleteItems(libraryId, items) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const results = { success: [], failed: [] };
for (const item of items) {
try {
const fullPath = path.join(libraryPath, item.path);
// 检查文件/文件夹是否存在
if (!fs.existsSync(fullPath)) {
if (item.type === 'folder') {
// 物理文件夹已不存在:视为只需要清理数据库中的“空壳”记录
console.warn(`目标文件夹不存在,仅清理数据库记录: ${item.path}`);
try {
db.deleteImagesByFolderPrefix(item.path);
db.deleteFoldersByPrefix(item.path);
results.success.push(item.path);
} catch (e) {
console.error(`清理不存在文件夹的数据库记录失败 ${item.path}:`, e.message);
results.failed.push({ path: item.path, error: e.message });
}
} else {
// 文件不存在仍然视为失败,提示用户
results.failed.push({ path: item.path, error: '文件不存在' });
}
continue;
}
// 移到临时备份文件夹(5分钟内可撤销)
const backupDir = path.join(libraryPath, TEMP_BACKUP_DIR);
if (!fs.existsSync(backupDir)) {
fs.mkdirSync(backupDir, { recursive: true });
}
const backupPath = path.join(backupDir, item.path);
const backupParentDir = path.dirname(backupPath);
// 确保备份目录存在
if (!fs.existsSync(backupParentDir)) {
fs.mkdirSync(backupParentDir, { recursive: true });
}
// 移动文件到备份目录
try {
// 尝试直接 rename(快速)
fs.renameSync(fullPath, backupPath);
} catch (renameError) {
// rename 失败(可能是权限问题或跨磁盘),使用复制+删除
console.log(`⚠️ rename失败,使用复制方式: ${item.path}`);
if (item.type === 'folder') {
// 文件夹:递归复制
this._copyDirSync(fullPath, backupPath);
// 删除原文件夹
fs.rmSync(fullPath, { recursive: true, force: true });
} else {
// 文件:直接复制
fs.copyFileSync(fullPath, backupPath);
fs.unlinkSync(fullPath);
}
}
// 记录删除时间(用于5分钟后清理)
const metaPath = backupPath + '.meta.json';
fs.writeFileSync(metaPath, JSON.stringify({
originalPath: item.path,
deletedAt: Date.now(),
type: item.type
}));
console.log(`📦 已移入临时文件夹: ${item.path}`);
// 删除数据库记录前,先保存到meta(恢复时需要)
let imageRecords = null;
let folderRecords = null;
if (item.type === 'folder') {
// 保存文件夹内所有图片和文件夹的数据库记录
imageRecords = db.getImagesByFolderPrefix(item.path);
const stmt = db.db.prepare('SELECT * FROM folders WHERE path = ? OR path LIKE ?');
folderRecords = stmt.all(item.path, `${item.path}/%`);
console.log(`🔍 删除文件夹: ${item.path} (图片:${imageRecords?.length || 0}, 子文件夹:${folderRecords?.length || 0})`);
// 删除数据库记录
db.deleteImagesByFolderPrefix(item.path);
db.deleteFoldersByPrefix(item.path);
} else {
// 保存单个文件的数据库记录
imageRecords = db.getImageByPath(item.path);
db.deleteImage(item.path);
}
// 更新meta文件,包含数据库记录(只保存非空记录)
const metaContent = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
if (imageRecords && (Array.isArray(imageRecords) ? imageRecords.length > 0 : true)) {
metaContent.imageRecords = imageRecords;
}
if (folderRecords && folderRecords.length > 0) {
metaContent.folderRecords = folderRecords;
}
fs.writeFileSync(metaPath, JSON.stringify(metaContent));
// 删除缩略图(可选,因为缩略图基于 hash,可能被其他文件共享)
// this._deleteThumbnail(db, item.path);
results.success.push(item.path);
} catch (error) {
console.error(`删除失败 ${item.path}:`, error.message);
results.failed.push({ path: item.path, error: error.message });
}
}
// 更新文件夹计数
if (results.success.length > 0) {
db.updateAllFolderCounts();
}
return results;
}
/**
* 递归复制文件夹(辅助方法)
* @private
*/
_copyDirSync(src, dest) {
// 创建目标目录
if (!fs.existsSync(dest)) {
fs.mkdirSync(dest, { recursive: true });
}
// 读取源目录内容
const entries = fs.readdirSync(src, { withFileTypes: true });
for (const entry of entries) {
const srcPath = path.join(src, entry.name);
const destPath = path.join(dest, entry.name);
if (entry.isDirectory()) {
// 递归复制子目录
this._copyDirSync(srcPath, destPath);
} else {
// 复制文件
fs.copyFileSync(srcPath, destPath);
}
}
}
/**
* 重命名文件或文件夹
* @param {string} libraryId - 素材库ID
* @param {string} oldPath - 旧路径(相对路径,使用正斜杠)
* @param {string} newName - 新名称(不含路径)
*/
async renameItem(libraryId, oldPath, newName) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
// 归一化旧路径,确保使用正斜杠
const normalizedOldPath = oldPath.replace(/\\/g, '/');
const fullOldPath = path.join(libraryPath, normalizedOldPath);
// 检查文件/文件夹是否存在
if (!fs.existsSync(fullOldPath)) {
throw new Error('文件不存在');
}
const stat = fs.lstatSync(fullOldPath);
const isDirectory = stat.isDirectory();
const directory = path.dirname(fullOldPath);
const initialNewPath = path.join(directory, newName);
// 如果目标已存在,则自动编号避免冲突
let finalFullNewPath = initialNewPath;
let finalNewName = newName;
if (fs.existsSync(finalFullNewPath)) {
const ext = isDirectory ? '' : path.extname(newName);
const basename = isDirectory ? newName : path.basename(newName, ext);
let counter = 1;
while (fs.existsSync(finalFullNewPath)) {
const numberedName = isDirectory
? `${basename} (${counter})`
: `${basename} (${counter})${ext}`;
finalFullNewPath = path.join(directory, numberedName);
finalNewName = numberedName;
counter++;
}
}
// 执行重命名(文件或文件夹)
fs.renameSync(fullOldPath, finalFullNewPath);
// 计算新的相对路径
const newRelativePath = path
.relative(libraryPath, finalFullNewPath)
.replace(/\\/g, '/');
if (isDirectory) {
// 文件夹:更新 folders 表与 images 表中所有相关记录
this._updateFolderPathInDatabase(db, normalizedOldPath, newRelativePath);
} else {
// 单个文件:仅更新 images 表中的一条记录
this._updatePathInDatabase(db, normalizedOldPath, newRelativePath);
}
return { newPath: newRelativePath, newName: finalNewName };
}
/**
* 移动文件或文件夹
* @param {string} libraryId - 素材库ID
* @param {Array} items - 待移动项
* @param {string} targetFolder - 目标文件夹(相对路径)
*/
async moveItems(libraryId, items, targetFolder) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const results = { success: [], failed: [] };
for (const item of items) {
try {
// 归一化路径(使用正斜杠)
const oldPath = item.path.replace(/\\/g, '/');
const fileName = path.basename(oldPath);
const normalizedTarget = targetFolder ? targetFolder.replace(/\\/g, '/') : '';
// 目标文件夹相对路径
const newRelativeFolder = normalizedTarget
? `${normalizedTarget}/${fileName}`
: fileName;
const oldFullPath = path.join(libraryPath, oldPath);
const newFullPath = path.join(libraryPath, newRelativeFolder);
// 检查源路径是否存在
if (!fs.existsSync(oldFullPath)) {
results.failed.push({ path: oldPath, error: '源文件不存在' });
continue;
}
// 检查目标父级文件夹是否存在
const targetFullPath = normalizedTarget
? path.join(libraryPath, normalizedTarget)
: libraryPath;
if (!fs.existsSync(targetFullPath)) {
fs.mkdirSync(targetFullPath, { recursive: true });
}
// 检查目标是否已存在同名文件/文件夹
if (fs.existsSync(newFullPath)) {
results.failed.push({ path: oldPath, error: '目标位置已存在同名文件' });
continue;
}
if (item.type === 'folder') {
// ===== 文件夹移动逻辑 =====
// 1. 先在磁盘上移动整个文件夹树
fs.renameSync(oldFullPath, newFullPath);
// 2. 更新 folders 表中该文件夹及其所有子文件夹的 path / parent_path
const oldFolderPath = oldPath;
const newFolderPath = newRelativeFolder;
const len = oldFolderPath.length + 1; // 用于 substr 去掉前缀
// 2.1 更新根文件夹记录
const updateRootFolderStmt = db.db.prepare(`
UPDATE folders
SET path = ?, parent_path = ?
WHERE path = ?
`);
updateRootFolderStmt.run(
newFolderPath,
normalizedTarget || null,
oldFolderPath
);
// 2.2 更新子文件夹记录(保持层级结构)
const updateChildFoldersStmt = db.db.prepare(`
UPDATE folders
SET path = ? || substr(path, ?),
parent_path = ? || substr(parent_path, ?)
WHERE path LIKE ?
`);
updateChildFoldersStmt.run(
newFolderPath,
len,
newFolderPath,
len,
`${oldFolderPath}/%`
);
// 3. 更新 images 表中所有属于该文件夹及子文件夹的图片路径和 folder 字段
const updateImagesStmt = db.db.prepare(`
UPDATE images
SET path = ? || substr(path, ?),
folder = ? || substr(folder, ?)
WHERE folder = ? OR folder LIKE ?
`);
updateImagesStmt.run(
newFolderPath,
len,
newFolderPath,
len,
oldFolderPath,
`${oldFolderPath}/%`
);
results.success.push({ oldPath: oldFolderPath, newPath: newFolderPath });
} else {
// ===== 单个文件移动逻辑(保持原有行为) =====
// 移动文件(同分区使用 rename,跨分区自动降级为复制+删除)
fs.renameSync(oldFullPath, newFullPath);
// 更新数据库(单个图片记录)
const newRelativePath = newRelativeFolder.replace(/\\/g, '/');
this._updatePathInDatabase(db, oldPath, newRelativePath);
results.success.push({ oldPath, newPath: newRelativePath });
}
} catch (error) {
console.error(`移动失败 ${item.path}:`, error.message);
results.failed.push({ path: item.path, error: error.message });
}
}
// 更新文件夹计数
if (results.success.length > 0) {
db.updateAllFolderCounts();
}
return results;
}
/**
* 复制文件或文件夹
* @param {string} libraryId - 素材库ID
* @param {Array} items - 待复制项
* @param {string} targetFolder - 目标文件夹(相对路径)
* @param {string} conflictAction - 冲突处理方式: 'skip'|'replace'|'rename'
*/
async copyItems(libraryId, items, targetFolder, conflictAction = 'rename') {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const results = { success: [], failed: [], conflicts: [] };
// 确保目标文件夹存在
const targetFullPath = path.join(libraryPath, targetFolder || '');
if (!fs.existsSync(targetFullPath)) {
fs.mkdirSync(targetFullPath, { recursive: true });
}
for (const item of items) {
try {
const srcFullPath = path.join(libraryPath, item.path);
const fileName = path.basename(item.path);
const dstFullPath = path.join(targetFullPath, fileName);
// 检查源文件是否存在
if (!fs.existsSync(srcFullPath)) {
results.failed.push({ path: item.path, error: '源文件不存在' });
continue;
}
// 处理冲突
let finalDstPath = dstFullPath;
const isDirectory = item.type === 'folder';
// 检查是否与源路径相同(在同一文件夹内复制粘贴)
if (srcFullPath === dstFullPath) {
// 记录冲突
results.conflicts.push({ path: item.path, name: fileName });
if (conflictAction === 'skip') {
// 跳过:源和目标相同,直接跳过
console.log(`⏭️ 跳过(源和目标相同): ${fileName}`);
continue;
} else if (conflictAction === 'replace') {
// 覆盖:源和目标相同,无法覆盖自己,跳过
console.log(`⏭️ 跳过(无法覆盖自己): ${fileName}`);
continue;
} else if (conflictAction === 'rename') {
// 重命名:自动编号创建副本
const ext = isDirectory ? '' : path.extname(fileName);
const basename = isDirectory ? fileName : path.basename(fileName, ext);
let counter = 1;
while (fs.existsSync(finalDstPath)) {
const numberedName = isDirectory
? `${basename} (${counter})`
: `${basename} (${counter})${ext}`;
finalDstPath = path.join(targetFullPath, numberedName);
counter++;
}
console.log(`✏️ 创建副本: ${path.basename(finalDstPath)}`);
}
} else if (fs.existsSync(dstFullPath)) {
// 目标文件存在但与源不同
results.conflicts.push({ path: item.path, name: fileName });
if (conflictAction === 'skip') {
// 跳过冲突文件
console.log(`⏭️ 跳过冲突文件: ${fileName}`);
continue;
} else if (conflictAction === 'replace') {
// 覆盖:先删除目标文件/文件夹
console.log(`🔄 覆盖文件: ${fileName}`);
if (fs.statSync(dstFullPath).isDirectory()) {
fs.rmSync(dstFullPath, { recursive: true, force: true });
} else {
fs.unlinkSync(dstFullPath);
}
} else if (conflictAction === 'rename') {
// 重命名:自动编号
const ext = isDirectory ? '' : path.extname(fileName);
const basename = isDirectory ? fileName : path.basename(fileName, ext);
let counter = 1;
while (fs.existsSync(finalDstPath)) {
const numberedName = isDirectory
? `${basename} (${counter})`
: `${basename} (${counter})${ext}`;
finalDstPath = path.join(targetFullPath, numberedName);
counter++;
}
console.log(`✏️ 重命名为: ${path.basename(finalDstPath)}`);
}
}
// 复制文件或文件夹
if (item.type === 'folder') {
// 复制整个文件夹
fs.cpSync(srcFullPath, finalDstPath, { recursive: true });
// 递归处理文件夹中的所有图片(生成缩略图、入库)
await this._processFolderImages(finalDstPath, libraryPath, db);
} else {
// 复制单个文件
fs.copyFileSync(srcFullPath, finalDstPath);
// 处理新文件(生成缩略图、入库)
await processImage(finalDstPath, libraryPath, db);
}
const newRelativePath = path.relative(libraryPath, finalDstPath).replace(/\\/g, '/');
results.success.push({ oldPath: item.path, newPath: newRelativePath });
console.log(`✅ 复制成功: ${item.path} → ${newRelativePath}`);
} catch (error) {
console.error(`复制失败 ${item.path}:`, error.message);
results.failed.push({ path: item.path, error: error.message });
}
}
// 更新文件夹计数
if (results.success.length > 0) {
db.updateAllFolderCounts();
}
return results;
}
/**
* 递归处理文件夹中的所有图片
* @private
*/
async _processFolderImages(folderPath, libraryPath, db) {
const entries = fs.readdirSync(folderPath, { withFileTypes: true });
for (const entry of entries) {
const fullPath = path.join(folderPath, entry.name);
if (entry.isDirectory()) {
// 跳过 .flypic 目录
if (entry.name === '.flypic') continue;
// 递归处理子文件夹
await this._processFolderImages(fullPath, libraryPath, db);
} else {
// 检查是否是图片文件
const ext = path.extname(entry.name).toLowerCase();
const imageExts = ['.jpg', '.jpeg', '.png', '.webp', '.gif', '.bmp', '.tiff'];
if (imageExts.includes(ext)) {
try {
await processImage(fullPath, libraryPath, db);
} catch (error) {
console.warn(`处理图片失败 ${entry.name}:`, error.message);
}
}
}
}
}
/**
* 更新文件元数据(评分、收藏、标签)
* @param {string} libraryId - 素材库ID
* @param {string} imagePath - 图片路径(相对路径)
* @param {Object} metadata - 元数据 {rating, favorite, tags}
*/
async updateMetadata(libraryId, imagePath, metadata) {
const db = this._getDatabase(libraryId);
const updates = {};
if (metadata.rating !== undefined) updates.rating = metadata.rating;
if (metadata.favorite !== undefined) updates.favorite = metadata.favorite;
if (metadata.tags !== undefined) {
updates.tags = Array.isArray(metadata.tags)
? JSON.stringify(metadata.tags)
: metadata.tags;
}
if (Object.keys(updates).length === 0) {
throw new Error('没有要更新的元数据');
}
// 构建 SQL 更新语句
const fields = Object.keys(updates).map(key => `${key} = ?`).join(', ');
const values = [...Object.values(updates), imagePath];
const stmt = db.db.prepare(`UPDATE images SET ${fields} WHERE path = ?`);
const result = stmt.run(...values);
if (result.changes === 0) {
throw new Error('图片不存在');
}
// 更新数据库修改时间
db.updateLastModified();
return db.getImageByPath(imagePath);
}
/**
* 更新数据库中的路径(仅用于单个文件)
* @private
*/
_updatePathInDatabase(db, oldPath, newPath) {
const image = db.getImageByPath(oldPath);
if (!image) {
return;
}
const newFilename = path.basename(newPath);
const newFolder = path.dirname(newPath);
const stmt = db.db.prepare(`
UPDATE images
SET path = ?, filename = ?, folder = ?
WHERE path = ?
`);
stmt.run(
newPath,
newFilename,
newFolder === '.' ? '' : newFolder.replace(/\\/g, '/'),
oldPath
);
db.updateLastModified();
}
/**
* 更新数据库中的文件夹路径(folders + images)
* @private
*/
_updateFolderPathInDatabase(db, oldFolderPath, newFolderPath) {
const normalizedOld = oldFolderPath.replace(/\\/g, '/');
const normalizedNew = newFolderPath.replace(/\\/g, '/');
const len = normalizedOld.length + 1; // 用于去掉前缀
// 1. 更新根文件夹记录(path / name,parent_path 保持不变)
const rootFolder = db.getFolderByPath(normalizedOld);
const parentPath = rootFolder ? rootFolder.parent_path : path.dirname(normalizedOld);
const updateRootFolderStmt = db.db.prepare(`
UPDATE folders
SET path = ?, parent_path = ?, name = ?
WHERE path = ?
`);
updateRootFolderStmt.run(
normalizedNew,
parentPath || null,
path.basename(normalizedNew),
normalizedOld
);
// 2. 更新子文件夹记录(保持层级结构)
const updateChildFoldersStmt = db.db.prepare(`
UPDATE folders
SET path = ? || substr(path, ?),
parent_path = ? || substr(parent_path, ?)
WHERE path LIKE ?
`);
updateChildFoldersStmt.run(
normalizedNew,
len,
normalizedNew,
len,
`${normalizedOld}/%`
);
// 3. 更新 images 表中所有属于该文件夹及子文件夹的图片路径和 folder 字段
const updateImagesStmt = db.db.prepare(`
UPDATE images
SET path = ? || substr(path, ?),
folder = ? || substr(folder, ?)
WHERE folder = ? OR folder LIKE ?
`);
updateImagesStmt.run(
normalizedNew,
len,
normalizedNew,
len,
normalizedOld,
`${normalizedOld}/%`
);
// 4. 重新计算所有文件夹的图片数量
db.updateAllFolderCounts();
db.updateLastModified();
}
/**
* 创建空文件夹
* @param {string} libraryId - 素材库ID
* @param {string} folderPath - 文件夹路径(相对路径)
*/
async createFolder(libraryId, folderPath) {
const db = this._getDatabase(libraryId);
const libraryPath = db.libraryPath;
const fullPath = path.join(libraryPath, folderPath);
// 检查文件夹是否已存在
if (fs.existsSync(fullPath)) {
throw new Error('文件夹已存在');
}
// 创建文件夹
fs.mkdirSync(fullPath, { recursive: true });
console.log(`📁 创建文件夹: ${folderPath}`);
// 添加到数据库
const normalizedPath = folderPath.replace(/\\/g, '/');
const parentPath = normalizedPath.includes('/')
? normalizedPath.substring(0, normalizedPath.lastIndexOf('/'))
: '';
const name = normalizedPath.split('/').pop();
// 确保父文件夹链存在
if (parentPath) {
let current = parentPath;
while (current && current !== '.') {
const existing = db.getFolderByPath(current);
if (!existing) {
const parent = path.posix.dirname(current);
const folderName = current.split('/').pop();
db.insertFolder({
path: current,
parent_path: parent === '.' ? '' : parent,
name: folderName,
image_count: 0
});
}
const parent = path.posix.dirname(current);
if (parent === current) break;
current = parent;
}
}
// 插入新文件夹
db.insertFolder({
path: normalizedPath,
parent_path: parentPath,
name: name,
image_count: 0
});
return { path: normalizedPath };
}
/**
* 删除缩略图(私有方法)
*/
_deleteThumbnail(db, imagePath) {
const image = db.getImageByPath(imagePath);
if (!image || !image.thumbnail_path) return;
try {
const thumbnailFullPath = path.join(db.libraryPath, image.thumbnail_path);
if (fs.existsSync(thumbnailFullPath)) {
fs.unlinkSync(thumbnailFullPath);
}
} catch (error) {
console.warn(`删除缩略图失败: ${error.message}`);
}
}
}
module.exports = FileService;