560 lines
18 KiB
TypeScript
560 lines
18 KiB
TypeScript
import { NextRequest, NextResponse } from "next/server";
|
||
import { auth } from "@/app/(auth)/auth";
|
||
import { db } from "@/lib/db";
|
||
import { systemSettings, generatedImage } from "@/lib/db/schema";
|
||
import { eq } from "drizzle-orm";
|
||
import { uploadFile } from "@/lib/storage/service";
|
||
import {
|
||
createMediaAssetRelation,
|
||
getPointsSystemConfig,
|
||
getMediaAssetsByUserAndUrls,
|
||
upsertMediaAsset,
|
||
} from "@/lib/db/queries";
|
||
import { prepareFeaturePointsCharge } from "@/lib/points/feature-charge";
|
||
import { getImageToolCreditCost } from "@/lib/points/config";
|
||
import { generateCanvasImage } from "@/lib/canvas/generate-image";
|
||
import { FAL_NANO_BANANA_2_EDIT_MODEL_ID } from "@/lib/ai/fal-image-models";
|
||
|
||
export const maxDuration = 600;
|
||
|
||
// PicWish API 需要公网可访问的 HTTP/HTTPS URL
|
||
const WATERMARK_SYNC_WAIT_TIMEOUT_MS = 20_000;
|
||
const WATERMARK_POLL_INTERVAL_MS = 1200;
|
||
|
||
// 获取去水印API配置
|
||
async function getWatermarkRemoveConfig() {
|
||
try {
|
||
const setting = await db
|
||
.select()
|
||
.from(systemSettings)
|
||
.where(eq(systemSettings.key, "watermark_remove_config"))
|
||
.limit(1);
|
||
|
||
if (setting.length > 0 && setting[0].value) {
|
||
return setting[0].value as { apiKey: string };
|
||
}
|
||
return null;
|
||
} catch (error) {
|
||
console.error("[WatermarkRemove] 获取配置失败:", error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// 轮询获取处理结果
|
||
async function pollForResult(
|
||
taskId: string,
|
||
apiKey: string,
|
||
timeoutMs = WATERMARK_SYNC_WAIT_TIMEOUT_MS
|
||
): Promise<{ success: boolean; imageUrl?: string; error?: string; pending?: boolean }> {
|
||
const maxAttempts = Math.max(1, Math.ceil(timeoutMs / WATERMARK_POLL_INTERVAL_MS));
|
||
const pollInterval = WATERMARK_POLL_INTERVAL_MS;
|
||
|
||
for (let attempt = 0; attempt < maxAttempts; attempt++) {
|
||
try {
|
||
const response = await fetch(
|
||
`https://techsz.aoscdn.com/api/tasks/visual/external/watermark-remove/${taskId}`,
|
||
{
|
||
method: "GET",
|
||
headers: {
|
||
"X-API-KEY": apiKey,
|
||
},
|
||
}
|
||
);
|
||
|
||
if (!response.ok) {
|
||
const errorText = await response.text();
|
||
console.error(`[WatermarkRemove] 轮询失败 (attempt ${attempt + 1}):`, errorText);
|
||
// 继续轮询
|
||
await new Promise(resolve => setTimeout(resolve, pollInterval));
|
||
continue;
|
||
}
|
||
|
||
const result = await response.json();
|
||
console.log(`[WatermarkRemove] 轮询结果 (attempt ${attempt + 1}):`, JSON.stringify(result).substring(0, 200));
|
||
|
||
const state = result.data?.state;
|
||
const stateDetail = result.data?.state_detail;
|
||
|
||
// 检查任务状态
|
||
if (state === 1) {
|
||
// 任务完成 - PicWish API 返回 "file" 字段
|
||
const imageUrl = result.data?.file || result.data?.image;
|
||
if (imageUrl) {
|
||
return { success: true, imageUrl };
|
||
}
|
||
return { success: false, error: "处理完成但未返回图片URL" };
|
||
} else if (typeof state === "number" && state < 0) {
|
||
// 任务失败
|
||
return { success: false, error: result.data?.error || "去水印处理失败" };
|
||
} else if (state === 4 || state === 0) {
|
||
// 明确处理中状态，继续轮询
|
||
console.log(`[WatermarkRemove] 任务处理中: state=${state}, detail=${stateDetail || "N/A"}`);
|
||
}
|
||
// 其他状态默认继续轮询
|
||
|
||
await new Promise(resolve => setTimeout(resolve, pollInterval));
|
||
} catch (error) {
|
||
console.error(`[WatermarkRemove] 轮询错误 (attempt ${attempt + 1}):`, error);
|
||
await new Promise(resolve => setTimeout(resolve, pollInterval));
|
||
}
|
||
}
|
||
|
||
return {
|
||
success: false,
|
||
pending: true,
|
||
error: "去水印任务仍在处理中",
|
||
};
|
||
}
|
||
|
||
function buildWatermarkTaskPendingResponse(taskId: string) {
|
||
return NextResponse.json(
|
||
{
|
||
success: true,
|
||
processing: true,
|
||
status: "running",
|
||
taskId,
|
||
pollAfterMs: WATERMARK_POLL_INTERVAL_MS,
|
||
},
|
||
{ status: 202 }
|
||
);
|
||
}
|
||
|
||
async function persistWatermarkResult(params: {
|
||
processedImageUrl: string;
|
||
userId: string;
|
||
startedAt?: number;
|
||
sourceImageUrls?: string[];
|
||
}): Promise<{
|
||
success: boolean;
|
||
original_url: string;
|
||
thumbnail_url: string;
|
||
processing_time?: number;
|
||
}> {
|
||
try {
|
||
const imageResponse = await fetch(params.processedImageUrl);
|
||
if (!imageResponse.ok) {
|
||
throw new Error("下载处理后的图片失败");
|
||
}
|
||
const imageBuffer = await imageResponse.arrayBuffer();
|
||
const filename = `watermark-removed-${Date.now()}.png`;
|
||
const uploadResult = await uploadFile(filename, imageBuffer);
|
||
|
||
let saved = false;
|
||
let saveError: unknown = null;
|
||
let savedImage:
|
||
| {
|
||
id: string;
|
||
}
|
||
| null = null;
|
||
for (let attempt = 1; attempt <= 3; attempt += 1) {
|
||
try {
|
||
([savedImage] = await db.insert(generatedImage).values({
|
||
userId: params.userId,
|
||
thumbnailUrl: uploadResult.url,
|
||
originalUrl: uploadResult.url,
|
||
imageSize: "2K",
|
||
prompt: "去水印处理",
|
||
modelId: "watermark-remove",
|
||
}).returning());
|
||
saved = true;
|
||
break;
|
||
} catch (error) {
|
||
saveError = error;
|
||
if (attempt < 3) {
|
||
await new Promise((resolve) => setTimeout(resolve, 120 * attempt));
|
||
}
|
||
}
|
||
}
|
||
if (!saved) {
|
||
console.error("[WatermarkRemove] 保存到相册失败:", saveError);
|
||
throw new Error("去水印成功但保存到相册失败，请稍后重试");
|
||
}
|
||
|
||
if (savedImage) {
|
||
try {
|
||
const sourceAssets =
|
||
Array.isArray(params.sourceImageUrls) && params.sourceImageUrls.length > 0
|
||
? await getMediaAssetsByUserAndUrls({
|
||
userId: params.userId,
|
||
urls: params.sourceImageUrls,
|
||
})
|
||
: [];
|
||
const media = await upsertMediaAsset({
|
||
userId: params.userId,
|
||
mediaType: "image",
|
||
sourceType: "edited",
|
||
status: "ready",
|
||
originalUrl: uploadResult.url,
|
||
previewUrl: uploadResult.url,
|
||
thumbnailUrl: uploadResult.url,
|
||
displayName: "去水印处理",
|
||
prompt: "去水印处理",
|
||
modelId: "watermark-remove",
|
||
sourceTable: "GeneratedImage",
|
||
sourceRowId: savedImage.id,
|
||
primaryParentAssetId: sourceAssets[0]?.id ?? null,
|
||
metadata: {
|
||
imageSize: "2K",
|
||
},
|
||
});
|
||
if (media) {
|
||
for (const sourceAsset of sourceAssets) {
|
||
await createMediaAssetRelation({
|
||
userId: params.userId,
|
||
fromAssetId: sourceAsset.id,
|
||
toAssetId: media.id,
|
||
relationType: "edited_from",
|
||
metadata: {
|
||
prompt: "去水印处理",
|
||
},
|
||
});
|
||
}
|
||
}
|
||
} catch (assetError) {
|
||
console.error("[WatermarkRemove] MediaAsset 注册失败:", assetError);
|
||
}
|
||
}
|
||
|
||
return {
|
||
success: true,
|
||
original_url: uploadResult.url,
|
||
thumbnail_url: uploadResult.url,
|
||
processing_time:
|
||
typeof params.startedAt === "number" ? (Date.now() - params.startedAt) / 1000 : undefined,
|
||
};
|
||
} catch (uploadError) {
|
||
console.error("[WatermarkRemove] 上传结果失败，回退原始URL:", uploadError);
|
||
return {
|
||
success: true,
|
||
original_url: params.processedImageUrl,
|
||
thumbnail_url: params.processedImageUrl,
|
||
processing_time:
|
||
typeof params.startedAt === "number" ? (Date.now() - params.startedAt) / 1000 : undefined,
|
||
};
|
||
}
|
||
}
|
||
|
||
function shouldUseFalWatermarkFallback(status: number, detail: string) {
|
||
return (
|
||
status === 401 ||
|
||
status === 402 ||
|
||
status === 403 ||
|
||
status === 429 ||
|
||
status >= 500 ||
|
||
/quota|credit|balance|exceed|expired|invalid|unauthor/i.test(detail)
|
||
);
|
||
}
|
||
|
||
async function removeWatermarkWithFal(params: {
|
||
imageUrl: string;
|
||
userId: string;
|
||
startedAt: number;
|
||
sourceImageUrls?: string[];
|
||
}) {
|
||
console.warn("[WatermarkRemove] AOS unavailable; using FAL Nano Banana 2 edit fallback");
|
||
const result = await generateCanvasImage({
|
||
prompt: [
|
||
"仅移除图片中后期叠加的水印、平台角标和覆盖式文字标记。",
|
||
"必须完整保留原图主体、商品、背景、构图、尺寸、颜色、光影和清晰度。",
|
||
"用周围真实纹理自然补全被遮挡区域，不得新增文字、标志或其他物体。",
|
||
].join(""),
|
||
model: FAL_NANO_BANANA_2_EDIT_MODEL_ID,
|
||
aspectRatio: "auto",
|
||
imageSize: "2K",
|
||
imageCount: 1,
|
||
referenceImages: [params.imageUrl],
|
||
allowFailover: false,
|
||
debugLabel: "watermark-remove-fal-fallback",
|
||
});
|
||
const processedImageUrl = result.images[0]?.originalUrl;
|
||
if (!processedImageUrl) {
|
||
throw new Error("FAL 去水印未返回可用图片");
|
||
}
|
||
return persistWatermarkResult({
|
||
processedImageUrl,
|
||
userId: params.userId,
|
||
startedAt: params.startedAt,
|
||
sourceImageUrls: params.sourceImageUrls,
|
||
});
|
||
}
|
||
|
||
async function finalizeWatermarkTaskResult(params: {
|
||
taskId: string;
|
||
userId: string;
|
||
startedAt?: number;
|
||
apiKey: string;
|
||
sourceImageUrls?: string[];
|
||
}): Promise<{
|
||
success: boolean;
|
||
original_url: string;
|
||
thumbnail_url: string;
|
||
processing_time?: number;
|
||
}> {
|
||
const pollResult = await pollForResult(params.taskId, params.apiKey, WATERMARK_SYNC_WAIT_TIMEOUT_MS);
|
||
if (pollResult.pending) {
|
||
throw new Error("WATERMARK_TASK_PENDING");
|
||
}
|
||
if (!pollResult.success || !pollResult.imageUrl) {
|
||
throw new Error(pollResult.error || "去水印处理失败");
|
||
}
|
||
return persistWatermarkResult({
|
||
processedImageUrl: pollResult.imageUrl,
|
||
userId: params.userId,
|
||
startedAt: params.startedAt,
|
||
sourceImageUrls: params.sourceImageUrls,
|
||
});
|
||
}
|
||
|
||
export async function GET(request: NextRequest) {
|
||
try {
|
||
const session = await auth();
|
||
if (!session?.user?.id) {
|
||
return NextResponse.json({ error: "请先登录" }, { status: 401 });
|
||
}
|
||
|
||
const { searchParams } = new URL(request.url);
|
||
const taskId = String(searchParams.get("taskId") || "").trim();
|
||
if (!taskId) {
|
||
return NextResponse.json({ error: "缺少 taskId 参数" }, { status: 400 });
|
||
}
|
||
|
||
const config = await getWatermarkRemoveConfig();
|
||
if (!config?.apiKey) {
|
||
return NextResponse.json(
|
||
{ error: "去水印服务未配置，请联系管理员在系统设置中配置API密钥" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
|
||
try {
|
||
const result = await finalizeWatermarkTaskResult({
|
||
taskId,
|
||
userId: session.user.id,
|
||
apiKey: config.apiKey,
|
||
});
|
||
return NextResponse.json(result);
|
||
} catch (error) {
|
||
if (error instanceof Error && error.message === "WATERMARK_TASK_PENDING") {
|
||
return buildWatermarkTaskPendingResponse(taskId);
|
||
}
|
||
throw error;
|
||
}
|
||
} catch (error) {
|
||
console.error("[WatermarkRemove][TaskStatus] 处理错误:", error);
|
||
return NextResponse.json(
|
||
{ error: error instanceof Error ? error.message : "去水印处理失败" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
export async function POST(request: NextRequest) {
|
||
try {
|
||
// 验证用户登录
|
||
const session = await auth();
|
||
if (!session?.user?.id) {
|
||
return NextResponse.json({ error: "请先登录" }, { status: 401 });
|
||
}
|
||
|
||
const startTime = Date.now();
|
||
|
||
// 获取请求参数
|
||
const body = await request.json();
|
||
const { image_url } = body;
|
||
|
||
if (!image_url) {
|
||
return NextResponse.json(
|
||
{ error: "请提供图片URL" },
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
|
||
// 获取API配置
|
||
const config = await getWatermarkRemoveConfig();
|
||
console.log("[WatermarkRemove] 使用原图URL:", image_url.substring(0, 100) + "...");
|
||
|
||
// 处理图片URL，确保获取公网可访问的URL
|
||
let publicImageUrl: string;
|
||
|
||
// 如果是 base64 格式的 data URL，先上传到 S3
|
||
if (image_url.startsWith("data:")) {
|
||
console.log("[WatermarkRemove] 检测到base64格式，上传到S3...");
|
||
try {
|
||
// 避免对超长 base64 使用正则，直接按 data URL 头部拆分
|
||
const commaIndex = image_url.indexOf(",");
|
||
if (commaIndex <= 0) {
|
||
return NextResponse.json(
|
||
{ error: "无效的图片格式" },
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
const header = image_url.slice(0, commaIndex);
|
||
const base64Data = image_url.slice(commaIndex + 1);
|
||
const headerMatch = header.match(/^data:image\/([a-zA-Z0-9.+-]+);base64$/i);
|
||
if (!headerMatch || !base64Data) {
|
||
return NextResponse.json(
|
||
{ error: "无效的图片格式" },
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
const ext = headerMatch[1].toLowerCase() === "jpeg" ? "jpg" : headerMatch[1].toLowerCase();
|
||
const buffer = Buffer.from(base64Data, "base64");
|
||
|
||
// 上传到 S3
|
||
const filename = `watermark-input-${Date.now()}.${ext}`;
|
||
const uploadResult = await uploadFile(filename, buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
|
||
publicImageUrl = uploadResult.url;
|
||
console.log("[WatermarkRemove] base64图片已上传到S3:", publicImageUrl);
|
||
} catch (uploadError) {
|
||
console.error("[WatermarkRemove] base64上传失败:", uploadError);
|
||
return NextResponse.json(
|
||
{ error: "图片上传失败" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
// 如果是 HTTP/HTTPS URL，下载后重新上传确保公网可访问
|
||
else if (image_url.startsWith("http://") || image_url.startsWith("https://")) {
|
||
try {
|
||
console.log("[WatermarkRemove] 下载原图并上传到S3...");
|
||
const imageResponse = await fetch(image_url);
|
||
if (!imageResponse.ok) {
|
||
throw new Error("下载原图失败");
|
||
}
|
||
const imageBuffer = await imageResponse.arrayBuffer();
|
||
const filename = `watermark-input-${Date.now()}.jpg`;
|
||
const uploadResult = await uploadFile(filename, imageBuffer);
|
||
publicImageUrl = uploadResult.url;
|
||
console.log("[WatermarkRemove] 图片已上传到S3:", publicImageUrl);
|
||
} catch (downloadError) {
|
||
console.error("[WatermarkRemove] 下载/上传原图失败:", downloadError);
|
||
// 如果下载失败，尝试使用原始URL
|
||
console.log("[WatermarkRemove] 尝试使用原始URL");
|
||
publicImageUrl = image_url;
|
||
}
|
||
} else {
|
||
return NextResponse.json(
|
||
{ error: "图片URL格式无效" },
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
|
||
console.log("[WatermarkRemove] 开始处理图片:", publicImageUrl);
|
||
|
||
const pointsConfig = await getPointsSystemConfig();
|
||
const pointsCharge = await prepareFeaturePointsCharge({
|
||
userId: session.user.id,
|
||
unitCost: getImageToolCreditCost(pointsConfig, "watermark-remove"),
|
||
reason: "image_watermark_remove",
|
||
modelId: "watermark-remove",
|
||
note: "去水印消耗积分",
|
||
pointsConfig,
|
||
});
|
||
if (!pointsCharge.ok) {
|
||
return NextResponse.json(pointsCharge.payload, { status: pointsCharge.status });
|
||
}
|
||
|
||
const sourceImageUrls =
|
||
typeof image_url === "string" && /^https?:\/\//i.test(image_url)
|
||
? [image_url]
|
||
: undefined;
|
||
|
||
if (!config?.apiKey) {
|
||
const fallbackResult = await removeWatermarkWithFal({
|
||
imageUrl: publicImageUrl,
|
||
userId: session.user.id,
|
||
startedAt: startTime,
|
||
sourceImageUrls,
|
||
});
|
||
if (pointsCharge.chargeable) {
|
||
await pointsCharge.consume({ note: "FAL 去水印备用链路消耗积分" });
|
||
}
|
||
return NextResponse.json(fallbackResult);
|
||
}
|
||
|
||
// 创建去水印任务
|
||
const formData = new FormData();
|
||
formData.append("sync", "0");
|
||
formData.append("url", publicImageUrl);
|
||
|
||
const createResponse = await fetch(
|
||
"https://techsz.aoscdn.com/api/tasks/visual/external/watermark-remove",
|
||
{
|
||
method: "POST",
|
||
headers: {
|
||
"X-API-KEY": config.apiKey,
|
||
},
|
||
body: formData,
|
||
}
|
||
);
|
||
|
||
if (!createResponse.ok) {
|
||
const errorText = await createResponse.text();
|
||
console.error("[WatermarkRemove] 创建任务失败:", errorText);
|
||
if (shouldUseFalWatermarkFallback(createResponse.status, errorText)) {
|
||
try {
|
||
const fallbackResult = await removeWatermarkWithFal({
|
||
imageUrl: publicImageUrl,
|
||
userId: session.user.id,
|
||
startedAt: startTime,
|
||
sourceImageUrls,
|
||
});
|
||
if (pointsCharge.chargeable) {
|
||
await pointsCharge.consume({ note: "FAL 去水印备用链路消耗积分" });
|
||
}
|
||
return NextResponse.json(fallbackResult);
|
||
} catch (fallbackError) {
|
||
console.error("[WatermarkRemove] FAL 备用链路失败:", fallbackError);
|
||
}
|
||
}
|
||
return NextResponse.json(
|
||
{ error: "去水印服务暂时不可用，请稍后重试" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
|
||
const createResult = await createResponse.json();
|
||
console.log("[WatermarkRemove] 创建任务结果:", JSON.stringify(createResult).substring(0, 200));
|
||
|
||
const taskId = createResult.data?.task_id;
|
||
if (!taskId) {
|
||
return NextResponse.json(
|
||
{ error: "未获取到任务ID" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
|
||
if (pointsCharge.chargeable) {
|
||
try {
|
||
await pointsCharge.consume({
|
||
note: `去水印任务消耗积分（${taskId}）`,
|
||
});
|
||
} catch (pointsError) {
|
||
console.error("[Points] Failed to consume watermark remove points:", pointsError);
|
||
}
|
||
}
|
||
|
||
try {
|
||
const result = await finalizeWatermarkTaskResult({
|
||
taskId,
|
||
userId: session.user.id,
|
||
startedAt: startTime,
|
||
apiKey: config.apiKey,
|
||
sourceImageUrls,
|
||
});
|
||
return NextResponse.json(result);
|
||
} catch (error) {
|
||
if (error instanceof Error && error.message === "WATERMARK_TASK_PENDING") {
|
||
return buildWatermarkTaskPendingResponse(taskId);
|
||
}
|
||
throw error;
|
||
}
|
||
} catch (error) {
|
||
console.error("[WatermarkRemove] 处理错误:", error);
|
||
return NextResponse.json(
|
||
{ error: error instanceof Error ? error.message : "去水印处理失败" },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|