750 lines
19 KiB
TypeScript
750 lines
19 KiB
TypeScript
// server/utils/imageGenerationRecords.ts - 生图相关数据库操作：用户快照、批次记录、图片子记录、历史查询和统计。
|
|
import type { IUserBasicData } from "#shared/types";
|
|
import type {
|
|
IImageGenerationStatsData,
|
|
IImageHistoryDetail,
|
|
IImageHistoryImageItem,
|
|
IImageHistoryItem,
|
|
IImageHistoryListData
|
|
} from "#shared/types/openai";
|
|
import { consola } from "consola";
|
|
import {
|
|
ImageArchiveStatus,
|
|
ImageGenerationStatus,
|
|
PlazaPostStatus,
|
|
Prisma
|
|
} from "~~/app/generated/prisma/client";
|
|
import { prisma } from "~~/server/utils/prisma";
|
|
|
|
const GLOBAL_STATS_ID = "global";
|
|
const DEFAULT_IMAGE_MODEL = "gpt-image-2";
|
|
|
|
interface IFinishImageGenerationImageSuccessInput {
|
|
/** NewAPI 上游返回的生成图片 URL */
|
|
imageUrl: string;
|
|
/** 上游返回的修订提示词，流式生图通常为空 */
|
|
revisedPrompt?: string | null;
|
|
/** 完整上游响应，仅服务端内部保存 */
|
|
upstreamResponse: unknown;
|
|
}
|
|
|
|
interface IFinishImageGenerationImageArchiveSuccessInput {
|
|
/** Lsky 图床归档后的图片 URL */
|
|
hostedImageUrl: string;
|
|
/** 图片 MIME 类型，优先来自图床上传结果 */
|
|
imageMimeType: string | null;
|
|
/** 完整 Lsky 上传响应 */
|
|
hostedResponse: unknown;
|
|
}
|
|
|
|
export interface IImageArchiveTask {
|
|
/** 生图图片子记录 ID */
|
|
imageId: bigint;
|
|
/** 所属生图批次记录 ID */
|
|
recordId: bigint;
|
|
/** NewAPI 用户 ID */
|
|
userId: number;
|
|
/** 上游生成图片 URL */
|
|
imageUrl: string;
|
|
/** 图片子记录创建时间，用于构造图床文件名 */
|
|
createdAt: Date;
|
|
/** 当前这次归档是第几次尝试 */
|
|
archiveAttempts: number;
|
|
}
|
|
|
|
/** 登录或恢复登录时保存 NewAPI 用户快照 */
|
|
export const upsertUserSnapshot = (user: IUserBasicData) => {
|
|
return prisma.user.upsert({
|
|
where: {
|
|
id: user.id
|
|
},
|
|
create: {
|
|
id: user.id,
|
|
username: user.username,
|
|
displayName: user.display_name,
|
|
group: user.group,
|
|
role: user.role,
|
|
status: user.status
|
|
},
|
|
update: {
|
|
username: user.username,
|
|
displayName: user.display_name,
|
|
group: user.group,
|
|
role: user.role,
|
|
status: user.status
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 仅有 userId 时兜底创建用户记录，避免旧 cookie 用户生成时外键失败 */
|
|
export const ensureUserRecord = (userId: number) => {
|
|
return prisma.user.upsert({
|
|
where: {
|
|
id: userId
|
|
},
|
|
create: {
|
|
id: userId
|
|
},
|
|
update: {}
|
|
});
|
|
};
|
|
|
|
/** 读取用于 Lsky 文件命名的用户标识，缺失时由调用方使用兜底名 */
|
|
export const getUserArchiveIdentity = async (userId: number) => {
|
|
const user = await prisma.user.findUnique({
|
|
where: {
|
|
id: userId
|
|
},
|
|
select: {
|
|
username: true,
|
|
displayName: true
|
|
}
|
|
});
|
|
|
|
return {
|
|
username: user?.username || user?.displayName || "user"
|
|
};
|
|
};
|
|
|
|
/** 创建进行中的生图批次和图片子记录，并递增全局请求/进行中统计 */
|
|
export const createRunningImageGeneration = async (
|
|
userId: number,
|
|
prompt: string,
|
|
batchSize: number
|
|
) => {
|
|
await ensureUserRecord(userId);
|
|
|
|
const record = await prisma.imageGeneration.create({
|
|
data: {
|
|
userId,
|
|
prompt,
|
|
status: ImageGenerationStatus.RUNNING,
|
|
model: DEFAULT_IMAGE_MODEL,
|
|
batchSize,
|
|
images: {
|
|
create: Array.from({ length: batchSize }, (_, index) => ({
|
|
userId,
|
|
index,
|
|
status: ImageGenerationStatus.RUNNING
|
|
}))
|
|
}
|
|
},
|
|
include: {
|
|
images: {
|
|
orderBy: {
|
|
index: "asc"
|
|
},
|
|
select: {
|
|
id: true,
|
|
index: true
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
await safeUpsertGenerationStats({
|
|
totalRequests: {
|
|
increment: 1
|
|
},
|
|
runningRequests: {
|
|
increment: 1
|
|
}
|
|
});
|
|
|
|
return record;
|
|
};
|
|
|
|
/** 将单张图片子记录标记为成功，并先写入上游结果；图床字段稍后由后台归档补写 */
|
|
export const finishImageGenerationImageSuccess = async (
|
|
imageId: bigint,
|
|
input: IFinishImageGenerationImageSuccessInput
|
|
) => {
|
|
await prisma.imageGenerationImage.update({
|
|
where: {
|
|
id: imageId
|
|
},
|
|
data: {
|
|
status: ImageGenerationStatus.SUCCEEDED,
|
|
imageUrl: input.imageUrl,
|
|
hostedImageUrl: null,
|
|
imageMimeType: null,
|
|
revisedPrompt: input.revisedPrompt || null,
|
|
upstreamResponse: input.upstreamResponse as Prisma.InputJsonValue,
|
|
hostedResponse: Prisma.DbNull,
|
|
errorMessage: null,
|
|
archiveStatus: ImageArchiveStatus.PENDING,
|
|
archiveAttempts: 0,
|
|
archiveNextRunAt: new Date(),
|
|
archiveLockedAt: null,
|
|
archiveLockedBy: null,
|
|
archiveLastError: null
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 将单张图片子记录标记为失败，只保留服务端可排查摘要 */
|
|
export const finishImageGenerationImageFailed = async (
|
|
imageId: bigint,
|
|
error: unknown
|
|
) => {
|
|
await prisma.imageGenerationImage.update({
|
|
where: {
|
|
id: imageId
|
|
},
|
|
data: {
|
|
status: ImageGenerationStatus.FAILED,
|
|
errorMessage: getSafeErrorMessage(error),
|
|
archiveStatus: ImageArchiveStatus.NOT_REQUIRED
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 批次内所有图片都结束后，汇总批次状态与全局统计 */
|
|
export const finishImageGenerationBatch = async ({
|
|
recordId,
|
|
startedAt,
|
|
successCount,
|
|
failedCount,
|
|
error
|
|
}: {
|
|
recordId: bigint;
|
|
startedAt: Date;
|
|
successCount: number;
|
|
failedCount: number;
|
|
error?: unknown;
|
|
}) => {
|
|
const endedAt = new Date();
|
|
const hasSuccess = successCount > 0;
|
|
|
|
await prisma.imageGeneration.update({
|
|
where: {
|
|
id: recordId
|
|
},
|
|
data: {
|
|
status: hasSuccess
|
|
? ImageGenerationStatus.SUCCEEDED
|
|
: ImageGenerationStatus.FAILED,
|
|
endedAt,
|
|
durationMs: getDurationMs(startedAt, endedAt),
|
|
successCount,
|
|
failedCount,
|
|
errorMessage: hasSuccess ? null : getSafeErrorMessage(error)
|
|
}
|
|
});
|
|
|
|
await safeUpsertGenerationStats({
|
|
successRequests: hasSuccess
|
|
? {
|
|
increment: 1
|
|
}
|
|
: undefined,
|
|
failedRequests: hasSuccess
|
|
? undefined
|
|
: {
|
|
increment: 1
|
|
},
|
|
runningRequests: {
|
|
decrement: 1
|
|
},
|
|
totalImages:
|
|
successCount > 0
|
|
? {
|
|
increment: successCount
|
|
}
|
|
: undefined
|
|
});
|
|
};
|
|
|
|
/** 兼容旧调用：主链路异常且尚未逐图结算时，把整个批次标记为失败 */
|
|
export const finishImageGenerationFailed = async (
|
|
recordId: bigint,
|
|
startedAt: Date,
|
|
error: unknown
|
|
) => {
|
|
const record = await prisma.imageGeneration.findUnique({
|
|
where: {
|
|
id: recordId
|
|
},
|
|
select: {
|
|
batchSize: true
|
|
}
|
|
});
|
|
|
|
await prisma.imageGenerationImage.updateMany({
|
|
where: {
|
|
imageGenerationId: recordId,
|
|
status: ImageGenerationStatus.RUNNING
|
|
},
|
|
data: {
|
|
status: ImageGenerationStatus.FAILED,
|
|
errorMessage: getSafeErrorMessage(error),
|
|
archiveStatus: ImageArchiveStatus.NOT_REQUIRED
|
|
}
|
|
});
|
|
|
|
await finishImageGenerationBatch({
|
|
recordId,
|
|
startedAt,
|
|
successCount: 0,
|
|
failedCount: record?.batchSize ?? 1,
|
|
error
|
|
});
|
|
};
|
|
|
|
/** 领取可执行的图床归档任务；通过 updateMany 条件锁避免多实例重复处理 */
|
|
export const claimRunnableImageArchiveTasks = async ({
|
|
limit,
|
|
workerId,
|
|
lockTtlMs
|
|
}: {
|
|
limit: number;
|
|
workerId: string;
|
|
lockTtlMs: number;
|
|
}): Promise<IImageArchiveTask[]> => {
|
|
if (limit <= 0) return [];
|
|
|
|
const now = new Date();
|
|
const staleBefore = new Date(now.getTime() - lockTtlMs);
|
|
const runnableWhere = buildRunnableArchiveWhere(now, staleBefore);
|
|
const candidates = await prisma.imageGenerationImage.findMany({
|
|
where: runnableWhere,
|
|
select: {
|
|
id: true
|
|
},
|
|
orderBy: [
|
|
{
|
|
archiveNextRunAt: "asc"
|
|
},
|
|
{
|
|
createdAt: "asc"
|
|
}
|
|
],
|
|
take: limit * 3
|
|
});
|
|
const tasks: IImageArchiveTask[] = [];
|
|
|
|
for (const candidate of candidates) {
|
|
if (tasks.length >= limit) break;
|
|
|
|
const claimed = await prisma.imageGenerationImage.updateMany({
|
|
where: {
|
|
id: candidate.id,
|
|
...runnableWhere
|
|
},
|
|
data: {
|
|
archiveStatus: ImageArchiveStatus.RUNNING,
|
|
archiveAttempts: {
|
|
increment: 1
|
|
},
|
|
archiveLockedAt: now,
|
|
archiveLockedBy: workerId,
|
|
archiveLastError: null
|
|
}
|
|
});
|
|
|
|
if (claimed.count !== 1) continue;
|
|
|
|
const task = await prisma.imageGenerationImage.findUnique({
|
|
where: {
|
|
id: candidate.id
|
|
},
|
|
select: {
|
|
id: true,
|
|
imageGenerationId: true,
|
|
userId: true,
|
|
imageUrl: true,
|
|
createdAt: true,
|
|
archiveAttempts: true
|
|
}
|
|
});
|
|
|
|
if (task?.imageUrl) {
|
|
tasks.push({
|
|
imageId: task.id,
|
|
recordId: task.imageGenerationId,
|
|
userId: task.userId,
|
|
imageUrl: task.imageUrl,
|
|
createdAt: task.createdAt,
|
|
archiveAttempts: task.archiveAttempts
|
|
});
|
|
}
|
|
}
|
|
|
|
return tasks;
|
|
};
|
|
|
|
/** 后台归档成功后回写图床地址、MIME 和图床响应 */
|
|
export const finishImageGenerationArchiveSuccess = async (
|
|
imageId: bigint,
|
|
input: IFinishImageGenerationImageArchiveSuccessInput
|
|
) => {
|
|
await prisma.imageGenerationImage.update({
|
|
where: {
|
|
id: imageId
|
|
},
|
|
data: {
|
|
hostedImageUrl: input.hostedImageUrl,
|
|
imageMimeType: input.imageMimeType,
|
|
hostedResponse: input.hostedResponse as Prisma.InputJsonValue,
|
|
errorMessage: null,
|
|
archiveStatus: ImageArchiveStatus.SUCCEEDED,
|
|
archiveNextRunAt: null,
|
|
archiveLockedAt: null,
|
|
archiveLockedBy: null,
|
|
archiveLastError: null
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 归档可重试失败时释放任务锁并安排下一次执行，前端仍显示归档中 */
|
|
export const scheduleImageGenerationArchiveRetry = async ({
|
|
imageId,
|
|
nextRunAt,
|
|
errorMessage
|
|
}: {
|
|
imageId: bigint;
|
|
nextRunAt: Date;
|
|
errorMessage: string;
|
|
}) => {
|
|
await prisma.imageGenerationImage.update({
|
|
where: {
|
|
id: imageId
|
|
},
|
|
data: {
|
|
archiveStatus: ImageArchiveStatus.PENDING,
|
|
archiveNextRunAt: nextRunAt,
|
|
archiveLockedAt: null,
|
|
archiveLockedBy: null,
|
|
archiveLastError: errorMessage,
|
|
errorMessage: null
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 后台归档最终失败时仅补写本地错误文案，不影响已成功的生图状态 */
|
|
export const finishImageGenerationArchiveFailed = async (
|
|
imageId: bigint,
|
|
errorMessage: string = "图片归档失败"
|
|
) => {
|
|
await prisma.imageGenerationImage.update({
|
|
where: {
|
|
id: imageId
|
|
},
|
|
data: {
|
|
archiveStatus: ImageArchiveStatus.FAILED,
|
|
archiveNextRunAt: null,
|
|
archiveLockedAt: null,
|
|
archiveLockedBy: null,
|
|
archiveLastError: errorMessage,
|
|
errorMessage: "图片归档失败"
|
|
}
|
|
});
|
|
};
|
|
|
|
/** 查询当前用户未删除的生图批次历史列表，不返回完整上游/图床响应 */
|
|
export const listImageGenerationHistory = async ({
|
|
userId,
|
|
page,
|
|
pageSize
|
|
}: {
|
|
userId: number;
|
|
page: number;
|
|
pageSize: number;
|
|
}): Promise<IImageHistoryListData> => {
|
|
const where = {
|
|
userId,
|
|
deletedAt: null
|
|
};
|
|
|
|
const [total, records] = await Promise.all([
|
|
prisma.imageGeneration.count({ where }),
|
|
prisma.imageGeneration.findMany({
|
|
where,
|
|
include: historyInclude,
|
|
orderBy: {
|
|
createdAt: "desc"
|
|
},
|
|
skip: (page - 1) * pageSize,
|
|
take: pageSize
|
|
})
|
|
]);
|
|
|
|
return {
|
|
page,
|
|
pageSize,
|
|
total,
|
|
items: records.map(mapImageGenerationItem)
|
|
};
|
|
};
|
|
|
|
/** 查询当前用户单条生图批次详情，内部响应字段固定隐藏为 null */
|
|
export const getImageGenerationDetail = async (
|
|
userId: number,
|
|
recordId: bigint
|
|
): Promise<IImageHistoryDetail | null> => {
|
|
const record = await prisma.imageGeneration.findFirst({
|
|
where: {
|
|
id: recordId,
|
|
userId,
|
|
deletedAt: null
|
|
},
|
|
include: historyInclude
|
|
});
|
|
|
|
if (!record) return null;
|
|
|
|
return mapImageGenerationItem(record);
|
|
};
|
|
|
|
/** 软删除当前用户单条生图批次历史 */
|
|
export const softDeleteImageGeneration = async (
|
|
userId: number,
|
|
recordId: bigint
|
|
): Promise<boolean> => {
|
|
const result = await prisma.imageGeneration.updateMany({
|
|
where: {
|
|
id: recordId,
|
|
userId,
|
|
deletedAt: null
|
|
},
|
|
data: {
|
|
deletedAt: new Date()
|
|
}
|
|
});
|
|
|
|
return result.count > 0;
|
|
};
|
|
|
|
/** 读取全局生图统计，没有记录时返回全 0 */
|
|
export const getGenerationStats =
|
|
async (): Promise<IImageGenerationStatsData> => {
|
|
const stats = await prisma.generationStats.findUnique({
|
|
where: {
|
|
id: GLOBAL_STATS_ID
|
|
}
|
|
});
|
|
|
|
return {
|
|
totalRequests: stats?.totalRequests ?? 0,
|
|
successRequests: stats?.successRequests ?? 0,
|
|
failedRequests: stats?.failedRequests ?? 0,
|
|
queuedRequests: stats?.queuedRequests ?? 0,
|
|
runningRequests: stats?.runningRequests ?? 0,
|
|
totalImages: stats?.totalImages ?? 0
|
|
};
|
|
};
|
|
|
|
/** 统一创建或更新全局统计行 */
|
|
const upsertGenerationStats = (update: Prisma.GenerationStatsUpdateInput) => {
|
|
return prisma.generationStats.upsert({
|
|
where: {
|
|
id: GLOBAL_STATS_ID
|
|
},
|
|
create: {
|
|
id: GLOBAL_STATS_ID,
|
|
...buildStatsCreateInput(update)
|
|
},
|
|
update
|
|
});
|
|
};
|
|
|
|
/** 更新统计失败不能影响主链路，避免统计表问题导致生图接口失败 */
|
|
const safeUpsertGenerationStats = async (
|
|
update: Prisma.GenerationStatsUpdateInput
|
|
) => {
|
|
const cleanUpdate = Object.fromEntries(
|
|
Object.entries(update).filter(([, value]) => value !== undefined)
|
|
) as Prisma.GenerationStatsUpdateInput;
|
|
|
|
try {
|
|
await upsertGenerationStats(cleanUpdate);
|
|
} catch (error) {
|
|
consola.error("[imageGenerationRecords] 更新生图统计失败", {
|
|
message: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
};
|
|
|
|
/** upsert 创建统计行时，把本次 increment 转换为初始计数 */
|
|
const buildStatsCreateInput = (update: Prisma.GenerationStatsUpdateInput) => {
|
|
return {
|
|
totalRequests: getIncrementValue(update.totalRequests),
|
|
successRequests: getIncrementValue(update.successRequests),
|
|
failedRequests: getIncrementValue(update.failedRequests),
|
|
queuedRequests: getIncrementValue(update.queuedRequests),
|
|
runningRequests: getIncrementValue(update.runningRequests),
|
|
totalImages: getIncrementValue(update.totalImages)
|
|
};
|
|
};
|
|
|
|
/** 只领取成功生成、所属批次未删除、已到执行时间或锁超时的归档任务 */
|
|
const buildRunnableArchiveWhere = (now: Date, staleBefore: Date) => {
|
|
return {
|
|
status: ImageGenerationStatus.SUCCEEDED,
|
|
imageUrl: {
|
|
not: null
|
|
},
|
|
imageGeneration: {
|
|
deletedAt: null
|
|
},
|
|
OR: [
|
|
{
|
|
archiveStatus: ImageArchiveStatus.PENDING,
|
|
OR: [
|
|
{
|
|
archiveNextRunAt: null
|
|
},
|
|
{
|
|
archiveNextRunAt: {
|
|
lte: now
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
archiveStatus: ImageArchiveStatus.RUNNING,
|
|
archiveLockedAt: {
|
|
lt: staleBefore
|
|
}
|
|
}
|
|
]
|
|
} satisfies Prisma.ImageGenerationImageWhereInput;
|
|
};
|
|
|
|
/** 从 Prisma increment 操作里取出增量；非 increment 操作在创建时按 0 处理 */
|
|
const getIncrementValue = (value: unknown): number => {
|
|
if (
|
|
value &&
|
|
typeof value === "object" &&
|
|
"increment" in value &&
|
|
typeof value.increment === "number"
|
|
) {
|
|
return value.increment;
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
const historyInclude = {
|
|
images: {
|
|
orderBy: {
|
|
index: "asc" as const
|
|
}
|
|
},
|
|
plazaPost: {
|
|
select: {
|
|
status: true,
|
|
coverImageId: true,
|
|
images: {
|
|
select: {
|
|
imageGenerationImageId: true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
type ImageGenerationWithHistory = Prisma.ImageGenerationGetPayload<{
|
|
include: typeof historyInclude;
|
|
}>;
|
|
|
|
/** 将 Prisma 批次记录转换为前端类型，BigInt/Date 在这里统一序列化 */
|
|
const mapImageGenerationItem = (
|
|
record: ImageGenerationWithHistory
|
|
): IImageHistoryItem => {
|
|
const images = record.images.map((image) =>
|
|
mapImageGenerationImageItem(image, record.plazaPost)
|
|
);
|
|
const publicImageIds = getPublicImageIds(record.plazaPost);
|
|
|
|
return {
|
|
id: record.id.toString(),
|
|
userId: record.userId,
|
|
prompt: record.prompt,
|
|
status: record.status,
|
|
model: record.model,
|
|
batchSize: record.batchSize,
|
|
successCount: record.successCount,
|
|
failedCount: record.failedCount,
|
|
startedAt: record.startedAt.toISOString(),
|
|
endedAt: record.endedAt?.toISOString() ?? null,
|
|
durationMs: record.durationMs,
|
|
errorMessage: getPublicBatchMessage(record.status, record.errorMessage),
|
|
isPublic:
|
|
record.plazaPost?.status === PlazaPostStatus.PUBLIC &&
|
|
publicImageIds.size > 0,
|
|
coverImageId: record.plazaPost?.coverImageId?.toString() ?? null,
|
|
images,
|
|
createdAt: record.createdAt.toISOString()
|
|
};
|
|
};
|
|
|
|
const mapImageGenerationImageItem = (
|
|
image: ImageGenerationWithHistory["images"][number],
|
|
plazaPost: ImageGenerationWithHistory["plazaPost"]
|
|
): IImageHistoryImageItem => {
|
|
const publicImageIds = getPublicImageIds(plazaPost);
|
|
|
|
return {
|
|
id: image.id.toString(),
|
|
index: image.index,
|
|
status: image.status,
|
|
imageUrl: image.imageUrl,
|
|
hostedImageUrl: image.hostedImageUrl,
|
|
imageMimeType: image.imageMimeType,
|
|
revisedPrompt: image.revisedPrompt,
|
|
errorMessage: getPublicImageMessage(image.status, image.errorMessage),
|
|
isPublic:
|
|
plazaPost?.status === PlazaPostStatus.PUBLIC && publicImageIds.has(image.id),
|
|
isCover:
|
|
plazaPost?.status === PlazaPostStatus.PUBLIC &&
|
|
plazaPost.coverImageId === image.id,
|
|
createdAt: image.createdAt.toISOString()
|
|
};
|
|
};
|
|
|
|
/** 展示图优先使用公开封面，其次使用第一张成功图，再兜底第一张子记录 */
|
|
const getPublicImageIds = (
|
|
plazaPost: ImageGenerationWithHistory["plazaPost"]
|
|
): Set<bigint> => {
|
|
if (!plazaPost || plazaPost.status !== PlazaPostStatus.PUBLIC) {
|
|
return new Set();
|
|
}
|
|
|
|
return new Set(
|
|
plazaPost.images.map((image) => image.imageGenerationImageId)
|
|
);
|
|
};
|
|
|
|
/** 计算耗时并兜底为非负数，避免系统时间抖动导致负值 */
|
|
const getDurationMs = (startedAt: Date, endedAt: Date) => {
|
|
return Math.max(0, endedAt.getTime() - startedAt.getTime());
|
|
};
|
|
|
|
/** 保存到数据库的错误信息只保留可读摘要，不保存复杂错误对象 */
|
|
const getSafeErrorMessage = (error: unknown): string => {
|
|
if (error instanceof Error) return error.message;
|
|
if (typeof error === "string") return error;
|
|
return "图片生成失败";
|
|
};
|
|
|
|
/** 批次错误返回本地泛化文案，具体内部错误留在数据库和服务端日志 */
|
|
const getPublicBatchMessage = (
|
|
status: ImageGenerationStatus,
|
|
errorMessage: string | null
|
|
): string | null => {
|
|
if (!errorMessage) return null;
|
|
return status === ImageGenerationStatus.FAILED ? "图片生成失败" : null;
|
|
};
|
|
|
|
/** 图片错误返回本地泛化文案，归档失败和生成失败分开表达 */
|
|
const getPublicImageMessage = (
|
|
status: ImageGenerationStatus,
|
|
errorMessage: string | null
|
|
): string | null => {
|
|
if (!errorMessage) return null;
|
|
return status === ImageGenerationStatus.SUCCEEDED
|
|
? "图片归档失败"
|
|
: "图片生成失败";
|
|
};
|