494 lines
15 KiB
TypeScript
494 lines
15 KiB
TypeScript
import { NextRequest, NextResponse } from "next/server";
|
||
import { db } from "@/lib/db";
|
||
import { generatedImage, user, aiModel, aiProvider } from "@/lib/db/schema";
|
||
import { eq, sql, desc, and, gte, lt } from "drizzle-orm";
|
||
import { auth } from "@/app/(auth)/auth";
|
||
|
||
type RuntimeModelRegistryRow = {
|
||
id: string;
|
||
modelId: string;
|
||
displayName: string;
|
||
providerName: string | null;
|
||
providerType: string | null;
|
||
isEnabled: boolean;
|
||
isHidden: boolean;
|
||
isDefault: boolean;
|
||
isSubModel: boolean;
|
||
sortOrder: number;
|
||
updatedAt: Date;
|
||
createdAt: Date;
|
||
};
|
||
|
||
type RuntimeModelMeta = {
|
||
canonicalModelId: string | null;
|
||
modelName: string | null;
|
||
providerName: string | null;
|
||
providerType: string | null;
|
||
};
|
||
|
||
const ANALYTICS_SIZE_BUCKETS = ["4K", "3K", "2K", "1K"] as const;
|
||
|
||
function normalizeAnalyticsImageSizeBucket(value: string | null | undefined) {
|
||
const normalized = String(value || "")
|
||
.trim()
|
||
.toUpperCase();
|
||
|
||
if (!normalized) return "2K";
|
||
if (normalized.includes("4K")) return "4K";
|
||
if (normalized.includes("3K")) return "3K";
|
||
if (normalized.includes("2K")) return "2K";
|
||
if (normalized.includes("1K")) return "1K";
|
||
|
||
const sizeMatch = normalized.match(/(\d+(?:\.\d+)?)\s*K/);
|
||
if (sizeMatch) {
|
||
const sizeValue = Number(sizeMatch[1]);
|
||
if (sizeValue >= 3.5) return "4K";
|
||
if (sizeValue >= 2.5) return "3K";
|
||
if (sizeValue >= 1.5) return "2K";
|
||
return "1K";
|
||
}
|
||
|
||
const dimensionMatch = normalized.match(/(\d{3,5})\s*[X×*]\s*(\d{3,5})/);
|
||
if (dimensionMatch) {
|
||
const maxEdge = Math.max(
|
||
Number(dimensionMatch[1]),
|
||
Number(dimensionMatch[2])
|
||
);
|
||
if (maxEdge >= 3500) return "4K";
|
||
if (maxEdge >= 2500) return "3K";
|
||
if (maxEdge >= 1500) return "2K";
|
||
return "1K";
|
||
}
|
||
|
||
const numericMatch = normalized.match(/(\d{3,5})/);
|
||
if (numericMatch) {
|
||
const numericValue = Number(numericMatch[1]);
|
||
if (numericValue >= 3500) return "4K";
|
||
if (numericValue >= 2500) return "3K";
|
||
if (numericValue >= 1500) return "2K";
|
||
}
|
||
|
||
return "1K";
|
||
}
|
||
|
||
function scoreRuntimeModelCandidate(row: RuntimeModelRegistryRow) {
|
||
return (
|
||
(row.isEnabled ? 100 : 0) +
|
||
(!row.isHidden ? 20 : 0) +
|
||
(!row.isSubModel ? 10 : 0) +
|
||
(row.isDefault ? 8 : 0) +
|
||
Math.max(0, 1000 - row.sortOrder) +
|
||
(row.updatedAt?.getTime() || row.createdAt?.getTime() || 0) / 1_000_000_000_000
|
||
);
|
||
}
|
||
|
||
function buildRuntimeModelRegistry(rows: RuntimeModelRegistryRow[]) {
|
||
const registry = new Map<string, RuntimeModelMeta & { score: number }>();
|
||
|
||
for (const row of rows) {
|
||
const score = scoreRuntimeModelCandidate(row);
|
||
const meta = {
|
||
score,
|
||
canonicalModelId: row.modelId,
|
||
modelName: row.displayName || null,
|
||
providerName: row.providerName || null,
|
||
providerType: row.providerType || null,
|
||
};
|
||
|
||
for (const key of [row.id, row.modelId]) {
|
||
const current = registry.get(key);
|
||
if (current && current.score >= score) continue;
|
||
registry.set(key, meta);
|
||
}
|
||
}
|
||
|
||
return registry;
|
||
}
|
||
|
||
function resolveRuntimeModelMeta(
|
||
registry: Map<string, RuntimeModelMeta & { score: number }>,
|
||
modelId: string | null
|
||
): RuntimeModelMeta {
|
||
if (!modelId) {
|
||
return {
|
||
canonicalModelId: null,
|
||
modelName: null,
|
||
providerName: null,
|
||
providerType: null,
|
||
};
|
||
}
|
||
|
||
const resolved = registry.get(modelId);
|
||
return {
|
||
canonicalModelId: resolved?.canonicalModelId || null,
|
||
modelName: resolved?.modelName || null,
|
||
providerName: resolved?.providerName || null,
|
||
providerType: resolved?.providerType || null,
|
||
};
|
||
}
|
||
|
||
function buildCanonicalModelUsage(
|
||
rows: Array<{ modelId: string | null; userId: string; count: number }>,
|
||
registry: Map<string, RuntimeModelMeta & { score: number }>
|
||
) {
|
||
const usageMap = new Map<
|
||
string,
|
||
RuntimeModelMeta & {
|
||
modelId: string | null;
|
||
count: number;
|
||
userIds: Set<string>;
|
||
}
|
||
>();
|
||
|
||
for (const row of rows) {
|
||
const meta = resolveRuntimeModelMeta(registry, row.modelId);
|
||
const canonicalModelId = meta.canonicalModelId || row.modelId;
|
||
const key = canonicalModelId || row.modelId || "__unknown__";
|
||
const current = usageMap.get(key) || {
|
||
modelId: canonicalModelId,
|
||
canonicalModelId,
|
||
modelName: meta.modelName,
|
||
providerName: meta.providerName,
|
||
providerType: meta.providerType,
|
||
count: 0,
|
||
userIds: new Set<string>(),
|
||
};
|
||
|
||
current.count += row.count;
|
||
current.userIds.add(row.userId);
|
||
if (!current.modelName && meta.modelName) current.modelName = meta.modelName;
|
||
if (!current.providerName && meta.providerName) {
|
||
current.providerName = meta.providerName;
|
||
}
|
||
if (!current.providerType && meta.providerType) {
|
||
current.providerType = meta.providerType;
|
||
}
|
||
usageMap.set(key, current);
|
||
}
|
||
|
||
return Array.from(usageMap.values())
|
||
.map(({ userIds, canonicalModelId, ...item }) => ({
|
||
...item,
|
||
modelId: item.modelId || canonicalModelId,
|
||
userCount: userIds.size,
|
||
}))
|
||
.sort((left, right) => right.count - left.count);
|
||
}
|
||
|
||
function buildCanonicalModelTrend(
|
||
rows: Array<{ date: string; modelId: string | null; count: number }>,
|
||
registry: Map<string, RuntimeModelMeta & { score: number }>
|
||
) {
|
||
const trendMap = new Map<
|
||
string,
|
||
RuntimeModelMeta & {
|
||
date: string;
|
||
modelId: string | null;
|
||
count: number;
|
||
}
|
||
>();
|
||
|
||
for (const row of rows) {
|
||
const meta = resolveRuntimeModelMeta(registry, row.modelId);
|
||
const canonicalModelId = meta.canonicalModelId || row.modelId;
|
||
const key = `${row.date}::${canonicalModelId || row.modelId || "__unknown__"}`;
|
||
const current = trendMap.get(key) || {
|
||
date: row.date,
|
||
modelId: canonicalModelId,
|
||
canonicalModelId,
|
||
modelName: meta.modelName,
|
||
providerName: meta.providerName,
|
||
providerType: meta.providerType,
|
||
count: 0,
|
||
};
|
||
|
||
current.count += row.count;
|
||
if (!current.modelName && meta.modelName) current.modelName = meta.modelName;
|
||
if (!current.providerName && meta.providerName) {
|
||
current.providerName = meta.providerName;
|
||
}
|
||
if (!current.providerType && meta.providerType) {
|
||
current.providerType = meta.providerType;
|
||
}
|
||
trendMap.set(key, current);
|
||
}
|
||
|
||
return Array.from(trendMap.values())
|
||
.map(({ canonicalModelId, ...item }) => ({
|
||
...item,
|
||
modelId: item.modelId || canonicalModelId,
|
||
}))
|
||
.sort(
|
||
(left, right) =>
|
||
left.date.localeCompare(right.date) || right.count - left.count
|
||
);
|
||
}
|
||
|
||
export async function GET(request: NextRequest) {
|
||
try {
|
||
const session = await auth();
|
||
|
||
if (!session?.user?.id) {
|
||
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
|
||
}
|
||
|
||
// 检查是否为管理员
|
||
const currentUser = await db.query.user.findFirst({
|
||
where: eq(user.id, session.user.id),
|
||
});
|
||
|
||
if (currentUser?.role !== "admin") {
|
||
return NextResponse.json({ error: "Forbidden" }, { status: 403 });
|
||
}
|
||
|
||
// 获取查询参数
|
||
const searchParams = request.nextUrl.searchParams;
|
||
const month = searchParams.get("month"); // 格式: YYYY-MM
|
||
const selectedDate = searchParams.get("date"); // 格式: YYYY-MM-DD，用于高峰时段筛选
|
||
|
||
// 1. 总体统计
|
||
const totalStats = await db
|
||
.select({
|
||
totalImages: sql<number>`count(*)::int`,
|
||
totalUsers: sql<number>`count(distinct ${generatedImage.userId})::int`,
|
||
})
|
||
.from(generatedImage);
|
||
|
||
// 2. 按用户统计（Top 20）
|
||
const userStats = await db
|
||
.select({
|
||
userId: generatedImage.userId,
|
||
userName: user.name,
|
||
userEmail: user.email,
|
||
imageCount: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.leftJoin(user, eq(generatedImage.userId, user.id))
|
||
.groupBy(generatedImage.userId, user.name, user.email)
|
||
.orderBy(desc(sql`count(*)`))
|
||
.limit(20);
|
||
|
||
// 3. 按日期统计（最近30天）
|
||
const dailyStats = await db
|
||
.select({
|
||
date: sql<string>`date(${generatedImage.createdAt})::text`,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(sql`${generatedImage.createdAt} >= now() - interval '30 days'`)
|
||
.groupBy(sql`date(${generatedImage.createdAt})`)
|
||
.orderBy(sql`date(${generatedImage.createdAt})`);
|
||
|
||
// 4. 按图片尺寸统计
|
||
const rawSizeStats = await db
|
||
.select({
|
||
imageSize: generatedImage.imageSize,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.groupBy(generatedImage.imageSize)
|
||
.orderBy(desc(sql`count(*)`));
|
||
const sizeBucketMap = new Map<string, number>();
|
||
for (const stat of rawSizeStats) {
|
||
const bucket = normalizeAnalyticsImageSizeBucket(stat.imageSize);
|
||
sizeBucketMap.set(bucket, (sizeBucketMap.get(bucket) || 0) + stat.count);
|
||
}
|
||
const sizeStats = ANALYTICS_SIZE_BUCKETS.map((bucket) => ({
|
||
imageSize: bucket,
|
||
count: sizeBucketMap.get(bucket) || 0,
|
||
}));
|
||
|
||
const runtimeModelRows = await db
|
||
.select({
|
||
id: aiModel.id,
|
||
modelId: aiModel.modelId,
|
||
displayName: aiModel.displayName,
|
||
providerName: aiProvider.name,
|
||
providerType: aiProvider.type,
|
||
isEnabled: aiModel.isEnabled,
|
||
isHidden: aiModel.isHidden,
|
||
isDefault: aiModel.isDefault,
|
||
isSubModel: aiModel.isSubModel,
|
||
sortOrder: aiModel.sortOrder,
|
||
updatedAt: aiModel.updatedAt,
|
||
createdAt: aiModel.createdAt,
|
||
})
|
||
.from(aiModel)
|
||
.leftJoin(aiProvider, eq(aiModel.providerId, aiProvider.id));
|
||
|
||
const runtimeModelRegistry = buildRuntimeModelRegistry(runtimeModelRows);
|
||
|
||
// 5. 按模型统计
|
||
const rawModelUsageRows = await db
|
||
.select({
|
||
modelId: generatedImage.modelId,
|
||
userId: generatedImage.userId,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.groupBy(generatedImage.modelId, generatedImage.userId);
|
||
|
||
const canonicalModelStats = buildCanonicalModelUsage(
|
||
rawModelUsageRows,
|
||
runtimeModelRegistry
|
||
);
|
||
|
||
const modelStats = canonicalModelStats.slice(0, 10).map((stat) => ({
|
||
modelId: stat.modelId,
|
||
count: stat.count,
|
||
}));
|
||
|
||
const modelDetailStats = canonicalModelStats.slice(0, 20).map((stat) => ({
|
||
modelId: stat.modelId,
|
||
count: stat.count,
|
||
userCount: stat.userCount,
|
||
modelName: stat.modelName,
|
||
providerName: stat.providerName,
|
||
providerType: stat.providerType,
|
||
}));
|
||
|
||
// 5.2 按提供商类型统计
|
||
const providerTypeStatsMap = new Map<
|
||
string,
|
||
{
|
||
providerType: string | null;
|
||
providerName: string | null;
|
||
count: number;
|
||
}
|
||
>();
|
||
for (const stat of canonicalModelStats) {
|
||
const key = `${stat.providerType || "unknown"}::${stat.providerName || "unknown"}`;
|
||
const current = providerTypeStatsMap.get(key) || {
|
||
providerType: stat.providerType,
|
||
providerName: stat.providerName,
|
||
count: 0,
|
||
};
|
||
current.count += stat.count;
|
||
providerTypeStatsMap.set(key, current);
|
||
}
|
||
const providerTypeStats = Array.from(providerTypeStatsMap.values()).sort(
|
||
(left, right) => right.count - left.count
|
||
);
|
||
|
||
// 5.3 模型使用趋势（最近7天，按模型分组）
|
||
const rawModelTrendStats = await db
|
||
.select({
|
||
date: sql<string>`date(${generatedImage.createdAt})::text`,
|
||
modelId: generatedImage.modelId,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(sql`${generatedImage.createdAt} >= now() - interval '7 days'`)
|
||
.groupBy(sql`date(${generatedImage.createdAt})`, generatedImage.modelId)
|
||
.orderBy(sql`date(${generatedImage.createdAt})`);
|
||
const modelTrendStats = buildCanonicalModelTrend(
|
||
rawModelTrendStats,
|
||
runtimeModelRegistry
|
||
);
|
||
|
||
// 6. 按月份统计
|
||
const monthlyStats = await db
|
||
.select({
|
||
month: sql<string>`to_char(${generatedImage.createdAt}, 'YYYY-MM')`,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.groupBy(sql`to_char(${generatedImage.createdAt}, 'YYYY-MM')`)
|
||
.orderBy(sql`to_char(${generatedImage.createdAt}, 'YYYY-MM')`);
|
||
|
||
// 7. 按小时统计（用于分析高峰时段，支持按日期筛选）
|
||
let hourlyWhereClause = undefined;
|
||
if (selectedDate) {
|
||
const dateStart = new Date(selectedDate);
|
||
const dateEnd = new Date(selectedDate);
|
||
dateEnd.setDate(dateEnd.getDate() + 1);
|
||
hourlyWhereClause = and(
|
||
gte(generatedImage.createdAt, dateStart),
|
||
lt(generatedImage.createdAt, dateEnd)
|
||
);
|
||
}
|
||
|
||
const hourlyStats = await db
|
||
.select({
|
||
hour: sql<number>`extract(hour from ${generatedImage.createdAt})::int`,
|
||
count: sql<number>`count(*)::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(hourlyWhereClause)
|
||
.groupBy(sql`extract(hour from ${generatedImage.createdAt})`)
|
||
.orderBy(sql`extract(hour from ${generatedImage.createdAt})`);
|
||
|
||
// 8. 今日统计
|
||
const todayStats = await db
|
||
.select({
|
||
count: sql<number>`count(*)::int`,
|
||
users: sql<number>`count(distinct ${generatedImage.userId})::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(sql`date(${generatedImage.createdAt}) = current_date`);
|
||
|
||
// 9. 本周统计
|
||
const weekStats = await db
|
||
.select({
|
||
count: sql<number>`count(*)::int`,
|
||
users: sql<number>`count(distinct ${generatedImage.userId})::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(sql`${generatedImage.createdAt} >= date_trunc('week', current_date)`);
|
||
|
||
// 10. 指定月份统计（支持选择月份）
|
||
let monthStart: Date;
|
||
let monthEnd: Date;
|
||
|
||
if (month) {
|
||
// 解析指定月份
|
||
const [year, mon] = month.split("-").map(Number);
|
||
monthStart = new Date(year, mon - 1, 1);
|
||
monthEnd = new Date(year, mon, 1); // 下个月第一天
|
||
} else {
|
||
// 默认当前月
|
||
const now = new Date();
|
||
monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
|
||
monthEnd = new Date(now.getFullYear(), now.getMonth() + 1, 1);
|
||
}
|
||
|
||
const monthStats = await db
|
||
.select({
|
||
count: sql<number>`count(*)::int`,
|
||
users: sql<number>`count(distinct ${generatedImage.userId})::int`,
|
||
})
|
||
.from(generatedImage)
|
||
.where(and(
|
||
gte(generatedImage.createdAt, monthStart),
|
||
lt(generatedImage.createdAt, monthEnd)
|
||
));
|
||
|
||
return NextResponse.json({
|
||
overview: {
|
||
totalImages: totalStats[0]?.totalImages || 0,
|
||
totalUsers: totalStats[0]?.totalUsers || 0,
|
||
todayImages: todayStats[0]?.count || 0,
|
||
todayUsers: todayStats[0]?.users || 0,
|
||
weekImages: weekStats[0]?.count || 0,
|
||
weekUsers: weekStats[0]?.users || 0,
|
||
monthImages: monthStats[0]?.count || 0,
|
||
monthUsers: monthStats[0]?.users || 0,
|
||
selectedMonth: month || `${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, "0")}`,
|
||
selectedDate: selectedDate || null,
|
||
},
|
||
userStats,
|
||
dailyStats,
|
||
sizeStats,
|
||
modelStats,
|
||
modelDetailStats,
|
||
providerTypeStats,
|
||
modelTrendStats,
|
||
monthlyStats,
|
||
hourlyStats,
|
||
});
|
||
} catch (error) {
|
||
console.error("[Admin Images Analytics API] Error:", error);
|
||
return NextResponse.json({ error: "Failed to fetch analytics" }, { status: 500 });
|
||
}
|
||
}
|