1376 lines
53 KiB
TypeScript
1376 lines
53 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server';
|
||
import { getServerSession } from 'next-auth';
|
||
import { authOptions } from '@/lib/auth';
|
||
import { prisma } from '@/lib/prisma';
|
||
import { access, stat } from 'fs/promises';
|
||
import { createReadStream } from 'fs';
|
||
import { Readable } from 'stream';
|
||
import path from 'path';
|
||
import { lookup, extension } from 'mime-types';
|
||
import JSZip from 'jszip';
|
||
import {
|
||
canUserDownloadMaterial,
|
||
isShareLinkAccess,
|
||
canUserDownloadSource,
|
||
} from '@/lib/department-permission';
|
||
import {
|
||
DownloadErrorCode,
|
||
createDownloadError,
|
||
DownloadErrorResponse,
|
||
} from '@/lib/download-errors';
|
||
|
||
function isHttpUrl(url?: string | null): boolean {
|
||
if (!url || typeof url !== 'string') return false;
|
||
return /^https?:\/\//i.test(url.trim());
|
||
}
|
||
|
||
import { isProductPackageType } from '@/lib/material-type-mapper';
|
||
|
||
// 处理产品全案分类下载
|
||
async function handleProductPackageDownload(material: any, downloadType: string) {
|
||
// 确保所有资产数据中的 BigInt 都被转换为字符串，避免序列化错误
|
||
const assets = (material.assets || []).map((asset: any) => ({
|
||
...asset,
|
||
fileSize: asset.fileSize ? (typeof asset.fileSize === 'bigint' ? asset.fileSize.toString() : asset.fileSize) : '0',
|
||
}));
|
||
|
||
// 添加详细日志
|
||
console.log(`[Download] handleProductPackageDownload: materialId=${material.id}, downloadType=${downloadType}, total assets=${assets.length}`);
|
||
console.log(`[Download] Assets breakdown:`, {
|
||
main: assets.filter((a: any) => a.assetType === 'main').length,
|
||
sku: assets.filter((a: any) => a.assetType === 'sku').length,
|
||
detail: assets.filter((a: any) => a.assetType === 'detail').length,
|
||
psd: assets.filter((a: any) => a.assetType === 'psd').length,
|
||
});
|
||
|
||
// 根据类型筛选资产
|
||
let targetAssets: any[] = [];
|
||
let zipName = '';
|
||
|
||
console.log(`[Download] ========== 开始筛选资产 ==========`);
|
||
console.log(`[Download] Requested downloadType: ${downloadType}`);
|
||
console.log(`[Download] Total assets available: ${assets.length}`);
|
||
|
||
switch (downloadType) {
|
||
case 'all':
|
||
// 全部下载（不含 PSD）
|
||
targetAssets = assets.filter((a: any) => {
|
||
const isNotPsd = a.assetType !== 'psd';
|
||
if (!isNotPsd) {
|
||
console.log(`[Download] Filtering out PSD asset: id=${a.id}, type=${a.assetType}`);
|
||
}
|
||
return isNotPsd;
|
||
});
|
||
zipName = '全部';
|
||
break;
|
||
case 'main':
|
||
targetAssets = assets.filter((a: any) => {
|
||
const isMain = a.assetType === 'main';
|
||
if (!isMain) {
|
||
console.log(`[Download] Filtering out non-main asset: id=${a.id}, type=${a.assetType}, expected=main`);
|
||
}
|
||
return isMain;
|
||
});
|
||
zipName = '主图';
|
||
break;
|
||
case 'sku':
|
||
targetAssets = assets.filter((a: any) => {
|
||
const isSku = a.assetType === 'sku';
|
||
if (!isSku) {
|
||
console.log(`[Download] Filtering out non-sku asset: id=${a.id}, type=${a.assetType}, expected=sku`);
|
||
}
|
||
return isSku;
|
||
});
|
||
zipName = 'SKU图';
|
||
break;
|
||
case 'detail':
|
||
targetAssets = assets.filter((a: any) => {
|
||
const isDetail = a.assetType === 'detail';
|
||
if (!isDetail) {
|
||
console.log(`[Download] Filtering out non-detail asset: id=${a.id}, type=${a.assetType}, expected=detail`);
|
||
}
|
||
return isDetail;
|
||
});
|
||
zipName = '详情图';
|
||
break;
|
||
case 'psd':
|
||
targetAssets = assets.filter((a: any) => {
|
||
const isPsd = a.assetType === 'psd';
|
||
if (!isPsd) {
|
||
console.log(`[Download] Filtering out non-psd asset: id=${a.id}, type=${a.assetType}, expected=psd`);
|
||
}
|
||
return isPsd;
|
||
});
|
||
zipName = 'PSD源文件';
|
||
break;
|
||
default:
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.INVALID_DOWNLOAD_TYPE),
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
|
||
console.log(`[Download] Filtered assets for ${downloadType}: count=${targetAssets.length}`);
|
||
console.log(`[Download] Selected assets (完整信息):`);
|
||
targetAssets.forEach((asset: any, index: number) => {
|
||
console.log(` [${index}] {
|
||
id: "${asset.id}",
|
||
assetType: "${asset.assetType}",
|
||
fileUrl: "${asset.fileUrl}",
|
||
fileName: "${asset.fileName}",
|
||
fileSize: "${asset.fileSize}"
|
||
}`);
|
||
});
|
||
|
||
// 验证：检查所有资产的fileUrl是否都相同（这可能是问题的根源）
|
||
if (targetAssets.length > 1) {
|
||
const firstUrl = targetAssets[0]?.fileUrl;
|
||
const allSameUrl = targetAssets.every((a: any) => a.fileUrl === firstUrl);
|
||
if (allSameUrl) {
|
||
console.error(`[Download] ⚠️ CRITICAL ERROR: All ${targetAssets.length} assets have the same fileUrl: ${firstUrl}`);
|
||
console.error(`[Download] This means all files are pointing to the same URL, which is likely the root cause of the download issue!`);
|
||
console.error(`[Download] Asset details:`);
|
||
targetAssets.forEach((asset: any, index: number) => {
|
||
console.error(` [${index}] id=${asset.id}, type=${asset.assetType}, url=${asset.fileUrl}, fileName=${asset.fileName}`);
|
||
});
|
||
} else {
|
||
console.log(`[Download] ✅ Assets have different fileUrls (this is correct)`);
|
||
// 打印每个资产的URL，用于验证
|
||
targetAssets.forEach((asset: any, index: number) => {
|
||
console.log(` Asset ${index} URL: ${asset.fileUrl}`);
|
||
});
|
||
}
|
||
}
|
||
|
||
// 验证：检查资产类型是否与请求的类型匹配
|
||
const mismatchedAssets = targetAssets.filter((a: any) => a.assetType !== downloadType);
|
||
if (mismatchedAssets.length > 0) {
|
||
console.error(`[Download] ⚠️ CRITICAL ERROR: Found ${mismatchedAssets.length} assets with mismatched types!`);
|
||
console.error(`[Download] Requested type: ${downloadType}`);
|
||
mismatchedAssets.forEach((asset: any) => {
|
||
console.error(` Asset id=${asset.id}, expected type=${downloadType}, actual type=${asset.assetType}, url=${asset.fileUrl}`);
|
||
});
|
||
} else {
|
||
console.log(`[Download] ✅ All ${targetAssets.length} assets have correct type: ${downloadType}`);
|
||
}
|
||
|
||
console.log(`[Download] ====================================`);
|
||
|
||
if (targetAssets.length === 0) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_DOWNLOADABLE_FILES),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
// 单个文件直接下载
|
||
if (targetAssets.length === 1 && downloadType === 'psd') {
|
||
const asset = targetAssets[0];
|
||
const filePath = asset.fileUrl;
|
||
|
||
// PSD 存储在本地
|
||
if (!path.isAbsolute(filePath)) {
|
||
const absolutePath = path.join(process.cwd(), filePath);
|
||
|
||
try {
|
||
await access(absolutePath);
|
||
const fileStats = await stat(absolutePath);
|
||
const fileStream = createReadStream(absolutePath);
|
||
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
fileStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
fileStream.on('end', () => controller.close());
|
||
fileStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
fileStream.destroy();
|
||
},
|
||
});
|
||
|
||
const ext = path.extname(asset.fileName || filePath);
|
||
const mimeType = lookup(ext) || 'application/octet-stream';
|
||
|
||
return new NextResponse(stream, {
|
||
headers: {
|
||
'Content-Type': mimeType,
|
||
'Content-Length': fileStats.size.toString(),
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(asset.fileName || 'source.psd')}"`,
|
||
// 静态PSD文件：长期缓存（1天），允许重新验证
|
||
'Cache-Control': 'public, max-age=86400, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
// 添加ETag支持
|
||
'ETag': `"${Buffer.from(`${absolutePath}-${fileStats.size}`).toString('base64').slice(0, 27)}"`,
|
||
},
|
||
});
|
||
} catch (error) {
|
||
console.error('[Download] PSD file not found:', absolutePath, error);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.PSD_NOT_FOUND),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 多个文件打包下载
|
||
const zip = new JSZip();
|
||
let addedCount = 0;
|
||
|
||
console.log(`[Download] Starting download for type: ${downloadType}, total assets: ${targetAssets.length}`);
|
||
|
||
// 按类型分组资产，如果是全部下载，需要分组到不同文件夹
|
||
const shouldGroupByType = downloadType === 'all';
|
||
const assetsByType: { [key: string]: any[] } = {};
|
||
|
||
if (shouldGroupByType) {
|
||
targetAssets.forEach((asset: any) => {
|
||
// 确保使用资产的实际类型，而不是从变量名推断
|
||
const type = asset.assetType || 'other';
|
||
if (!assetsByType[type]) {
|
||
assetsByType[type] = [];
|
||
}
|
||
// 验证资产类型是否匹配
|
||
if (asset.assetType && asset.assetType !== type) {
|
||
console.error(`[Download] CRITICAL: Asset type mismatch! asset.assetType=${asset.assetType}, inferred type=${type}, assetId=${asset.id}`);
|
||
}
|
||
assetsByType[type].push(asset);
|
||
});
|
||
|
||
console.log(`[Download] Grouped assets by type:`, Object.keys(assetsByType).map(type => `${type}: ${assetsByType[type].length}`).join(', '));
|
||
// 打印每个分组的详细信息
|
||
for (const [type, assets] of Object.entries(assetsByType)) {
|
||
console.log(`[Download] Type ${type} assets:`, assets.map((a: any) => ({ id: a.id, url: a.fileUrl, fileName: a.fileName })));
|
||
}
|
||
} else {
|
||
assetsByType['all'] = targetAssets;
|
||
}
|
||
|
||
// 类型文件夹名称映射
|
||
const typeFolderMap: { [key: string]: string } = {
|
||
main: '主图',
|
||
sku: 'SKU图',
|
||
detail: '详情图',
|
||
psd: 'PSD源文件',
|
||
};
|
||
|
||
// 用于跟踪已使用的文件名（完整路径），避免重名覆盖
|
||
const usedFileNames = new Set<string>();
|
||
|
||
// 遍历所有资产
|
||
const processAssets = async (assets: any[], folderPath: string = '') => {
|
||
for (let index = 0; index < assets.length; index++) {
|
||
const asset = assets[index];
|
||
try {
|
||
// 确保使用资产的原始数据，不要被任何变量覆盖
|
||
const fileUrl = asset.fileUrl;
|
||
const assetType = asset.assetType;
|
||
const assetId = asset.id;
|
||
const fileName = asset.fileName;
|
||
|
||
// 验证关键字段
|
||
if (!fileUrl) {
|
||
console.error(`[Download] CRITICAL: Asset has no fileUrl! assetId=${assetId}, type=${assetType}`);
|
||
continue;
|
||
}
|
||
if (!assetType) {
|
||
console.error(`[Download] CRITICAL: Asset has no assetType! assetId=${assetId}, url=${fileUrl}`);
|
||
continue;
|
||
}
|
||
|
||
// 生成唯一文件名（避免重名覆盖）
|
||
// 需要检查完整路径（包含文件夹）是否已使用
|
||
const baseFileName = fileName || `${assetType}-${index}.jpg`;
|
||
const ext = path.extname(baseFileName) || '.jpg';
|
||
const nameWithoutExt = path.basename(baseFileName, ext);
|
||
|
||
// 生成唯一文件名（考虑文件夹路径）
|
||
let uniqueFileName = baseFileName;
|
||
let suffix = 1;
|
||
let fullZipPath = folderPath ? `${folderPath}/${uniqueFileName}` : uniqueFileName;
|
||
|
||
while (usedFileNames.has(fullZipPath)) {
|
||
uniqueFileName = `${nameWithoutExt}_${suffix}${ext}`;
|
||
fullZipPath = folderPath ? `${folderPath}/${uniqueFileName}` : uniqueFileName;
|
||
suffix++;
|
||
}
|
||
|
||
// 标记为已使用
|
||
usedFileNames.add(fullZipPath);
|
||
|
||
// 添加详细日志
|
||
console.log(`[Download] ========== Processing asset ==========`);
|
||
console.log(`[Download] Asset ID: ${assetId}`);
|
||
console.log(`[Download] Asset Type: ${assetType}`);
|
||
console.log(`[Download] File URL: ${fileUrl}`);
|
||
console.log(`[Download] Original File Name: ${fileName}`);
|
||
console.log(`[Download] Unique File Name: ${uniqueFileName}`);
|
||
console.log(`[Download] Folder Path: ${folderPath || '(root)'}`);
|
||
|
||
// 判断是 S3 URL 还是本地路径
|
||
if (isHttpUrl(fileUrl)) {
|
||
// S3 文件
|
||
console.log(`[Download] Detected S3 URL, fetching file...`);
|
||
console.log(`[Download] Fetch URL: ${fileUrl}`);
|
||
const response = await fetch(fileUrl);
|
||
if (!response.ok) {
|
||
console.error(`[Download] ❌ Failed to fetch asset: ${fileUrl}, status: ${response.status}, assetType=${assetType}, assetId=${assetId}`);
|
||
continue;
|
||
}
|
||
const arrayBuffer = await response.arrayBuffer();
|
||
const buffer = Buffer.from(arrayBuffer);
|
||
|
||
// 验证文件大小
|
||
if (buffer.length === 0) {
|
||
console.error(`[Download] ❌ Empty buffer for asset: ${fileUrl}, assetType=${assetType}, assetId=${assetId}`);
|
||
continue;
|
||
}
|
||
|
||
// 计算文件哈希（前16字节的十六进制），用于验证文件是否相同
|
||
const fileHash = buffer.slice(0, Math.min(16, buffer.length)).toString('hex');
|
||
const fileHashEnd = buffer.slice(Math.max(0, buffer.length - 16)).toString('hex');
|
||
console.log(`[Download] File hash (first 16 bytes): ${fileHash}`);
|
||
console.log(`[Download] File hash (last 16 bytes): ${fileHashEnd}`);
|
||
|
||
// 使用唯一文件名（fullZipPath 已经在上面计算好了）
|
||
const zipPath = fullZipPath;
|
||
|
||
console.log(`[Download] Adding to ZIP:`);
|
||
console.log(` - ZIP Path: ${zipPath}`);
|
||
console.log(` - File Size: ${buffer.length} bytes`);
|
||
console.log(` - Asset Type: ${assetType}`);
|
||
console.log(` - Asset ID: ${assetId}`);
|
||
console.log(` - Source URL: ${fileUrl}`);
|
||
console.log(` - File Hash (start): ${fileHash}`);
|
||
console.log(` - File Hash (end): ${fileHashEnd}`);
|
||
|
||
zip.file(zipPath, buffer);
|
||
addedCount++;
|
||
console.log(`[Download] ✅ Successfully added S3 file to zip`);
|
||
console.log(`[Download] ====================================`);
|
||
} else {
|
||
// 本地文件
|
||
const absolutePath = path.isAbsolute(fileUrl)
|
||
? fileUrl
|
||
: path.join(process.cwd(), fileUrl);
|
||
|
||
console.log(`[Download] Reading local file: ${absolutePath} for asset type=${assetType}, id=${assetId}`);
|
||
try {
|
||
await access(absolutePath);
|
||
const fileStream = createReadStream(absolutePath);
|
||
const chunks: Buffer[] = [];
|
||
|
||
await new Promise<void>((resolve, reject) => {
|
||
fileStream.on('data', (chunk: any) => chunks.push(Buffer.from(chunk)));
|
||
fileStream.on('end', () => resolve());
|
||
fileStream.on('error', reject);
|
||
});
|
||
|
||
const buffer = Buffer.concat(chunks);
|
||
|
||
// 验证文件大小
|
||
if (buffer.length === 0) {
|
||
console.warn(`[Download] Empty buffer for local file: ${absolutePath}, assetType=${assetType}, assetId=${assetId}`);
|
||
continue;
|
||
}
|
||
|
||
// 使用唯一文件名（fullZipPath 已经在上面计算好了）
|
||
const zipPath = fullZipPath;
|
||
zip.file(zipPath, buffer);
|
||
addedCount++;
|
||
console.log(`[Download] ✅ Added local file to zip: ${zipPath} (assetType=${assetType}, assetId=${assetId}, path=${absolutePath}, size=${buffer.length} bytes)`);
|
||
} catch (error) {
|
||
console.warn(`[Download] Failed to read local file: ${absolutePath}, assetType=${assetType}, assetId=${assetId}`, error);
|
||
continue;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error(`[Download] Error adding asset to zip:`, error, asset);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 如果按类型分组，为每种类型创建文件夹
|
||
if (shouldGroupByType) {
|
||
console.log(`[Download] ========== Processing grouped assets ==========`);
|
||
for (const [type, assets] of Object.entries(assetsByType)) {
|
||
const folderName = typeFolderMap[type] || type;
|
||
console.log(`[Download] ========== Processing type=${type}, folder=${folderName} ==========`);
|
||
console.log(`[Download] Assets count: ${assets.length}`);
|
||
|
||
// 验证资产类型是否正确，并打印每个资产的详细信息
|
||
for (const asset of assets) {
|
||
console.log(`[Download] Verifying asset: id=${asset.id}, type=${asset.assetType}, url=${asset.fileUrl}, fileName=${asset.fileName}`);
|
||
if (asset.assetType !== type) {
|
||
console.error(`[Download] ❌ CRITICAL ERROR: Asset type mismatch! Expected ${type}, got ${asset.assetType}, assetId=${asset.id}, url=${asset.fileUrl}, fileName=${asset.fileName}`);
|
||
} else {
|
||
console.log(`[Download] ✅ Asset type verified: ${asset.assetType}`);
|
||
}
|
||
}
|
||
await processAssets(assets, folderName);
|
||
console.log(`[Download] ========== Finished processing type=${type} ==========`);
|
||
}
|
||
} else {
|
||
console.log(`[Download] ========== Processing single type=${downloadType} ==========`);
|
||
console.log(`[Download] Assets count: ${targetAssets.length}`);
|
||
|
||
// 验证资产类型是否正确，并打印每个资产的详细信息
|
||
for (const asset of targetAssets) {
|
||
console.log(`[Download] Verifying asset: id=${asset.id}, type=${asset.assetType}, url=${asset.fileUrl}, fileName=${asset.fileName}`);
|
||
if (asset.assetType !== downloadType) {
|
||
console.error(`[Download] ❌ CRITICAL ERROR: Asset type mismatch! Expected ${downloadType}, got ${asset.assetType}, assetId=${asset.id}, url=${asset.fileUrl}, fileName=${asset.fileName}`);
|
||
} else {
|
||
console.log(`[Download] ✅ Asset type verified: ${asset.assetType}`);
|
||
}
|
||
}
|
||
await processAssets(targetAssets);
|
||
console.log(`[Download] ========== Finished processing single type ==========`);
|
||
}
|
||
|
||
console.log(`[Download] Total files added to zip: ${addedCount}`);
|
||
|
||
if (addedCount === 0) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_DOWNLOADABLE_FILES),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
const zipBuffer = await zip.generateAsync({
|
||
type: 'nodebuffer',
|
||
compression: 'DEFLATE',
|
||
compressionOptions: { level: 6 },
|
||
});
|
||
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
zipName,
|
||
].filter(Boolean);
|
||
|
||
const filename = `${filenameParts.join('_')}.zip`;
|
||
|
||
return new NextResponse(zipBuffer as any, {
|
||
headers: {
|
||
'Content-Type': 'application/zip',
|
||
'Content-Length': zipBuffer.length.toString(),
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 动态生成的ZIP文件：短期缓存（1小时），允许重新验证
|
||
'Cache-Control': 'public, max-age=3600, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
},
|
||
});
|
||
}
|
||
|
||
// 动态打包displayImages为ZIP（用于模特类素材）
|
||
async function buildDynamicZipFromDisplayImages(material: any) {
|
||
const displayImages = Array.isArray(material.displayImages)
|
||
? material.displayImages.filter((img: any) => typeof img === 'string' && img.trim().length > 0)
|
||
: [];
|
||
|
||
if (displayImages.length === 0) {
|
||
console.warn('[Download API] No displayImages available for dynamic zip, materialId:', material.id);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_DOWNLOADABLE_FILES, '该素材可能只包含图片'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
console.log(`[Download API] Building ZIP from displayImages for material ${material.id}, total: ${displayImages.length}`);
|
||
|
||
const zip = new JSZip();
|
||
let addedCount = 0;
|
||
|
||
for (let i = 0; i < displayImages.length; i++) {
|
||
const imageUrl = displayImages[i];
|
||
try {
|
||
const response = await fetch(imageUrl);
|
||
if (!response.ok) {
|
||
console.warn(`[Download API] Failed to fetch display image index=${i} url=${imageUrl}, status=${response.status}`);
|
||
continue;
|
||
}
|
||
|
||
const arrayBuffer = await response.arrayBuffer();
|
||
const buffer = Buffer.from(arrayBuffer);
|
||
|
||
if (!buffer || buffer.length === 0) {
|
||
console.warn(`[Download API] Empty buffer for display image index=${i} url=${imageUrl}, skipping`);
|
||
continue;
|
||
}
|
||
|
||
const urlObj = new URL(imageUrl);
|
||
const filename = (path.basename(urlObj.pathname) || `image-${i + 1}.webp`).replace(/[^\w\-.]+/g, '_');
|
||
zip.file(filename, buffer);
|
||
addedCount++;
|
||
} catch (error) {
|
||
console.error(`[Download API] Error while adding display image index=${i} url=${imageUrl} to zip:`, error);
|
||
}
|
||
}
|
||
|
||
if (addedCount === 0) {
|
||
console.warn('[Download API] No valid displayImages added to zip, materialId:', material.id);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_DOWNLOADABLE_FILES, '该素材可能只包含图片'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
const zipBuffer = await zip.generateAsync({
|
||
type: 'nodebuffer',
|
||
compression: 'DEFLATE',
|
||
compressionOptions: { level: 6 },
|
||
});
|
||
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
material.productCategoryName || '',
|
||
'展示图合集',
|
||
].filter(Boolean);
|
||
|
||
const filename = `${filenameParts.join('_')}.zip`;
|
||
|
||
console.log(
|
||
'[Download API] Dynamic ZIP built from displayImages, materialId:',
|
||
material.id,
|
||
'size:',
|
||
(zipBuffer.length / 1024 / 1024).toFixed(2),
|
||
'MB'
|
||
);
|
||
|
||
return new NextResponse(zipBuffer as any, {
|
||
headers: {
|
||
'Content-Type': 'application/zip',
|
||
'Content-Length': zipBuffer.length.toString(),
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 动态生成的ZIP文件：短期缓存（1小时），允许重新验证
|
||
'Cache-Control': 'public, max-age=3600, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
},
|
||
});
|
||
}
|
||
|
||
// GET - 下载素材
|
||
export async function GET(request: NextRequest) {
|
||
try {
|
||
const isShare = isShareLinkAccess(request);
|
||
|
||
// 如果不是分享链接，需要登录
|
||
if (!isShare) {
|
||
const session = await getServerSession(authOptions);
|
||
if (!session) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.UNAUTHORIZED),
|
||
{ status: 401 }
|
||
);
|
||
}
|
||
|
||
const userId = (session.user as any).id;
|
||
const userRole = (session.user as any).role;
|
||
|
||
// 检查用户级别的下载权限
|
||
if (userRole !== 'ADMIN') {
|
||
const user = await prisma.user.findUnique({
|
||
where: { id: userId },
|
||
select: { canDownload: true },
|
||
});
|
||
|
||
if (!user || !user.canDownload) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FORBIDDEN),
|
||
{ status: 403 }
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
const { searchParams } = new URL(request.url);
|
||
const materialId = searchParams.get('id');
|
||
const downloadType = searchParams.get('type'); // all/main/sku/detail/psd
|
||
const assetId = searchParams.get('assetId'); // 单个资产ID（用于单个PSD文件下载）
|
||
|
||
if (!materialId) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.INVALID_DOWNLOAD_TYPE, '缺少素材ID'),
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
|
||
// 查询素材（产品全案需要包含资产信息）
|
||
let material: any;
|
||
try {
|
||
material = await prisma.material.findUnique({
|
||
where: { id: materialId },
|
||
select: {
|
||
id: true,
|
||
zipFilePath: true,
|
||
zipFileName: true,
|
||
productModel: true,
|
||
categoryName: true,
|
||
sceneName: true,
|
||
productCategoryName: true,
|
||
authorName: true,
|
||
materialType: true,
|
||
downloadCount: true,
|
||
displayImages: true,
|
||
videoSourceUrl: true,
|
||
videoPreview540Url: true,
|
||
videoPreviewClipUrl: true,
|
||
videoCoverUrl: true,
|
||
previewUrl: true,
|
||
createdAt: true,
|
||
// assets: {
|
||
// select: {
|
||
// id: true,
|
||
// assetType: true,
|
||
// fileUrl: true,
|
||
// fileName: true,
|
||
// fileSize: true,
|
||
// sortOrder: true,
|
||
// },
|
||
// orderBy: {
|
||
// sortOrder: 'asc',
|
||
// },
|
||
// },
|
||
},
|
||
});
|
||
|
||
// 如果是任务-详情（兼容老的"产品全案"），单独查询 assets
|
||
if (material && isProductPackageType(material.materialType)) {
|
||
const assets = await prisma.materialAsset.findMany({
|
||
where: {
|
||
materialId: material.id,
|
||
},
|
||
select: {
|
||
id: true,
|
||
assetType: true,
|
||
fileUrl: true,
|
||
fileName: true,
|
||
fileSize: true,
|
||
sortOrder: true,
|
||
},
|
||
orderBy: {
|
||
sortOrder: 'asc',
|
||
},
|
||
});
|
||
|
||
// 添加详细日志，验证资产数据
|
||
console.log(`[Download API] ========== 资产查询结果 ==========`);
|
||
console.log(`[Download API] MaterialId: ${material.id}`);
|
||
console.log(`[Download API] Total assets: ${assets.length}`);
|
||
// 将 BigInt 转换为字符串后再序列化
|
||
const assetsForLog = assets.map((a: any) => ({
|
||
...a,
|
||
fileSize: a.fileSize ? a.fileSize.toString() : '0',
|
||
}));
|
||
console.log(`[Download API] Raw assets from database:`, JSON.stringify(assetsForLog, null, 2));
|
||
|
||
// 按类型分组并打印详细信息
|
||
const assetsByType = {
|
||
main: assets.filter((a: any) => a.assetType === 'main'),
|
||
sku: assets.filter((a: any) => a.assetType === 'sku'),
|
||
detail: assets.filter((a: any) => a.assetType === 'detail'),
|
||
psd: assets.filter((a: any) => a.assetType === 'psd'),
|
||
};
|
||
|
||
console.log(`[Download API] Assets breakdown:`);
|
||
console.log(` - main: ${assetsByType.main.length} assets`);
|
||
assetsByType.main.forEach((a: any, i: number) => {
|
||
console.log(` [${i}] id=${a.id}, type=${a.assetType}, url=${a.fileUrl}, fileName=${a.fileName}`);
|
||
});
|
||
|
||
console.log(` - sku: ${assetsByType.sku.length} assets`);
|
||
assetsByType.sku.forEach((a: any, i: number) => {
|
||
console.log(` [${i}] id=${a.id}, type=${a.assetType}, url=${a.fileUrl}, fileName=${a.fileName}`);
|
||
});
|
||
|
||
console.log(` - detail: ${assetsByType.detail.length} assets`);
|
||
assetsByType.detail.forEach((a: any, i: number) => {
|
||
console.log(` [${i}] id=${a.id}, type=${a.assetType}, url=${a.fileUrl}, fileName=${a.fileName}`);
|
||
});
|
||
|
||
console.log(` - psd: ${assetsByType.psd.length} assets`);
|
||
assetsByType.psd.forEach((a: any, i: number) => {
|
||
console.log(` [${i}] id=${a.id}, type=${a.assetType}, url=${a.fileUrl}, fileName=${a.fileName}`);
|
||
});
|
||
|
||
// 检查是否有重复的fileUrl
|
||
const urlCounts: { [key: string]: { count: number; types: string[]; ids: string[] } } = {};
|
||
assets.forEach((asset: any) => {
|
||
if (asset.fileUrl) {
|
||
if (!urlCounts[asset.fileUrl]) {
|
||
urlCounts[asset.fileUrl] = { count: 0, types: [], ids: [] };
|
||
}
|
||
urlCounts[asset.fileUrl].count++;
|
||
urlCounts[asset.fileUrl].types.push(asset.assetType);
|
||
urlCounts[asset.fileUrl].ids.push(asset.id);
|
||
}
|
||
});
|
||
|
||
const duplicateUrls = Object.entries(urlCounts).filter(([url, info]) => info.count > 1);
|
||
if (duplicateUrls.length > 0) {
|
||
console.error(`[Download API] ⚠️ CRITICAL: Found duplicate fileUrls!`);
|
||
duplicateUrls.forEach(([url, info]) => {
|
||
console.error(` URL: ${url}`);
|
||
console.error(` Used by ${info.count} assets:`);
|
||
console.error(` Types: ${info.types.join(', ')}`);
|
||
console.error(` IDs: ${info.ids.join(', ')}`);
|
||
});
|
||
} else {
|
||
console.log(`[Download API] ✅ No duplicate fileUrls found`);
|
||
}
|
||
|
||
// 检查是否有资产类型为空或无效
|
||
const invalidAssets = assets.filter((a: any) => !a.assetType || !['main', 'sku', 'detail', 'psd'].includes(a.assetType));
|
||
if (invalidAssets.length > 0) {
|
||
console.error(`[Download API] ⚠️ CRITICAL: Found assets with invalid assetType!`);
|
||
invalidAssets.forEach((a: any) => {
|
||
console.error(` Asset ID: ${a.id}, assetType: ${a.assetType}, url: ${a.fileUrl}`);
|
||
});
|
||
}
|
||
|
||
console.log(`[Download API] ====================================`);
|
||
|
||
// 将 BigInt 转换为字符串，避免序列化错误
|
||
material.assets = assets.map((asset: any) => ({
|
||
...asset,
|
||
fileSize: asset.fileSize ? asset.fileSize.toString() : '0',
|
||
}));
|
||
}
|
||
} catch (error: any) {
|
||
if (error?.meta?.column?.includes('deletedAt')) {
|
||
console.warn('[Download API] deletedAt field not found, retrying without deletedAt');
|
||
material = await prisma.material.findUnique({
|
||
where: { id: materialId },
|
||
select: {
|
||
id: true,
|
||
zipFilePath: true,
|
||
zipFileName: true,
|
||
productModel: true,
|
||
categoryName: true,
|
||
sceneName: true,
|
||
productCategoryName: true,
|
||
authorName: true,
|
||
materialType: true,
|
||
downloadCount: true,
|
||
displayImages: true,
|
||
videoSourceUrl: true,
|
||
videoPreview540Url: true,
|
||
videoPreviewClipUrl: true,
|
||
videoCoverUrl: true,
|
||
previewUrl: true,
|
||
createdAt: true,
|
||
},
|
||
});
|
||
|
||
// 如果是任务-详情（兼容老的"产品全案"），单独查询 assets
|
||
if (material && isProductPackageType(material.materialType)) {
|
||
const assets = await prisma.materialAsset.findMany({
|
||
where: { materialId: material.id },
|
||
select: {
|
||
id: true,
|
||
assetType: true,
|
||
fileUrl: true,
|
||
fileName: true,
|
||
fileSize: true,
|
||
sortOrder: true,
|
||
},
|
||
orderBy: {
|
||
sortOrder: 'asc',
|
||
},
|
||
});
|
||
material.assets = assets;
|
||
}
|
||
} else {
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
if (!material) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.MATERIAL_NOT_FOUND),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
// 权限检查：如果不是分享链接，检查部门级别的下载权限
|
||
if (!isShare) {
|
||
const session = await getServerSession(authOptions);
|
||
if (session?.user) {
|
||
const userRole = (session.user as any).role;
|
||
const userDepartment = (session.user as any).department;
|
||
const managedDepartment = (session.user as any).managedDepartment;
|
||
const userId = (session.user as any).id;
|
||
|
||
// 超级管理员不受限制
|
||
const { isSuperAdmin } = await import('@/lib/department-permission');
|
||
if (!(await isSuperAdmin(userId))) {
|
||
const canDownload = await canUserDownloadMaterial(
|
||
userDepartment,
|
||
userRole,
|
||
managedDepartment,
|
||
material.materialType,
|
||
userId
|
||
);
|
||
|
||
if (!canDownload) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_PERMISSION),
|
||
{ status: 403 }
|
||
);
|
||
}
|
||
|
||
// 任务-详情：PSD下载权限参考"详情模板"类型的 canDownloadSource 权限
|
||
// 如果下载的是 PSD，需要额外检查"详情模板"类型的源文件下载权限
|
||
if (isProductPackageType(material.materialType) && downloadType === 'psd') {
|
||
const canDownloadPsd = await canUserDownloadSource(
|
||
userDepartment,
|
||
userRole,
|
||
managedDepartment,
|
||
'详情模板', // 产品全案的 PSD 下载权限参考"详情模板"类型
|
||
userId
|
||
);
|
||
|
||
if (!canDownloadPsd) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_PERMISSION, '无权限下载 PSD 源文件'),
|
||
{ status: 403 }
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 任务-详情：处理分类下载
|
||
if (isProductPackageType(material.materialType) && downloadType && material.assets) {
|
||
// 如果指定了assetId，直接下载单个PSD文件（不打包）
|
||
if (assetId && downloadType === 'psd') {
|
||
const asset = (material.assets as any[]).find((a: any) => a.id === assetId && a.assetType === 'psd');
|
||
if (!asset) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.PSD_NOT_FOUND),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
const filePath = asset.fileUrl;
|
||
const absolutePath = path.isAbsolute(filePath)
|
||
? filePath
|
||
: path.join(process.cwd(), filePath);
|
||
|
||
try {
|
||
await access(absolutePath);
|
||
const fileStats = await stat(absolutePath);
|
||
const fileStream = createReadStream(absolutePath);
|
||
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
fileStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
fileStream.on('end', () => controller.close());
|
||
fileStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
fileStream.destroy();
|
||
},
|
||
});
|
||
|
||
const ext = path.extname(asset.fileName || filePath);
|
||
const mimeType = lookup(ext) || 'application/octet-stream';
|
||
|
||
return new NextResponse(stream, {
|
||
headers: {
|
||
'Content-Type': mimeType,
|
||
'Content-Length': fileStats.size.toString(),
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(asset.fileName || 'source.psd')}"`,
|
||
// 静态PSD文件：长期缓存（1天），允许重新验证
|
||
'Cache-Control': 'public, max-age=86400, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
// 添加ETag支持
|
||
'ETag': `"${Buffer.from(`${absolutePath}-${fileStats.size}`).toString('base64').slice(0, 27)}"`,
|
||
},
|
||
});
|
||
} catch (error) {
|
||
console.error('[Download] PSD file not found:', absolutePath, error);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.PSD_NOT_FOUND),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
}
|
||
|
||
return handleProductPackageDownload(material, downloadType);
|
||
}
|
||
|
||
// 增加下载次数（仅非分享链接时）
|
||
if (!isShare) {
|
||
try {
|
||
await prisma.material.update({
|
||
where: { id: materialId },
|
||
data: { downloadCount: { increment: 1 } },
|
||
});
|
||
} catch (error: any) {
|
||
if (error?.meta?.column?.includes('deletedAt')) {
|
||
console.warn('[Download API] deletedAt field not found in update, retrying without deletedAt');
|
||
await prisma.material.update({
|
||
where: { id: materialId },
|
||
data: { downloadCount: { increment: 1 } },
|
||
});
|
||
} else {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检查是否有ZIP文件；若无，则处理S3直链（音频等存放在zipFileName的场景），否则再尝试动态打包
|
||
if (!material.zipFilePath || material.zipFilePath.trim() === '') {
|
||
const zipUrl = (material.zipFileName || '').trim();
|
||
|
||
// 场景：音频/视频源文件直接存放在S3，zipFileName 是 S3 URL
|
||
if (zipUrl && isHttpUrl(zipUrl)) {
|
||
console.log('[Download API] zipFilePath empty, proxy S3 url from zipFileName:', zipUrl);
|
||
|
||
const urlObj = new URL(zipUrl);
|
||
const extFromUrl = path.extname(urlObj.pathname) || '';
|
||
const mimeType = lookup(extFromUrl) || 'application/octet-stream';
|
||
|
||
// 生成下载文件名（与本地下载保持一致的命名逻辑）
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
material.productCategoryName || '',
|
||
'源文件',
|
||
].filter(Boolean);
|
||
const finalExt = extFromUrl || '.bin';
|
||
const filename = `${filenameParts.join('_')}${finalExt}`;
|
||
|
||
try {
|
||
const response = await fetch(zipUrl);
|
||
if (!response.ok || !response.body) {
|
||
console.error('[Download API] Failed to fetch S3 url from zipFileName:', zipUrl, 'status:', response.status);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FILE_NOT_FOUND, 'S3文件访问失败'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
// 将 web ReadableStream 转为 Node.js Readable 再封装为 Web ReadableStream 返回
|
||
const nodeStream = Readable.fromWeb(response.body as any);
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
nodeStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
nodeStream.on('end', () => controller.close());
|
||
nodeStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
nodeStream.destroy();
|
||
},
|
||
});
|
||
|
||
return new NextResponse(stream as any, {
|
||
status: 200,
|
||
headers: {
|
||
'Content-Type': mimeType,
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// S3代理下载：中等缓存（6小时），允许重新验证
|
||
'Cache-Control': 'public, max-age=21600, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
// 不设置 Content-Length，因 S3 直链已被代理流式返回
|
||
},
|
||
});
|
||
} catch (error) {
|
||
console.error('[Download API] Error proxying S3 url from zipFileName:', zipUrl, error);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.S3_ACCESS_FAILED, 'S3代理下载失败'),
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
console.log('[Download API] Material has no zipFilePath, try dynamic zip if supported. type=', material.materialType);
|
||
|
||
// 支持动态打包的素材类型
|
||
const supportedTypes = [
|
||
'模特',
|
||
'实拍图片',
|
||
'买家秀图片',
|
||
'小红书种草',
|
||
'主图模版',
|
||
'SKU模版',
|
||
'品牌VI灵感',
|
||
];
|
||
|
||
if (
|
||
supportedTypes.includes(material.materialType) &&
|
||
Array.isArray(material.displayImages) &&
|
||
material.displayImages.length > 0
|
||
) {
|
||
return buildDynamicZipFromDisplayImages(material);
|
||
}
|
||
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NO_DOWNLOADABLE_FILES, '该素材可能只包含图片'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
|
||
// 处理文件路径
|
||
// 判断是否老素材：根据文档，老素材的特征是：
|
||
// 1. 创建时间 ≤ 2025-10-27
|
||
// 2. previewUrl 不包含 "由壹点AI/"
|
||
// 3. zipFilePath 可能是相对路径（如 uploads/material-*.zip），实际文件存储在外网服务器 103.118.245.6
|
||
const oldMaterialDate = new Date('2025-10-27T23:59:59.999Z');
|
||
const materialCreatedAt = material.createdAt ? new Date(material.createdAt) : null;
|
||
const isOldByDate = materialCreatedAt && materialCreatedAt <= oldMaterialDate;
|
||
const isOldByUrl = material.zipFilePath?.includes('103.118.245.6') ||
|
||
material.zipFilePath?.startsWith('http') ||
|
||
(material.previewUrl && !material.previewUrl.includes('由壹点AI/'));
|
||
|
||
const isOldMaterial = isOldByDate || isOldByUrl;
|
||
|
||
let filePath = material.zipFilePath;
|
||
|
||
// 老素材：如果 zipFilePath 是相对路径，尝试从外网服务器下载
|
||
if (isOldMaterial && filePath && !filePath.startsWith('http') && !path.isAbsolute(filePath)) {
|
||
// 老素材的相对路径，实际文件在外网服务器上
|
||
const externalUrl = `http://103.118.245.6/${filePath.replace(/^\/+/, '')}`;
|
||
console.log('[Download API] Old material detected, using external server URL:', externalUrl);
|
||
|
||
try {
|
||
// 检查外网服务器文件是否存在
|
||
const headResponse = await fetch(externalUrl, { method: 'HEAD' });
|
||
if (headResponse.ok) {
|
||
console.log('[Download API] File found on external server, proxying download');
|
||
|
||
// 从外网服务器代理下载
|
||
const downloadResponse = await fetch(externalUrl);
|
||
if (!downloadResponse.ok || !downloadResponse.body) {
|
||
throw new Error(`External server returned ${downloadResponse.status}`);
|
||
}
|
||
|
||
// 生成下载文件名
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
material.productCategoryName || '',
|
||
'源文件',
|
||
].filter(Boolean);
|
||
const originalExt = material.zipFileName ? path.extname(material.zipFileName) : '';
|
||
const finalExt = originalExt || '.bin';
|
||
const filename = `${filenameParts.join('_')}${finalExt}`;
|
||
|
||
// 将 web ReadableStream 转为 Node.js Readable 再封装为 Web ReadableStream 返回
|
||
const nodeStream = Readable.fromWeb(downloadResponse.body as any);
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
nodeStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
nodeStream.on('end', () => controller.close());
|
||
nodeStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
nodeStream.destroy();
|
||
},
|
||
});
|
||
|
||
const ext = path.extname(material.zipFileName || '');
|
||
const mimeType = lookup(ext) || 'application/octet-stream';
|
||
|
||
return new NextResponse(stream as any, {
|
||
status: 200,
|
||
headers: {
|
||
'Content-Type': mimeType,
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 外网服务器代理下载：中等缓存（6小时），允许重新验证
|
||
'Cache-Control': 'public, max-age=21600, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
'Vary': 'Accept-Encoding',
|
||
},
|
||
});
|
||
} else {
|
||
console.warn('[Download API] External server file not found, status:', headResponse.status);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FILE_NOT_FOUND, '老素材文件在外网服务器上不存在'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
} catch (externalError) {
|
||
console.error('[Download API] External server download failed:', externalError);
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.NETWORK_ERROR, '无法连接到外网服务器，请检查网络连接'),
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
// 新素材：相对路径转绝对路径
|
||
if (!isOldMaterial) {
|
||
if (!path.isAbsolute(filePath)) {
|
||
filePath = path.join(process.cwd(), filePath);
|
||
}
|
||
}
|
||
|
||
console.log('Attempting to download file:', filePath, '(Old material:', isOldMaterial, ')');
|
||
|
||
// 检查文件是否存在
|
||
try {
|
||
await access(filePath);
|
||
} catch (error) {
|
||
console.error('File not found:', filePath, 'error:', error);
|
||
|
||
// 如果是视频类素材且源文件不存在，尝试下载720P（预览视频，回退方案）
|
||
const videoTypes = ['主图视频', '安装视频', '种草视频'];
|
||
const isVideoMaterial = videoTypes.includes(material.materialType) ||
|
||
material.videoSourceUrl ||
|
||
material.videoPreview540Url;
|
||
|
||
if (isVideoMaterial && material.videoPreview540Url) {
|
||
console.log('[Download API] Video source file missing, fallback to 720P preview video, materialId:', material.id);
|
||
console.log('[Download API] Preview video URL:', material.videoPreview540Url);
|
||
|
||
try {
|
||
// 检查预览视频URL是否可访问
|
||
const previewResponse = await fetch(material.videoPreview540Url, { method: 'HEAD' });
|
||
if (previewResponse.ok) {
|
||
console.log('[Download API] Preview video accessible, proxying download');
|
||
|
||
// 从S3代理下载预览视频
|
||
const downloadResponse = await fetch(material.videoPreview540Url);
|
||
if (!downloadResponse.ok || !downloadResponse.body) {
|
||
throw new Error(`Preview video fetch returned ${downloadResponse.status}`);
|
||
}
|
||
|
||
// 生成下载文件名（标注为720P预览）
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
material.productCategoryName || '',
|
||
'720P',
|
||
].filter(Boolean);
|
||
const filename = `${filenameParts.join('_')}.mp4`;
|
||
|
||
// 将 web ReadableStream 转为 Node.js Readable 再封装为 Web ReadableStream 返回
|
||
const nodeStream = Readable.fromWeb(downloadResponse.body as any);
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
nodeStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
nodeStream.on('end', () => controller.close());
|
||
nodeStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
nodeStream.destroy();
|
||
},
|
||
});
|
||
|
||
return new NextResponse(stream as any, {
|
||
status: 200,
|
||
headers: {
|
||
'Content-Type': 'video/mp4',
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 预览视频代理下载：中等缓存（6小时），允许重新验证
|
||
'Cache-Control': 'public, max-age=21600, must-revalidate',
|
||
'Accept-Ranges': 'bytes',
|
||
'Vary': 'Accept-Encoding',
|
||
},
|
||
});
|
||
} else {
|
||
console.warn('[Download API] Preview video not accessible, status:', previewResponse.status);
|
||
// 预览视频不可访问，继续尝试其他fallback
|
||
}
|
||
} catch (videoError) {
|
||
console.error('[Download API] Preview video download failed:', videoError);
|
||
// 预览视频下载失败，继续尝试其他fallback
|
||
}
|
||
}
|
||
|
||
// 如果本地文件不存在，尝试动态打包
|
||
const supportedTypes = [
|
||
'模特',
|
||
'实拍图片',
|
||
'买家秀图片',
|
||
'小红书种草',
|
||
'主图模版',
|
||
'SKU模版',
|
||
'品牌VI灵感',
|
||
];
|
||
|
||
if (
|
||
supportedTypes.includes(material.materialType) &&
|
||
Array.isArray(material.displayImages) &&
|
||
material.displayImages.length > 0
|
||
) {
|
||
console.log('[Download API] Local file missing, fallback to dynamic zip from displayImages, materialId:', material.id);
|
||
return buildDynamicZipFromDisplayImages(material);
|
||
}
|
||
|
||
// 所有fallback都失败，返回明确的错误信息
|
||
if (isOldMaterial) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FILE_NOT_FOUND, '老素材文件在外网服务器上不存在或无法访问'),
|
||
{ status: 404 }
|
||
);
|
||
} else if (isVideoMaterial) {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FILE_NOT_FOUND, '视频源文件不存在，且预览视频也无法访问'),
|
||
{ status: 404 }
|
||
);
|
||
} else {
|
||
return NextResponse.json(
|
||
createDownloadError(DownloadErrorCode.FILE_NOT_FOUND, '文件不存在或已被删除'),
|
||
{ status: 404 }
|
||
);
|
||
}
|
||
}
|
||
|
||
// 获取文件大小
|
||
const fileStats = await stat(filePath);
|
||
const fileSize = fileStats.size;
|
||
|
||
// 确定文件扩展名和MIME类型
|
||
const originalExt = material.zipFileName ? path.extname(material.zipFileName) : '';
|
||
const actualExt = path.extname(filePath);
|
||
const ext = originalExt || actualExt;
|
||
const mimeType = lookup(ext || filePath) || 'application/octet-stream';
|
||
const mimeExt = extension(mimeType);
|
||
const finalExt = ext || (mimeExt ? `.${mimeExt}` : '');
|
||
|
||
// 生成下载文件名
|
||
const filenameParts = [
|
||
material.productModel || 'unknown',
|
||
material.categoryName || '',
|
||
material.sceneName || '',
|
||
material.productCategoryName || '',
|
||
'源文件',
|
||
].filter(Boolean);
|
||
|
||
const filename = `${filenameParts.join('_')}${finalExt || '.bin'}`;
|
||
|
||
console.log('Download filename:', filename, 'size:', fileSize, 'mime:', mimeType);
|
||
|
||
// 处理Range请求（断点续传）
|
||
const rangeHeader = request.headers.get('range');
|
||
|
||
if (rangeHeader) {
|
||
const rangePrefix = 'bytes=';
|
||
if (!rangeHeader.startsWith(rangePrefix)) {
|
||
return new NextResponse('Range header format is invalid', { status: 416 });
|
||
}
|
||
|
||
const rangeParts = rangeHeader.replace(rangePrefix, '').split('-');
|
||
const start = parseInt(rangeParts[0], 10);
|
||
const end = rangeParts[1] ? parseInt(rangeParts[1], 10) : fileSize - 1;
|
||
|
||
if (isNaN(start) || isNaN(end) || start >= fileSize || end >= fileSize) {
|
||
return new NextResponse('Range header out of bounds', { status: 416 });
|
||
}
|
||
|
||
const chunkSize = end - start + 1;
|
||
const fileStream = createReadStream(filePath, { start, end });
|
||
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
fileStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
fileStream.on('end', () => controller.close());
|
||
fileStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
fileStream.destroy();
|
||
},
|
||
});
|
||
|
||
return new NextResponse(stream, {
|
||
status: 206,
|
||
headers: {
|
||
'Content-Range': `bytes ${start}-${end}/${fileSize}`,
|
||
'Accept-Ranges': 'bytes',
|
||
'Content-Length': chunkSize.toString(),
|
||
'Content-Type': mimeType,
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 静态文件Range请求：长期缓存（1天），允许重新验证
|
||
'Cache-Control': 'public, max-age=86400, must-revalidate',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding, Range',
|
||
},
|
||
});
|
||
}
|
||
|
||
// 正常下载
|
||
const fileStream = createReadStream(filePath);
|
||
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
fileStream.on('data', (chunk) => controller.enqueue(chunk));
|
||
fileStream.on('end', () => controller.close());
|
||
fileStream.on('error', (err) => controller.error(err));
|
||
},
|
||
cancel() {
|
||
fileStream.destroy();
|
||
},
|
||
});
|
||
|
||
return new NextResponse(stream, {
|
||
headers: {
|
||
'Accept-Ranges': 'bytes',
|
||
'Content-Length': fileSize.toString(),
|
||
'Content-Type': mimeType,
|
||
'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
|
||
// 静态文件下载：长期缓存（1天），允许重新验证
|
||
// 注意：对于已存在的文件，内容不会改变，可以缓存
|
||
'Cache-Control': 'public, max-age=86400, must-revalidate',
|
||
// 性能优化：启用压缩（如果客户端支持）
|
||
'Vary': 'Accept-Encoding',
|
||
// 添加ETag支持（基于文件路径和大小）
|
||
'ETag': `"${Buffer.from(`${filePath}-${fileSize}`).toString('base64').slice(0, 27)}"`,
|
||
},
|
||
});
|
||
} catch (error) {
|
||
console.error('Download error:', error);
|
||
|
||
// 根据错误类型返回对应的错误代码
|
||
const errorMessage = error instanceof Error ? error.message : String(error);
|
||
|
||
let errorCode = DownloadErrorCode.UNKNOWN_ERROR;
|
||
let details: string | undefined;
|
||
|
||
if (errorMessage.includes('BigInt')) {
|
||
errorCode = DownloadErrorCode.BIGINT_SERIALIZATION_ERROR;
|
||
} else if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
|
||
errorCode = DownloadErrorCode.FILE_NOT_FOUND;
|
||
details = errorMessage;
|
||
} else if (errorMessage.includes('S3') || errorMessage.includes('存储')) {
|
||
errorCode = DownloadErrorCode.S3_ACCESS_FAILED;
|
||
details = errorMessage;
|
||
} else if (errorMessage.includes('network') || errorMessage.includes('网络')) {
|
||
errorCode = DownloadErrorCode.NETWORK_ERROR;
|
||
details = errorMessage;
|
||
} else if (errorMessage.includes('stream') || errorMessage.includes('流')) {
|
||
errorCode = DownloadErrorCode.STREAM_ERROR;
|
||
details = errorMessage;
|
||
} else if (errorMessage.includes('zip') || errorMessage.includes('ZIP')) {
|
||
errorCode = DownloadErrorCode.ZIP_CREATION_FAILED;
|
||
details = errorMessage;
|
||
} else {
|
||
details = errorMessage;
|
||
}
|
||
|
||
return NextResponse.json(
|
||
createDownloadError(errorCode, details),
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|