335 lines
9.6 KiB
TypeScript
335 lines
9.6 KiB
TypeScript
import { promises as fs } from "node:fs";
|
|
import { asc, sql } from "drizzle-orm";
|
|
import { numericValue } from "@/features/catalog/domain/offer-input";
|
|
import { CatalogPages, db } from "@/lib/db";
|
|
import { getFurnitureDataPath } from "@/lib/services/furni-data";
|
|
import { getHabboGamedataHotel } from "@/lib/services/habbo-gamedata-hotel";
|
|
|
|
// Cache FurnitureData.json in memory with TTL to avoid repeated disk I/O
|
|
let furniDataCache: {
|
|
roomitemtypes?: {
|
|
furnitype?: Array<{
|
|
id: number;
|
|
description?: string;
|
|
classname?: string;
|
|
revision?: number;
|
|
}>;
|
|
};
|
|
wallitemtypes?: {
|
|
furnitype?: Array<{
|
|
id: number;
|
|
description?: string;
|
|
classname?: string;
|
|
revision?: number;
|
|
}>;
|
|
};
|
|
} | null = null;
|
|
let furniDataCacheTime = 0;
|
|
const FURNI_CACHE_TTL = 30_000; // 30 seconds
|
|
|
|
async function getFurnitureData() {
|
|
if (furniDataCache && Date.now() - furniDataCacheTime < FURNI_CACHE_TTL)
|
|
return furniDataCache;
|
|
const furniDataPath = await getFurnitureDataPath();
|
|
try {
|
|
const raw = await fs.readFile(furniDataPath, "utf-8");
|
|
furniDataCache = JSON.parse(raw);
|
|
furniDataCacheTime = Date.now();
|
|
return furniDataCache;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/** Invalidate the FurnitureData cache after writes */
|
|
export function invalidateFurniDataCache() {
|
|
furniDataCache = null;
|
|
furniDataCacheTime = 0;
|
|
}
|
|
|
|
interface RawItem {
|
|
id: number;
|
|
itemIds: string;
|
|
pageId: number;
|
|
offerId: number;
|
|
songId: number;
|
|
orderNumber: number;
|
|
catalogName: string;
|
|
costCredits: number;
|
|
costPoints: number;
|
|
pointsType: number;
|
|
amount: number;
|
|
limitedSells: number;
|
|
limitedStack: number;
|
|
extradata: string;
|
|
haveOffer: string;
|
|
clubOnly: string;
|
|
}
|
|
|
|
interface BaseItem {
|
|
id: number;
|
|
spriteId: number;
|
|
publicName: string;
|
|
itemName: string;
|
|
type: string;
|
|
width: number;
|
|
length: number;
|
|
stackHeight: number;
|
|
allowStack: number;
|
|
allowSit: number;
|
|
allowLay: number;
|
|
allowWalk: number;
|
|
allowGift: number;
|
|
allowTrade: number;
|
|
allowRecycle: number;
|
|
allowMarketplaceSell: number;
|
|
allowInventoryStack: number;
|
|
interactionType: string;
|
|
interactionModesCount: number;
|
|
vendingIds: string;
|
|
customparams: string;
|
|
effectIdMale: number;
|
|
effectIdFemale: number;
|
|
clothingOnWalk: string;
|
|
}
|
|
|
|
export interface CatalogItemEnriched {
|
|
id: number;
|
|
catalogName: string;
|
|
itemIds: string;
|
|
costCredits: number;
|
|
costPoints: number;
|
|
pointsType: number;
|
|
amount: number;
|
|
limitedSells: number;
|
|
limitedStack: number;
|
|
orderNumber: number;
|
|
offerId: number;
|
|
songId: number;
|
|
haveOffer: string;
|
|
clubOnly: string;
|
|
extradata: string;
|
|
baseName: string;
|
|
baseItemName: string;
|
|
spriteId: number;
|
|
baseItem: BaseItem | null;
|
|
}
|
|
|
|
export interface CatalogItemsData {
|
|
items: CatalogItemEnriched[];
|
|
baseItems: {
|
|
id: number;
|
|
publicName: string;
|
|
itemName: string;
|
|
spriteId: number;
|
|
type: string;
|
|
}[];
|
|
catalogNameMap: Record<number, string>;
|
|
furniDataIdList: number[];
|
|
furniDescriptionMap: Record<number, string>;
|
|
furniRevisionMap: Record<number, { classname: string; revision: number }>;
|
|
interactionTypes: string[];
|
|
allPages: { id: number; caption: string }[];
|
|
/** CMS `habbo_gamedata_hotel` — locale used for Suggest names */
|
|
gamedataHotel: string;
|
|
}
|
|
|
|
export async function loadCatalogItemsData(
|
|
pageId: number,
|
|
): Promise<CatalogItemsData> {
|
|
// Load items via raw query to work around pageId Int vs VARCHAR mismatch
|
|
const pageIdStr = String(pageId);
|
|
// CAST: live Habbo DBs often store page_id as VARCHAR while schema maps Int.
|
|
const [rawItems] = (await db.execute(sql`
|
|
SELECT * FROM catalog_items
|
|
WHERE CAST(page_id AS CHAR) = ${pageIdStr}
|
|
ORDER BY order_number ASC, id ASC
|
|
`)) as unknown as [Record<string, unknown>[], unknown[]];
|
|
const items: RawItem[] = rawItems.map((r: Record<string, unknown>) => ({
|
|
id: Number(r.id),
|
|
itemIds: String(r.item_ids ?? ""),
|
|
pageId: numericValue(r.page_id, 0),
|
|
offerId: numericValue(r.offer_id, -1),
|
|
songId: numericValue(r.song_id, 0),
|
|
orderNumber: numericValue(r.order_number, 99),
|
|
catalogName: String(r.catalog_name ?? ""),
|
|
costCredits: numericValue(r.cost_credits, 0),
|
|
costPoints: numericValue(r.cost_points, 0),
|
|
pointsType: numericValue(r.points_type, 0),
|
|
amount: numericValue(r.amount, 1),
|
|
limitedSells: numericValue(r.limited_sells, 0),
|
|
limitedStack: numericValue(r.limited_stack, 0),
|
|
extradata: String(r.extradata ?? ""),
|
|
haveOffer: String(r.have_offer ?? "1"),
|
|
clubOnly: String(r.club_only ?? "0"),
|
|
}));
|
|
|
|
const [allPages, interactionTypesRaw, gamedataHotel] = await Promise.all([
|
|
db
|
|
.select({ id: CatalogPages.id, caption: CatalogPages.caption })
|
|
.from(CatalogPages)
|
|
.orderBy(asc(CatalogPages.caption)),
|
|
db
|
|
.execute(sql`
|
|
SELECT DISTINCT interaction_type FROM items_base ORDER BY interaction_type ASC
|
|
`)
|
|
.then(
|
|
(result) =>
|
|
(result as unknown as [{ interaction_type: string }[], unknown[]])[0],
|
|
),
|
|
getHabboGamedataHotel(),
|
|
]);
|
|
|
|
const interactionTypes = interactionTypesRaw.map((r) =>
|
|
String(r.interaction_type),
|
|
);
|
|
|
|
// Resolve item names from items_base for enrichment + translate
|
|
const itemIdStrings = items.map((i) => i.itemIds).filter(Boolean);
|
|
const baseItemIds = [
|
|
...new Set(
|
|
itemIdStrings.flatMap((s) =>
|
|
s
|
|
.split(";")
|
|
.map(Number)
|
|
.filter((n) => n > 0),
|
|
),
|
|
),
|
|
];
|
|
|
|
// Raw query to work around ENUM('0','1') columns returning numeric values.
|
|
// baseItemIds is built from numeric splits + filter(n > 0); joined via sql.join.
|
|
const [baseItemRows] =
|
|
baseItemIds.length > 0
|
|
? ((await db.execute(sql`
|
|
SELECT id, sprite_id, public_name, item_name, type, width, length,
|
|
stack_height, allow_stack, allow_sit, allow_lay, allow_walk,
|
|
allow_gift, allow_trade, allow_recycle, allow_marketplace_sell,
|
|
allow_inventory_stack, interaction_type, interaction_modes_count,
|
|
vending_ids, customparams, effect_id_male, effect_id_female,
|
|
clothing_on_walk
|
|
FROM items_base WHERE id IN (${sql.join(baseItemIds, sql`, `)})
|
|
`)) as unknown as [Record<string, unknown>[], unknown[]])
|
|
: [[], []];
|
|
|
|
const baseItems: BaseItem[] = baseItemRows.map((r) => ({
|
|
id: Number(r.id),
|
|
spriteId: Number(r.sprite_id),
|
|
publicName: String(r.public_name ?? ""),
|
|
itemName: String(r.item_name ?? ""),
|
|
type: String(r.type ?? "s"),
|
|
width: numericValue(r.width, 1),
|
|
length: numericValue(r.length, 1),
|
|
stackHeight: numericValue(r.stack_height, 0),
|
|
allowStack: Number(r.allow_stack ?? 0),
|
|
allowSit: Number(r.allow_sit ?? 0),
|
|
allowLay: Number(r.allow_lay ?? 0),
|
|
allowWalk: Number(r.allow_walk ?? 0),
|
|
allowGift: Number(r.allow_gift ?? 1),
|
|
allowTrade: Number(r.allow_trade ?? 1),
|
|
allowRecycle: Number(r.allow_recycle ?? 0),
|
|
allowMarketplaceSell: Number(r.allow_marketplace_sell ?? 0),
|
|
allowInventoryStack: Number(r.allow_inventory_stack ?? 1),
|
|
interactionType: String(r.interaction_type ?? "default"),
|
|
interactionModesCount: numericValue(r.interaction_modes_count, 2),
|
|
vendingIds: String(r.vending_ids ?? "0"),
|
|
customparams: String(r.customparams ?? ""),
|
|
effectIdMale: numericValue(r.effect_id_male, 0),
|
|
effectIdFemale: numericValue(r.effect_id_female, 0),
|
|
clothingOnWalk: String(r.clothing_on_walk ?? ""),
|
|
}));
|
|
|
|
const baseItemMap = Object.fromEntries(baseItems.map((b) => [b.id, b]));
|
|
|
|
// Build mapping: baseItemId -> catalogName
|
|
const catalogNameMap: Record<number, string> = {};
|
|
for (const item of items) {
|
|
const firstBaseId = item.itemIds
|
|
.split(";")
|
|
.map(Number)
|
|
.find((n) => n > 0);
|
|
if (firstBaseId && !catalogNameMap[firstBaseId]) {
|
|
catalogNameMap[firstBaseId] = item.catalogName;
|
|
}
|
|
}
|
|
|
|
const catalogItems: CatalogItemEnriched[] = items.map((item) => {
|
|
const firstBaseId = item.itemIds
|
|
.split(";")
|
|
.map(Number)
|
|
.find((n) => n > 0);
|
|
const base = firstBaseId ? baseItemMap[firstBaseId] : undefined;
|
|
return {
|
|
id: item.id,
|
|
catalogName: item.catalogName,
|
|
itemIds: item.itemIds,
|
|
costCredits: item.costCredits,
|
|
costPoints: item.costPoints,
|
|
pointsType: item.pointsType,
|
|
amount: item.amount,
|
|
limitedSells: item.limitedSells,
|
|
limitedStack: item.limitedStack,
|
|
orderNumber: item.orderNumber,
|
|
offerId: item.offerId,
|
|
songId: item.songId,
|
|
haveOffer: item.haveOffer,
|
|
clubOnly: item.clubOnly,
|
|
extradata: item.extradata,
|
|
baseName: base?.publicName || base?.itemName || "",
|
|
baseItemName: base?.itemName || "",
|
|
spriteId: base?.spriteId ?? 0,
|
|
baseItem: base ? { ...base } : null,
|
|
};
|
|
});
|
|
|
|
// Build spriteId -> items_base.id mapping for FurnitureData.json lookup
|
|
const spriteToBaseId = new Map<number, number>();
|
|
for (const b of baseItems) {
|
|
spriteToBaseId.set(b.spriteId, b.id);
|
|
}
|
|
|
|
// Read FurnitureData.json (cached in memory)
|
|
const foundBaseIds = new Set<number>();
|
|
const furniDescriptionMap: Record<number, string> = {};
|
|
const furniRevisionMap: Record<
|
|
number,
|
|
{ classname: string; revision: number }
|
|
> = {};
|
|
const furniData = await getFurnitureData();
|
|
if (furniData) {
|
|
for (const section of ["roomitemtypes", "wallitemtypes"] as const) {
|
|
if (furniData[section]?.furnitype) {
|
|
for (const item of furniData[section].furnitype) {
|
|
const baseId = spriteToBaseId.get(item.id);
|
|
if (baseId !== undefined) {
|
|
foundBaseIds.add(baseId);
|
|
furniDescriptionMap[baseId] = item.description ?? "";
|
|
furniRevisionMap[baseId] = {
|
|
classname: item.classname ?? "",
|
|
revision: item.revision ?? 0,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
items: catalogItems,
|
|
baseItems: baseItems.map((b) => ({
|
|
id: b.id,
|
|
publicName: b.publicName,
|
|
itemName: b.itemName,
|
|
spriteId: b.spriteId,
|
|
type: b.type,
|
|
})),
|
|
catalogNameMap,
|
|
furniDataIdList: [...foundBaseIds],
|
|
furniDescriptionMap,
|
|
furniRevisionMap,
|
|
interactionTypes,
|
|
allPages,
|
|
gamedataHotel,
|
|
};
|
|
}
|