819 lines
22 KiB
JavaScript
819 lines
22 KiB
JavaScript
const axios = require('axios');
|
|
const fs = require('fs-extra');
|
|
const path = require('path');
|
|
const { v4: uuidv4 } = require('uuid');
|
|
const ArtworkService = require('./artwork');
|
|
const ArtistService = require('./artist');
|
|
|
|
class DownloadService {
|
|
constructor(auth) {
|
|
this.auth = auth;
|
|
this.artworkService = new ArtworkService(auth);
|
|
this.artistService = new ArtistService(auth);
|
|
this.downloadPath = path.join(__dirname, '../../downloads');
|
|
this.dataPath = path.join(__dirname, '../../data');
|
|
this.tasksFile = path.join(this.dataPath, 'download_tasks.json');
|
|
this.historyFile = path.join(this.dataPath, 'download_history.json');
|
|
|
|
this.tasks = new Map(); // 内存中的任务状态
|
|
this.history = []; // 下载历史
|
|
this.initialized = false;
|
|
}
|
|
|
|
/**
|
|
* 初始化服务
|
|
*/
|
|
async init() {
|
|
try {
|
|
// 确保目录存在
|
|
await fs.ensureDir(this.downloadPath);
|
|
await fs.ensureDir(this.dataPath);
|
|
|
|
// 加载历史记录
|
|
await this.loadHistory();
|
|
|
|
// 加载任务状态
|
|
await this.loadTasks();
|
|
|
|
this.initialized = true;
|
|
console.log('下载服务初始化完成');
|
|
} catch (error) {
|
|
console.error('下载服务初始化失败:', error);
|
|
this.initialized = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 加载下载历史
|
|
*/
|
|
async loadHistory() {
|
|
try {
|
|
if (await fs.pathExists(this.historyFile)) {
|
|
this.history = await fs.readJson(this.historyFile);
|
|
}
|
|
} catch (error) {
|
|
console.error('加载下载历史失败:', error);
|
|
this.history = [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 保存下载历史
|
|
*/
|
|
async saveHistory() {
|
|
try {
|
|
await fs.writeJson(this.historyFile, this.history, { spaces: 2 });
|
|
} catch (error) {
|
|
console.error('保存下载历史失败:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 加载任务状态
|
|
*/
|
|
async loadTasks() {
|
|
try {
|
|
if (await fs.pathExists(this.tasksFile)) {
|
|
const tasksData = await fs.readJson(this.tasksFile);
|
|
// 只加载未完成的任务
|
|
for (const [taskId, task] of Object.entries(tasksData)) {
|
|
if (task.status === 'downloading' || task.status === 'pending') {
|
|
this.tasks.set(taskId, task);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error('加载任务状态失败:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 保存任务状态
|
|
*/
|
|
async saveTasks() {
|
|
try {
|
|
const tasksData = {};
|
|
for (const [taskId, task] of this.tasks.entries()) {
|
|
tasksData[taskId] = task;
|
|
}
|
|
await fs.writeJson(this.tasksFile, tasksData, { spaces: 2 });
|
|
} catch (error) {
|
|
console.error('保存任务状态失败:', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取任务进度
|
|
*/
|
|
getTaskProgress(taskId) {
|
|
const task = this.tasks.get(taskId);
|
|
if (!task) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
id: task.id,
|
|
type: task.type,
|
|
status: task.status,
|
|
progress: task.progress,
|
|
total: task.total,
|
|
completed: task.completed,
|
|
failed: task.failed,
|
|
start_time: task.start_time,
|
|
end_time: task.end_time,
|
|
files: task.files || [],
|
|
error: task.error
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 获取所有任务
|
|
*/
|
|
getAllTasks() {
|
|
const tasks = [];
|
|
for (const [taskId, task] of this.tasks.entries()) {
|
|
tasks.push(this.getTaskProgress(taskId));
|
|
}
|
|
return tasks;
|
|
}
|
|
|
|
/**
|
|
* 获取下载历史
|
|
*/
|
|
getDownloadHistory(limit = 50, offset = 0) {
|
|
return this.history
|
|
.sort((a, b) => new Date(b.end_time) - new Date(a.end_time))
|
|
.slice(offset, offset + limit);
|
|
}
|
|
|
|
/**
|
|
* 获取下载的文件列表
|
|
*/
|
|
async getDownloadedFiles() {
|
|
try {
|
|
const files = [];
|
|
const artists = await fs.readdir(this.downloadPath);
|
|
|
|
for (const artist of artists) {
|
|
const artistPath = path.join(this.downloadPath, artist);
|
|
const artistStat = await fs.stat(artistPath);
|
|
|
|
if (artistStat.isDirectory()) {
|
|
const artworks = await fs.readdir(artistPath);
|
|
|
|
for (const artwork of artworks) {
|
|
const artworkPath = path.join(artistPath, artwork);
|
|
const artworkStat = await fs.stat(artworkPath);
|
|
|
|
if (artworkStat.isDirectory()) {
|
|
const artworkFiles = await fs.readdir(artworkPath);
|
|
const imageFiles = artworkFiles.filter(file =>
|
|
/\.(jpg|jpeg|png|gif|webp)$/i.test(file)
|
|
);
|
|
|
|
if (imageFiles.length > 0) {
|
|
files.push({
|
|
artist: artist,
|
|
artwork: artwork,
|
|
path: artworkPath,
|
|
files: imageFiles,
|
|
total_size: await this.getDirectorySize(artworkPath),
|
|
created_at: artworkStat.birthtime
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return files.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
|
|
} catch (error) {
|
|
console.error('获取下载文件列表失败:', error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 检查作品是否已下载
|
|
*/
|
|
async isArtworkDownloaded(artworkId) {
|
|
try {
|
|
// 从历史记录中查找
|
|
const historyItem = this.history.find(item =>
|
|
item.artwork_id === artworkId && item.status === 'completed'
|
|
);
|
|
|
|
if (historyItem) {
|
|
// 检查文件是否还存在
|
|
const exists = await fs.pathExists(historyItem.download_path);
|
|
if (exists) {
|
|
const files = await fs.readdir(historyItem.download_path);
|
|
const imageFiles = files.filter(file =>
|
|
/\.(jpg|jpeg|png|gif|webp)$/i.test(file)
|
|
);
|
|
return imageFiles.length > 0;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
} catch (error) {
|
|
console.error('检查作品下载状态失败:', error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取已下载的作品ID列表
|
|
*/
|
|
async getDownloadedArtworkIds() {
|
|
try {
|
|
const downloadedIds = new Set();
|
|
|
|
// 从历史记录中获取
|
|
for (const item of this.history) {
|
|
if (item.artwork_id && item.status === 'completed') {
|
|
const exists = await fs.pathExists(item.download_path);
|
|
if (exists) {
|
|
const files = await fs.readdir(item.download_path);
|
|
const imageFiles = files.filter(file =>
|
|
/\.(jpg|jpeg|png|gif|webp)$/i.test(file)
|
|
);
|
|
if (imageFiles.length > 0) {
|
|
downloadedIds.add(item.artwork_id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Array.from(downloadedIds);
|
|
} catch (error) {
|
|
console.error('获取已下载作品ID列表失败:', error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取目录大小
|
|
*/
|
|
async getDirectorySize(dirPath) {
|
|
try {
|
|
const files = await fs.readdir(dirPath);
|
|
let totalSize = 0;
|
|
|
|
for (const file of files) {
|
|
const filePath = path.join(dirPath, file);
|
|
const stat = await fs.stat(filePath);
|
|
if (stat.isFile()) {
|
|
totalSize += stat.size;
|
|
}
|
|
}
|
|
|
|
return totalSize;
|
|
} catch (error) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除下载的文件
|
|
*/
|
|
async deleteDownloadedFiles(artist, artwork) {
|
|
try {
|
|
const targetPath = path.join(this.downloadPath, artist, artwork);
|
|
if (await fs.pathExists(targetPath)) {
|
|
await fs.remove(targetPath);
|
|
|
|
// 从历史记录中移除
|
|
this.history = this.history.filter(item =>
|
|
!(item.artist_name === artist && item.artwork_title === artwork)
|
|
);
|
|
await this.saveHistory();
|
|
|
|
return { success: true };
|
|
}
|
|
return { success: false, error: '文件不存在' };
|
|
} catch (error) {
|
|
return { success: false, error: error.message };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 取消下载任务
|
|
*/
|
|
async cancelTask(taskId) {
|
|
const task = this.tasks.get(taskId);
|
|
if (!task) {
|
|
return { success: false, error: '任务不存在' };
|
|
}
|
|
|
|
if (task.status === 'completed' || task.status === 'failed') {
|
|
return { success: false, error: '任务已完成，无法取消' };
|
|
}
|
|
|
|
task.status = 'cancelled';
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
|
|
return { success: true };
|
|
}
|
|
|
|
/**
|
|
* 下载单个作品
|
|
*/
|
|
async downloadArtwork(artworkId, options = {}) {
|
|
const taskId = uuidv4();
|
|
const { size = 'original', quality = 'high', format = 'auto', skipExisting = true } = options;
|
|
|
|
try {
|
|
// 检查是否已下载
|
|
if (skipExisting && await this.isArtworkDownloaded(artworkId)) {
|
|
console.log(`作品 ${artworkId} 已存在，跳过下载`);
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
artwork_id: artworkId,
|
|
skipped: true,
|
|
message: '作品已存在，跳过下载'
|
|
}
|
|
};
|
|
}
|
|
|
|
// 创建任务记录
|
|
const task = {
|
|
id: taskId,
|
|
type: 'artwork',
|
|
artwork_id: artworkId,
|
|
status: 'downloading',
|
|
progress: 0,
|
|
total: 1,
|
|
completed: 0,
|
|
failed: 0,
|
|
files: [],
|
|
start_time: new Date(),
|
|
end_time: null,
|
|
error: null
|
|
};
|
|
|
|
this.tasks.set(taskId, task);
|
|
await this.saveTasks();
|
|
|
|
// 获取作品信息
|
|
const artworkResult = await this.artworkService.getArtworkDetail(artworkId);
|
|
if (!artworkResult.success) {
|
|
throw new Error(`获取作品信息失败: ${artworkResult.error}`);
|
|
}
|
|
|
|
const artwork = artworkResult.data;
|
|
|
|
// 确保作品信息完整
|
|
if (!artwork || !artwork.user || !artwork.title) {
|
|
throw new Error('作品信息不完整');
|
|
}
|
|
|
|
const artistName = (artwork.user.name || 'Unknown Artist').replace(/[<>:"/\\|?*]/g, '_');
|
|
const artworkTitle = (artwork.title || 'Untitled').replace(/[<>:"/\\|?*]/g, '_');
|
|
|
|
// 创建作品目录 - 使用仓库管理格式
|
|
const artistDir = path.join(this.downloadPath, artistName);
|
|
const artworkDirName = `${artworkId}_${artworkTitle}`;
|
|
const artworkDir = path.join(artistDir, artworkDirName);
|
|
await fs.ensureDir(artworkDir);
|
|
|
|
// 获取图片URL
|
|
const imagesResult = await this.artworkService.getArtworkImages(artworkId, size);
|
|
if (!imagesResult.success) {
|
|
throw new Error(`获取图片URL失败: ${imagesResult.error}`);
|
|
}
|
|
|
|
const images = imagesResult.data.images;
|
|
task.total = images.length;
|
|
|
|
// 下载所有图片
|
|
const downloadPromises = images.map(async (image, index) => {
|
|
if (task.status === 'cancelled') {
|
|
return { success: false, error: '任务已取消' };
|
|
}
|
|
|
|
try {
|
|
const imageUrl = image[size] || image.original;
|
|
const fileExt = this.getFileExtension(imageUrl);
|
|
const fileName = `${artworkTitle}_${artworkId}_${index + 1}${fileExt}`;
|
|
const filePath = path.join(artworkDir, fileName);
|
|
|
|
await this.downloadFile(imageUrl, filePath);
|
|
|
|
task.completed++;
|
|
task.progress = Math.round((task.completed / task.total) * 100);
|
|
task.files.push({
|
|
path: filePath,
|
|
url: imageUrl,
|
|
size: size,
|
|
filename: fileName
|
|
});
|
|
|
|
await this.saveTasks();
|
|
return { success: true, file: fileName };
|
|
} catch (error) {
|
|
task.failed++;
|
|
console.error(`下载图片失败 ${index + 1}:`, error.message);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
|
|
await Promise.all(downloadPromises);
|
|
|
|
// 保存作品信息
|
|
const infoPath = path.join(artworkDir, 'artwork_info.json');
|
|
await fs.writeJson(infoPath, artwork, { spaces: 2 });
|
|
|
|
// 更新任务状态
|
|
task.status = task.failed === 0 ? 'completed' : 'partial';
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
|
|
// 添加到历史记录
|
|
const historyItem = {
|
|
id: taskId,
|
|
type: 'artwork',
|
|
artwork_id: artworkId,
|
|
artist_name: artistName,
|
|
artwork_title: artworkTitle,
|
|
download_path: artworkDir,
|
|
total_files: task.total,
|
|
completed_files: task.completed,
|
|
failed_files: task.failed,
|
|
files: task.files,
|
|
start_time: task.start_time,
|
|
end_time: task.end_time,
|
|
status: task.status
|
|
};
|
|
|
|
this.history.unshift(historyItem);
|
|
await this.saveHistory();
|
|
|
|
console.log('下载完成，历史记录已保存:', {
|
|
taskId,
|
|
historyLength: this.history.length,
|
|
tasksCount: this.tasks.size
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
artwork_id: artworkId,
|
|
artist_name: artistName,
|
|
artwork_title: artworkTitle,
|
|
download_path: artworkDir,
|
|
total_files: task.total,
|
|
completed_files: task.completed,
|
|
failed_files: task.failed,
|
|
files: task.files
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
const task = this.tasks.get(taskId);
|
|
if (task) {
|
|
task.status = 'failed';
|
|
task.error = error.message;
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
}
|
|
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 下载文件
|
|
*/
|
|
async downloadFile(url, filePath) {
|
|
const response = await axios({
|
|
method: 'GET',
|
|
url: url,
|
|
responseType: 'stream',
|
|
headers: {
|
|
'Referer': 'https://www.pixiv.net/',
|
|
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
|
|
},
|
|
timeout: 30000
|
|
});
|
|
|
|
const writer = fs.createWriteStream(filePath);
|
|
response.data.pipe(writer);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
writer.on('finish', resolve);
|
|
writer.on('error', reject);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 获取文件扩展名
|
|
*/
|
|
getFileExtension(url) {
|
|
const match = url.match(/\.([a-zA-Z0-9]+)(\?|$)/);
|
|
return match ? `.${match[1]}` : '.jpg';
|
|
}
|
|
|
|
/**
|
|
* 批量下载作品
|
|
*/
|
|
async downloadMultipleArtworks(artworkIds, options = {}) {
|
|
const taskId = uuidv4();
|
|
const { concurrent = 3, size = 'original', quality = 'high', format = 'auto', skipExisting = true } = options;
|
|
|
|
try {
|
|
// 检查重复下载
|
|
let filteredIds = artworkIds;
|
|
let skippedCount = 0;
|
|
|
|
if (skipExisting) {
|
|
const downloadedIds = await this.getDownloadedArtworkIds();
|
|
const downloadedSet = new Set(downloadedIds);
|
|
|
|
filteredIds = artworkIds.filter(id => !downloadedSet.has(id));
|
|
skippedCount = artworkIds.length - filteredIds.length;
|
|
|
|
console.log(`批量下载: 总共 ${artworkIds.length} 个作品，跳过 ${skippedCount} 个已下载的作品，需要下载 ${filteredIds.length} 个作品`);
|
|
}
|
|
|
|
// 创建任务记录
|
|
const task = {
|
|
id: taskId,
|
|
type: 'batch',
|
|
artwork_ids: artworkIds,
|
|
filtered_ids: filteredIds,
|
|
status: 'downloading',
|
|
progress: 0,
|
|
total: filteredIds.length,
|
|
completed: 0,
|
|
failed: 0,
|
|
skipped: skippedCount,
|
|
results: [],
|
|
start_time: new Date(),
|
|
end_time: null,
|
|
error: null
|
|
};
|
|
|
|
this.tasks.set(taskId, task);
|
|
await this.saveTasks();
|
|
|
|
const results = [];
|
|
|
|
// 如果没有需要下载的作品，直接返回
|
|
if (filteredIds.length === 0) {
|
|
task.status = 'completed';
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
total_artworks: artworkIds.length,
|
|
completed_artworks: 0,
|
|
failed_artworks: 0,
|
|
skipped_artworks: skippedCount,
|
|
message: '所有作品都已下载完成'
|
|
}
|
|
};
|
|
}
|
|
|
|
// 分批下载
|
|
for (let i = 0; i < filteredIds.length; i += concurrent) {
|
|
if (task.status === 'cancelled') {
|
|
break;
|
|
}
|
|
|
|
const batch = filteredIds.slice(i, i + concurrent);
|
|
const batchPromises = batch.map(async (artworkId) => {
|
|
try {
|
|
const result = await this.downloadArtwork(artworkId, { size, quality, format, skipExisting: false });
|
|
task.completed++;
|
|
results.push({ artwork_id: artworkId, ...result });
|
|
return result;
|
|
} catch (error) {
|
|
task.failed++;
|
|
results.push({ artwork_id: artworkId, success: false, error: error.message });
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
|
|
await Promise.all(batchPromises);
|
|
task.progress = Math.round((task.completed / task.total) * 100);
|
|
await this.saveTasks();
|
|
|
|
// 添加延迟避免请求过于频繁
|
|
if (i + concurrent < filteredIds.length) {
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
}
|
|
}
|
|
|
|
// 更新任务状态
|
|
task.status = task.failed === 0 ? 'completed' : 'partial';
|
|
task.end_time = new Date();
|
|
task.results = results;
|
|
await this.saveTasks();
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
total_artworks: task.total,
|
|
completed_artworks: task.completed,
|
|
failed_artworks: task.failed,
|
|
results: results
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
const task = this.tasks.get(taskId);
|
|
if (task) {
|
|
task.status = 'failed';
|
|
task.error = error.message;
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
}
|
|
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 下载作者作品
|
|
*/
|
|
async downloadArtistArtworks(artistId, options = {}) {
|
|
const taskId = uuidv4();
|
|
const {
|
|
type = 'art',
|
|
limit = 50,
|
|
size = 'original',
|
|
quality = 'high',
|
|
format = 'auto',
|
|
skipExisting = true,
|
|
maxConcurrent = 3,
|
|
pageSize = 30
|
|
} = options;
|
|
|
|
try {
|
|
// 创建任务记录
|
|
const task = {
|
|
id: taskId,
|
|
type: 'artist',
|
|
artist_id: artistId,
|
|
status: 'downloading',
|
|
progress: 0,
|
|
total: 0,
|
|
completed: 0,
|
|
failed: 0,
|
|
skipped: 0,
|
|
results: [],
|
|
start_time: new Date(),
|
|
end_time: null,
|
|
error: null
|
|
};
|
|
|
|
this.tasks.set(taskId, task);
|
|
await this.saveTasks();
|
|
|
|
// 获取已下载的作品ID
|
|
const downloadedIds = skipExisting ? await this.getDownloadedArtworkIds() : [];
|
|
const downloadedSet = new Set(downloadedIds);
|
|
|
|
// 分页获取作者作品列表
|
|
let allArtworks = [];
|
|
let offset = 0;
|
|
let hasMore = true;
|
|
|
|
while (hasMore && allArtworks.length < limit) {
|
|
const artworksResult = await this.artistService.getArtistArtworks(artistId, {
|
|
type,
|
|
offset: offset,
|
|
limit: Math.min(pageSize, limit - allArtworks.length)
|
|
});
|
|
|
|
if (!artworksResult.success) {
|
|
throw new Error(`获取作者作品失败: ${artworksResult.error}`);
|
|
}
|
|
|
|
const artworks = artworksResult.data.artworks;
|
|
if (artworks.length === 0) {
|
|
hasMore = false;
|
|
} else {
|
|
allArtworks.push(...artworks);
|
|
offset += artworks.length;
|
|
|
|
// 添加延迟避免请求过于频繁
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
}
|
|
}
|
|
|
|
// 过滤已下载的作品
|
|
const newArtworks = skipExisting
|
|
? allArtworks.filter(artwork => !downloadedSet.has(artwork.id))
|
|
: allArtworks;
|
|
|
|
const skippedCount = allArtworks.length - newArtworks.length;
|
|
task.skipped = skippedCount;
|
|
task.total = newArtworks.length;
|
|
await this.saveTasks();
|
|
|
|
console.log(`作者作品下载: 总共 ${allArtworks.length} 个作品，跳过 ${skippedCount} 个已下载的作品，需要下载 ${newArtworks.length} 个作品`);
|
|
|
|
// 如果没有需要下载的作品，直接返回
|
|
if (newArtworks.length === 0) {
|
|
task.status = 'completed';
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
artist_id: artistId,
|
|
total_artworks: allArtworks.length,
|
|
completed_artworks: 0,
|
|
failed_artworks: 0,
|
|
skipped_artworks: skippedCount,
|
|
message: '所有作品都已下载完成'
|
|
}
|
|
};
|
|
}
|
|
|
|
const results = [];
|
|
|
|
// 分批下载作品
|
|
for (let i = 0; i < newArtworks.length; i += maxConcurrent) {
|
|
if (task.status === 'cancelled') {
|
|
break;
|
|
}
|
|
|
|
const batch = newArtworks.slice(i, i + maxConcurrent);
|
|
const batchPromises = batch.map(async (artwork) => {
|
|
try {
|
|
const result = await this.downloadArtwork(artwork.id, { size, quality, format, skipExisting: false });
|
|
task.completed++;
|
|
results.push({ artwork_id: artwork.id, ...result });
|
|
return result;
|
|
} catch (error) {
|
|
task.failed++;
|
|
results.push({ artwork_id: artwork.id, success: false, error: error.message });
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
|
|
await Promise.all(batchPromises);
|
|
task.progress = Math.round((task.completed / task.total) * 100);
|
|
await this.saveTasks();
|
|
|
|
// 添加延迟避免请求过于频繁
|
|
if (i + maxConcurrent < newArtworks.length) {
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
}
|
|
}
|
|
|
|
// 更新任务状态
|
|
task.status = task.failed === 0 ? 'completed' : 'partial';
|
|
task.end_time = new Date();
|
|
task.results = results;
|
|
await this.saveTasks();
|
|
|
|
return {
|
|
success: true,
|
|
data: {
|
|
task_id: taskId,
|
|
artist_id: artistId,
|
|
total_artworks: task.total,
|
|
completed_artworks: task.completed,
|
|
failed_artworks: task.failed,
|
|
results: results
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
const task = this.tasks.get(taskId);
|
|
if (task) {
|
|
task.status = 'failed';
|
|
task.error = error.message;
|
|
task.end_time = new Date();
|
|
await this.saveTasks();
|
|
}
|
|
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = DownloadService;
|