371 lines
10 KiB
TypeScript
371 lines
10 KiB
TypeScript
import { withAdmin } from "@/lib/api-handler";
|
|
import { apiError } from "@/lib/api-response";
|
|
import { PERMS } from "@/lib/permissions";
|
|
import { logAudit } from "@/lib/services/audit";
|
|
import { getSource } from "@/lib/services/clone-sources";
|
|
import {
|
|
appendFurniEntriesBatch,
|
|
rebuildCatalogOfferIds,
|
|
reconcileFurniDataWithItemsBase,
|
|
verifyAndFixSpriteIds,
|
|
} from "@/lib/services/furni-data";
|
|
import { buildLocalizedFurniDataFiles } from "@/lib/services/furni-data-i18n";
|
|
import {
|
|
ensureDirectories,
|
|
ensureFurniOwnership,
|
|
fixDatabaseConsistencyAfterImport,
|
|
importSingleFurni,
|
|
reconcileImportedOfferIds,
|
|
syncAssetsToGamedataBundle,
|
|
verifyAndFixInteractionModesCount,
|
|
} from "@/lib/services/furni-import";
|
|
import { rcon } from "@/lib/services/rcon";
|
|
import type { ImportSingleResult } from "@/types/furni";
|
|
|
|
interface BatchItem {
|
|
id: number;
|
|
classname: string;
|
|
name: string;
|
|
description: string;
|
|
type: string;
|
|
revision: number;
|
|
category: string;
|
|
}
|
|
|
|
/**
|
|
* SSE batch import endpoint.
|
|
* Processes multiple furniture items with configurable concurrency,
|
|
* streaming real-time progress events to the client.
|
|
*/
|
|
export const POST = withAdmin(
|
|
{ permission: PERMS.ASSETS_IMPORT },
|
|
async (request, ctx) => {
|
|
const body = await request.json();
|
|
const rawItems: BatchItem[] = body.items || [];
|
|
const concurrency = Math.min(Math.max(body.concurrency || 1, 1), 3);
|
|
const sourceId: string | undefined = body.sourceId;
|
|
|
|
if (rawItems.length === 0) return apiError("No items to import", 400);
|
|
|
|
// Look up clone source for SWF/nitro/icon URL fallbacks
|
|
let source: Awaited<ReturnType<typeof getSource>> | null = null;
|
|
if (sourceId) {
|
|
source = await getSource(sourceId);
|
|
}
|
|
|
|
// Deduplicate by (spriteId, classname) to avoid concurrent INSERT races on
|
|
// items_base.id when the same item is listed twice in the request body.
|
|
const seen = new Set<string>();
|
|
const items: BatchItem[] = [];
|
|
for (const it of rawItems) {
|
|
const key = `${it.id}:${it.classname}`;
|
|
if (seen.has(key)) continue;
|
|
seen.add(key);
|
|
items.push(it);
|
|
}
|
|
|
|
await ensureDirectories();
|
|
const encoder = new TextEncoder();
|
|
|
|
// Wire client disconnect to abort controller so we stop processing
|
|
// when the user navigates away or closes the browser.
|
|
const abortController = new AbortController();
|
|
let aborted = false;
|
|
request.signal.addEventListener("abort", () => {
|
|
aborted = true;
|
|
abortController.abort();
|
|
});
|
|
|
|
const stream = new ReadableStream({
|
|
async start(controller) {
|
|
const send = (data: unknown) => {
|
|
if (aborted) return;
|
|
try {
|
|
controller.enqueue(
|
|
encoder.encode(`data: ${JSON.stringify(data)}\n\n`),
|
|
);
|
|
} catch {
|
|
/* stream closed by client */
|
|
}
|
|
};
|
|
|
|
const startTime = Date.now();
|
|
send({ type: "batch_start", total: items.length, concurrency });
|
|
|
|
let succeeded = 0;
|
|
let failed = 0;
|
|
let withWarnings = 0;
|
|
const furniDataEntries: Array<{
|
|
entry: Record<string, unknown>;
|
|
itemType: string;
|
|
}> = [];
|
|
|
|
// Process in chunks of `concurrency`
|
|
for (let i = 0; i < items.length; i += concurrency) {
|
|
if (aborted) break;
|
|
|
|
const chunk = items.slice(i, i + concurrency);
|
|
|
|
const promises = chunk.map(async (item, chunkIdx) => {
|
|
const index = i + chunkIdx;
|
|
send({
|
|
type: "item_progress",
|
|
classname: item.classname,
|
|
status: "started",
|
|
index,
|
|
});
|
|
|
|
try {
|
|
const result: ImportSingleResult = await importSingleFurni({
|
|
id: item.id ?? 0,
|
|
classname: item.classname,
|
|
name: item.name,
|
|
description: item.description ?? "",
|
|
type: item.type ?? "flooritem",
|
|
revision: item.revision ?? 0,
|
|
category: item.category ?? "unknown",
|
|
skipFurniDataWrite: false,
|
|
repairExisting: body.repairExisting === true,
|
|
sourceSwfBaseUrl: source?.sourceSwfBaseUrl,
|
|
nitroBaseUrl: source?.nitroBaseUrl,
|
|
iconBaseUrl: source?.iconBaseUrl,
|
|
onProgress: (status: string) => {
|
|
send({
|
|
type: "item_progress",
|
|
classname: item.classname,
|
|
status,
|
|
index,
|
|
});
|
|
},
|
|
});
|
|
|
|
if (result.ok) {
|
|
succeeded++;
|
|
if (result.warnings.length > 0) withWarnings++;
|
|
if (result.furniDataEntry)
|
|
furniDataEntries.push(result.furniDataEntry);
|
|
|
|
send({
|
|
type: "item_progress",
|
|
classname: item.classname,
|
|
status: "done",
|
|
index,
|
|
itemId: result.itemId,
|
|
warnings:
|
|
result.warnings.length > 0 ? result.warnings : undefined,
|
|
});
|
|
|
|
logAudit({
|
|
userId: ctx.session.user.id,
|
|
action: "furni_import",
|
|
target: "ItemsBase",
|
|
targetId: result.itemId ?? 0,
|
|
after: {
|
|
classname: item.classname,
|
|
name: item.name,
|
|
type: item.type === "wallitem" ? "i" : "s",
|
|
catalogItemId: result.catalogItemId,
|
|
dimensions: result.dimensions,
|
|
batch: true,
|
|
},
|
|
});
|
|
} else {
|
|
failed++;
|
|
send({
|
|
type: "item_progress",
|
|
classname: item.classname,
|
|
status: "failed",
|
|
index,
|
|
message: result.error,
|
|
});
|
|
}
|
|
} catch (err) {
|
|
failed++;
|
|
send({
|
|
type: "item_progress",
|
|
classname: item.classname,
|
|
status: "failed",
|
|
index,
|
|
message: (err as Error).message,
|
|
});
|
|
}
|
|
});
|
|
|
|
await Promise.allSettled(promises);
|
|
await new Promise((r) => setImmediate(r));
|
|
}
|
|
|
|
if (aborted) {
|
|
send({
|
|
type: "batch_complete",
|
|
succeeded,
|
|
failed,
|
|
warnings: withWarnings,
|
|
aborted: true,
|
|
duration: Date.now() - startTime,
|
|
});
|
|
controller.close();
|
|
return;
|
|
}
|
|
|
|
// Post-import steps: send progress so the user knows what's happening
|
|
send({ type: "post_import", status: "Writing FurnitureData.json..." });
|
|
|
|
// Batch write FurnitureData.json once at the end — BEFORE RCON so the
|
|
// emulator never sees items that the Nitro client can't render.
|
|
let furniDataWriteOk = true;
|
|
if (furniDataEntries.length > 0) {
|
|
try {
|
|
await appendFurniEntriesBatch(furniDataEntries);
|
|
} catch (err) {
|
|
furniDataWriteOk = false;
|
|
send({
|
|
type: "item_progress",
|
|
classname: "_batch_",
|
|
status: "failed",
|
|
index: -1,
|
|
message: `FurnitureData.json batch write failed: ${(err as Error).message}`,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Refresh game server caches once — skip if FurnitureData write failed
|
|
if (furniDataWriteOk && !aborted) {
|
|
send({
|
|
type: "post_import",
|
|
status: "Refreshing emulator caches...",
|
|
});
|
|
try {
|
|
const okCat = await rcon.updateCatalog();
|
|
const okItems = await rcon.updateItems();
|
|
if (!okCat || !okItems) {
|
|
send({
|
|
type: "item_progress",
|
|
classname: "_rcon_",
|
|
status: "failed",
|
|
index: -1,
|
|
message: "RCON refresh failed — emulator cache may be stale",
|
|
});
|
|
}
|
|
} catch (err) {
|
|
console.warn(
|
|
"[import-furni] RCON update failed after batch:",
|
|
(err as Error).message,
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!aborted) {
|
|
send({
|
|
type: "post_import",
|
|
status: "Reconciling offer IDs & ownership...",
|
|
});
|
|
|
|
// Post-import reconciliation — wrapped in try/catch so one
|
|
// failure doesn't block the rest.
|
|
let offerIdsFixed = 0;
|
|
let ownershipFixed: string[] = [];
|
|
let nitrosSynced: string[] = [];
|
|
let iconsSynced: string[] = [];
|
|
let furniDataFixedIds = 0;
|
|
let furniDataFixedOfferIds = 0;
|
|
let furniDataMissing = 0;
|
|
let furniDataConflicts = 0;
|
|
let offerRebuildFixed = 0;
|
|
let spriteFixed = 0;
|
|
let interactionFixed = 0;
|
|
let languages: Awaited<
|
|
ReturnType<typeof buildLocalizedFurniDataFiles>
|
|
> = [];
|
|
try {
|
|
offerIdsFixed = (await reconcileImportedOfferIds()).fixed;
|
|
ownershipFixed = (await ensureFurniOwnership()).fixed;
|
|
const assetsSynced = await syncAssetsToGamedataBundle();
|
|
nitrosSynced = assetsSynced.copiedNitros;
|
|
iconsSynced = assetsSynced.copiedIcons;
|
|
const furniReconcile = await reconcileFurniDataWithItemsBase();
|
|
furniDataFixedIds = furniReconcile.fixedIds;
|
|
furniDataFixedOfferIds = furniReconcile.fixedOfferIds;
|
|
furniDataMissing = furniReconcile.missing;
|
|
furniDataConflicts = furniReconcile.conflicts;
|
|
offerRebuildFixed = (await rebuildCatalogOfferIds()).fixed;
|
|
spriteFixed = (await verifyAndFixSpriteIds()).fixed;
|
|
|
|
if (!aborted) {
|
|
send({
|
|
type: "post_import",
|
|
status: "Verifying interaction modes...",
|
|
});
|
|
interactionFixed = (await verifyAndFixInteractionModesCount())
|
|
.fixed;
|
|
}
|
|
|
|
try {
|
|
languages = await buildLocalizedFurniDataFiles();
|
|
} catch (err) {
|
|
console.warn(
|
|
"[import-furni] Localized furnidata build failed:",
|
|
(err as Error).message,
|
|
);
|
|
}
|
|
} catch (err) {
|
|
console.warn(
|
|
"[import-furni] Post-import reconcile/ownership failed:",
|
|
(err as Error).message,
|
|
);
|
|
}
|
|
|
|
send({
|
|
type: "post_import",
|
|
status: "Fixing database consistency...",
|
|
});
|
|
const { catalogNameFixed, haveOfferFixed, costCreditsFixed } =
|
|
await fixDatabaseConsistencyAfterImport();
|
|
|
|
send({
|
|
type: "batch_complete",
|
|
succeeded,
|
|
failed,
|
|
warnings: withWarnings,
|
|
offerIdsFixed,
|
|
ownershipFixed,
|
|
nitrosSynced,
|
|
iconsSynced,
|
|
furniDataFixedIds,
|
|
furniDataFixedOfferIds,
|
|
furniDataMissing,
|
|
furniDataConflicts,
|
|
offerRebuildFixed,
|
|
spriteFixed,
|
|
interactionFixed,
|
|
catalogNameFixed,
|
|
haveOfferFixed,
|
|
costCreditsFixed,
|
|
languages,
|
|
duration: Date.now() - startTime,
|
|
});
|
|
} else {
|
|
send({
|
|
type: "batch_complete",
|
|
succeeded,
|
|
failed,
|
|
warnings: withWarnings,
|
|
aborted: true,
|
|
duration: Date.now() - startTime,
|
|
});
|
|
}
|
|
|
|
controller.close();
|
|
},
|
|
});
|
|
|
|
return new Response(stream, {
|
|
headers: {
|
|
"Content-Type": "text/event-stream",
|
|
"Cache-Control": "no-cache",
|
|
Connection: "keep-alive",
|
|
},
|
|
});
|
|
},
|
|
);
|