380 lines
13 KiB
TypeScript
380 lines
13 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server'
|
|
import { getServerSession } from 'next-auth'
|
|
import { promises as fs } from 'fs'
|
|
import path from 'path'
|
|
import { authOptions } from '@/lib/auth'
|
|
import { prisma } from '@/lib/prisma'
|
|
import { sanitizeFileName } from '@/lib/image-processor'
|
|
import { deleteFileIfUnreferenced } from '@/lib/file-cleanup'
|
|
import {
|
|
buildPublicDisplayUrl,
|
|
buildWhiteBackgroundPublicDisplayPath,
|
|
buildWhiteBackgroundPublicDisplayPathFromAssetPath,
|
|
uploadPublicDisplayToS3,
|
|
} from '@/lib/public-display'
|
|
import { deleteFromS3 } from '@/lib/s3'
|
|
import {
|
|
buildWhiteBackgroundFixedFileName,
|
|
countWhiteBackgroundFixedViews,
|
|
getAllWhiteBackgroundAssetTypesForSku,
|
|
getNextWhiteBackgroundOtherIndex,
|
|
getWhiteBackgroundAssetWhereForSku,
|
|
getWhiteBackgroundOtherAssetType,
|
|
getWhiteBackgroundPreviewRelativePathFromAssetPath,
|
|
getWhiteBackgroundRelativeDirectory,
|
|
getWhiteBackgroundRelativeFilePath,
|
|
getWhiteBackgroundViewAssetType,
|
|
getWhiteBackgroundZipFileName,
|
|
groupWhiteBackgroundAssetsBySku,
|
|
hasCompleteWhiteBackgroundAssetGroup,
|
|
normalizeWhiteBackgroundSkuName,
|
|
STANDARD_MODEL_WHITE_BG_OTHER_FIELD_NAME,
|
|
STANDARD_MODEL_WHITE_BG_VIEWS,
|
|
type StandardModelWhiteBgKey,
|
|
} from '@/lib/standard-model-white-background'
|
|
import { normalizeStandardModelWhiteBackgroundSourceType } from '@/lib/standard-model-white-background-metadata'
|
|
import { createMaterialLog } from '@/lib/material-log'
|
|
import { buildWhiteBackgroundWebpVariants } from '@/lib/white-background-preview'
|
|
|
|
export const runtime = 'nodejs'
|
|
|
|
function resolveSafeOtherBaseName(file: File, index: number): string {
|
|
const ext = path.extname(file.name)
|
|
const originalBaseName = path.basename(file.name, ext)
|
|
return (
|
|
sanitizeFileName(originalBaseName || `other-${index}`)
|
|
.replace(/\s+/g, '-')
|
|
.toLowerCase() || `other-${index}`
|
|
)
|
|
}
|
|
|
|
export async function POST(
|
|
request: NextRequest,
|
|
{ params }: { params: { id: string } },
|
|
) {
|
|
const writtenFilePaths: string[] = []
|
|
const uploadedPreviewUrls: string[] = []
|
|
let assetsPersisted = false
|
|
|
|
try {
|
|
const session = await getServerSession(authOptions)
|
|
if (!session?.user || !(session.user as any).id) {
|
|
return NextResponse.json({ error: '请先登录' }, { status: 401 })
|
|
}
|
|
|
|
const materialId = params.id
|
|
const userId = (session.user as any).id
|
|
|
|
const material = await prisma.material.findUnique({
|
|
where: { id: materialId },
|
|
select: {
|
|
id: true,
|
|
materialType: true,
|
|
userId: true,
|
|
productCategoryName: true,
|
|
categoryName: true,
|
|
},
|
|
})
|
|
|
|
if (!material) {
|
|
return NextResponse.json({ error: '素材不存在' }, { status: 404 })
|
|
}
|
|
|
|
if (material.materialType !== '标准模型') {
|
|
return NextResponse.json({ error: '只有标准模型类型支持上传白底图' }, { status: 400 })
|
|
}
|
|
|
|
const formData = await request.formData()
|
|
const skuId = ((formData.get('skuId') as string) || '').trim()
|
|
const skuName = ((formData.get('skuName') as string) || '').trim()
|
|
const sourceType = normalizeStandardModelWhiteBackgroundSourceType(
|
|
(formData.get('sourceType') as string) || '',
|
|
)
|
|
|
|
if (!skuId) {
|
|
return NextResponse.json({ error: '缺少SKU ID' }, { status: 400 })
|
|
}
|
|
|
|
if (!sourceType) {
|
|
return NextResponse.json({ error: '白底图出图方式必填，且只能是 实拍、渲染、AI' }, { status: 400 })
|
|
}
|
|
|
|
const sku = await prisma.materialSku.findFirst({
|
|
where: {
|
|
id: skuId,
|
|
materialId,
|
|
deletedAt: null,
|
|
},
|
|
select: { id: true, skuName: true },
|
|
})
|
|
|
|
if (!sku) {
|
|
return NextResponse.json({ error: 'SKU不存在或已被删除' }, { status: 404 })
|
|
}
|
|
|
|
const whiteBackgroundImages = STANDARD_MODEL_WHITE_BG_VIEWS.reduce((acc, view) => {
|
|
acc[view.key] = formData.get(view.fieldName) as File | null
|
|
return acc
|
|
}, {} as Partial<Record<StandardModelWhiteBgKey, File | null>>)
|
|
|
|
const otherImages = formData
|
|
.getAll(STANDARD_MODEL_WHITE_BG_OTHER_FIELD_NAME)
|
|
.filter((file): file is File => {
|
|
return (
|
|
!!file &&
|
|
typeof (file as File).name === 'string' &&
|
|
typeof (file as File).arrayBuffer === 'function' &&
|
|
Number((file as File).size || 0) > 0
|
|
)
|
|
})
|
|
|
|
const uploadedFixedViews = STANDARD_MODEL_WHITE_BG_VIEWS.filter((view) => !!whiteBackgroundImages[view.key])
|
|
if (uploadedFixedViews.length === 0 && otherImages.length === 0) {
|
|
return NextResponse.json(
|
|
{ error: '请至少上传 1 张白底图' },
|
|
{ status: 400 },
|
|
)
|
|
}
|
|
|
|
const existingAssets = await prisma.materialAsset.findMany({
|
|
where: {
|
|
materialId,
|
|
...getWhiteBackgroundAssetWhereForSku(skuId),
|
|
},
|
|
select: {
|
|
id: true,
|
|
fileUrl: true,
|
|
assetType: true,
|
|
sortOrder: true,
|
|
},
|
|
})
|
|
|
|
const existingWhiteBackgroundGroup = groupWhiteBackgroundAssetsBySku(existingAssets).get(skuId)
|
|
const nextOtherIndex = getNextWhiteBackgroundOtherIndex(existingWhiteBackgroundGroup)
|
|
const assetTypesToReplace = new Set<string>(getAllWhiteBackgroundAssetTypesForSku(skuId))
|
|
const normalizedSkuName = normalizeWhiteBackgroundSkuName(skuName || sku.skuName)
|
|
const whiteBackgroundCategoryName =
|
|
String(material.productCategoryName || '').trim() ||
|
|
String(material.categoryName || '').trim()
|
|
|
|
const uploadDir = path.join(
|
|
process.cwd(),
|
|
...getWhiteBackgroundRelativeDirectory(materialId, skuId).split('/'),
|
|
)
|
|
|
|
await fs.mkdir(path.join(uploadDir, 'other'), { recursive: true })
|
|
|
|
const assetsToCreate: Array<{
|
|
materialId: string
|
|
assetType: string
|
|
fileUrl: string
|
|
fileName: string
|
|
fileSize: bigint
|
|
sortOrder: number
|
|
}> = []
|
|
|
|
for (let index = 0; index < STANDARD_MODEL_WHITE_BG_VIEWS.length; index++) {
|
|
const view = STANDARD_MODEL_WHITE_BG_VIEWS[index]
|
|
const imageFile = whiteBackgroundImages[view.key]
|
|
if (!imageFile) {
|
|
continue
|
|
}
|
|
|
|
const displayFileName = buildWhiteBackgroundFixedFileName(
|
|
normalizedSkuName,
|
|
whiteBackgroundCategoryName,
|
|
view.label,
|
|
'.webp',
|
|
)
|
|
const diskFileName = displayFileName
|
|
const relativePath = getWhiteBackgroundRelativeFilePath(materialId, skuId, diskFileName)
|
|
const absolutePath = path.join(process.cwd(), ...relativePath.split('/'))
|
|
const sourceBuffer = Buffer.from(await imageFile.arrayBuffer())
|
|
const { original, preview } = await buildWhiteBackgroundWebpVariants(sourceBuffer)
|
|
assetTypesToReplace.add(getWhiteBackgroundViewAssetType(skuId, view.key))
|
|
|
|
await fs.mkdir(path.dirname(absolutePath), { recursive: true })
|
|
await fs.writeFile(absolutePath, original)
|
|
writtenFilePaths.push(relativePath)
|
|
const previewUrl = await uploadPublicDisplayToS3(
|
|
preview,
|
|
buildWhiteBackgroundPublicDisplayPath(materialId, skuId, diskFileName),
|
|
'image/webp',
|
|
)
|
|
uploadedPreviewUrls.push(previewUrl)
|
|
|
|
assetsToCreate.push({
|
|
materialId,
|
|
assetType: getWhiteBackgroundViewAssetType(skuId, view.key),
|
|
fileUrl: relativePath,
|
|
fileName: displayFileName,
|
|
fileSize: BigInt(original.length),
|
|
sortOrder: index,
|
|
})
|
|
}
|
|
|
|
for (let index = 0; index < otherImages.length; index++) {
|
|
const imageFile = otherImages[index]
|
|
const otherIndex = nextOtherIndex + index
|
|
const safeBaseName = resolveSafeOtherBaseName(imageFile, otherIndex)
|
|
const displayFileName = `${String(otherIndex).padStart(2, '0')}-${safeBaseName}.webp`
|
|
const diskFileName = `other/${displayFileName}`
|
|
const relativePath = getWhiteBackgroundRelativeFilePath(materialId, skuId, diskFileName)
|
|
const absolutePath = path.join(process.cwd(), ...relativePath.split('/'))
|
|
const sourceBuffer = Buffer.from(await imageFile.arrayBuffer())
|
|
const { original, preview } = await buildWhiteBackgroundWebpVariants(sourceBuffer)
|
|
|
|
await fs.mkdir(path.dirname(absolutePath), { recursive: true })
|
|
await fs.writeFile(absolutePath, original)
|
|
writtenFilePaths.push(relativePath)
|
|
const previewUrl = await uploadPublicDisplayToS3(
|
|
preview,
|
|
buildWhiteBackgroundPublicDisplayPath(materialId, skuId, diskFileName),
|
|
'image/webp',
|
|
)
|
|
uploadedPreviewUrls.push(previewUrl)
|
|
|
|
assetsToCreate.push({
|
|
materialId,
|
|
assetType: getWhiteBackgroundOtherAssetType(skuId, otherIndex),
|
|
fileUrl: relativePath,
|
|
fileName: displayFileName,
|
|
fileSize: BigInt(original.length),
|
|
sortOrder: 1000 + otherIndex - 1,
|
|
})
|
|
}
|
|
|
|
const assetTypeListToReplace = Array.from(assetTypesToReplace)
|
|
const replacedAssets = existingAssets.filter((asset) => assetTypeListToReplace.includes(asset.assetType))
|
|
|
|
const nextFixed: Partial<Record<StandardModelWhiteBgKey, { assetType: string }>> = {
|
|
...(existingWhiteBackgroundGroup?.fixed || {}),
|
|
}
|
|
uploadedFixedViews.forEach((view) => {
|
|
nextFixed[view.key] = {
|
|
assetType: getWhiteBackgroundViewAssetType(skuId, view.key),
|
|
}
|
|
})
|
|
const nextFixedCount = countWhiteBackgroundFixedViews({ fixed: nextFixed })
|
|
const nextOtherCount = (existingWhiteBackgroundGroup?.other.length || 0) + otherImages.length
|
|
const whiteBackgroundCount = nextFixedCount + nextOtherCount
|
|
const isComplete =
|
|
hasCompleteWhiteBackgroundAssetGroup({ fixed: nextFixed }) && nextFixedCount === STANDARD_MODEL_WHITE_BG_VIEWS.length
|
|
|
|
const uploadedAt = new Date()
|
|
|
|
await prisma.$transaction(async (tx) => {
|
|
if (assetTypeListToReplace.length > 0) {
|
|
await tx.materialAsset.deleteMany({
|
|
where: {
|
|
materialId,
|
|
assetType: {
|
|
in: assetTypeListToReplace,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
if (assetsToCreate.length > 0) {
|
|
await tx.materialAsset.createMany({
|
|
data: assetsToCreate,
|
|
})
|
|
}
|
|
|
|
await tx.materialSku.update({
|
|
where: { id: skuId },
|
|
data: {
|
|
whiteBackgroundSourceType: sourceType,
|
|
whiteBackgroundUploadedBy: userId,
|
|
whiteBackgroundUploadedAt: uploadedAt,
|
|
},
|
|
})
|
|
})
|
|
assetsPersisted = true
|
|
|
|
for (const asset of replacedAssets) {
|
|
if (!asset.fileUrl) {
|
|
continue
|
|
}
|
|
await deleteFileIfUnreferenced(asset.fileUrl)
|
|
|
|
const previewRelativePath = getWhiteBackgroundPreviewRelativePathFromAssetPath(asset.fileUrl)
|
|
if (previewRelativePath) {
|
|
await deleteFileIfUnreferenced(previewRelativePath)
|
|
}
|
|
|
|
const publicDisplayPath = buildWhiteBackgroundPublicDisplayPathFromAssetPath(asset.fileUrl)
|
|
const publicDisplayUrl = publicDisplayPath ? buildPublicDisplayUrl(publicDisplayPath) : null
|
|
if (publicDisplayUrl) {
|
|
await deleteFileIfUnreferenced(publicDisplayUrl)
|
|
}
|
|
}
|
|
|
|
try {
|
|
await createMaterialLog({
|
|
materialId,
|
|
userId,
|
|
action: 'UPDATE',
|
|
changes: {
|
|
whiteBackgroundStorageMode: {
|
|
oldValue: existingAssets.length > 0 ? 'replace' : null,
|
|
newValue: 'per-image-assets',
|
|
},
|
|
whiteBackgroundSummary: {
|
|
oldValue: null,
|
|
newValue: {
|
|
uploadedFixedCount: uploadedFixedViews.length,
|
|
fixedCount: nextFixedCount,
|
|
otherCount: nextOtherCount,
|
|
skuId,
|
|
skuName: normalizedSkuName,
|
|
sourceType,
|
|
whiteBackgroundUploadedBy: userId,
|
|
whiteBackgroundUploadedAt: uploadedAt.toISOString(),
|
|
zipFileName: getWhiteBackgroundZipFileName(normalizedSkuName),
|
|
},
|
|
},
|
|
},
|
|
})
|
|
} catch (logError) {
|
|
console.error('记录白底图上传日志失败:', logError)
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
whiteBackgroundUploaded: whiteBackgroundCount > 0,
|
|
uploadedFixedCount: uploadedFixedViews.length,
|
|
fixedCount: nextFixedCount,
|
|
otherCount: nextOtherCount,
|
|
whiteBackgroundCount,
|
|
isComplete,
|
|
sourceType,
|
|
whiteBackgroundUploadedBy: userId,
|
|
whiteBackgroundUploadedAt: uploadedAt.toISOString(),
|
|
downloadFileName: getWhiteBackgroundZipFileName(normalizedSkuName),
|
|
})
|
|
} catch (error) {
|
|
if (!assetsPersisted) {
|
|
for (const relativePath of writtenFilePaths) {
|
|
const absolutePath = path.join(process.cwd(), ...relativePath.split('/'))
|
|
try {
|
|
await fs.unlink(absolutePath)
|
|
} catch {
|
|
// ignore cleanup failure
|
|
}
|
|
}
|
|
|
|
for (const previewUrl of uploadedPreviewUrls) {
|
|
try {
|
|
await deleteFromS3(previewUrl)
|
|
} catch {
|
|
// ignore cleanup failure
|
|
}
|
|
}
|
|
}
|
|
|
|
console.error('上传白底图失败:', error)
|
|
return NextResponse.json({ error: '上传白底图失败' }, { status: 500 })
|
|
}
|
|
}
|