import React, { useCallback, useContext, useEffect, useRef, useState } from "react";
import { Alert, Button, Descriptions, Drawer, Popconfirm, Space, Table, Typography, Upload } from "antd";
import * as lib from "@clusterio/lib";
import {
PageLayout, PageHeader, ControlContext, FactorioIcon, notify, notifyErrorHandler,
useAccount, useInstances, useDefaultModPack, useExportLocale, useExportPrototypeMetadata,
useTableQueryState, useColumnSearch, type WebPluginContext,
} from "@clusterio/web_ui";
import {
DatabaseStatsRequest, DatabaseStatsResponse, DeletePlayerDataRequest, ForceReleaseRequest,
GetPlayerDataRequest, GetPlayerDataResponse, IpcPlayerData, ListPlayersRequest, PlayerEntry,
SetPlayerDataRequest,
} from "../messages.js";
import { type ItemSummary, summarizePlayerInventories } from "../player_data.js";
import "./style.css";
const strcmp = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" }).compare;
function useInstanceName() {
const [instances] = useInstances();
return (instanceId?: number) => {
if (instanceId === undefined) {
return "";
}
return instances.get(instanceId)?.name ?? `Instance ${instanceId}`;
};
}
function InventoryTable(props: { name: string, items: ItemSummary[] }) {
const modPack = useDefaultModPack();
const locale = useExportLocale(modPack);
const prototypes = useExportPrototypeMetadata(modPack);
const itemMetadata = prototypes?.get("item");
function getLocaleName(itemName: string) {
let meta = itemMetadata?.get(itemName);
if (typeof meta?.localised_name === "string") {
return meta.localised_name;
}
if (meta?.localised_name) {
return locale.get(meta.localised_name[0]) ?? itemName;
}
return locale.get(`item-name.${itemName}`) ?? locale.get(`entity-name.${itemName}`) ?? itemName;
}
return
props.name}
columns={[
{
title: "Item",
key: "item",
render: (_, item) => (item.exportSize !== undefined
? {item.name}
: <>
{getLocaleName(item.name)}
>
),
},
{
title: "Quality",
key: "quality",
render: (_, item) => item.quality,
},
{
title: "Count",
key: "count",
align: "right",
render: (_, item) => item.count,
},
{
title: "Size",
key: "size",
align: "right",
render: (_, item) => (item.exportSize === undefined ? "" : lib.formatBytes(item.exportSize)),
},
]}
dataSource={props.items.map((item, key) => ({ ...item, key }))}
pagination={false}
/>;
}
function PlayerDrawer(props: { playerName?: string, onClose: () => void, onChange: () => void }) {
const control = useContext(ControlContext);
const account = useAccount();
const instanceName = useInstanceName();
const [response, setResponse] = useState();
const { playerName } = props;
// Only the latest request may set the response, older ones may be for another player
const requestId = useRef(0);
const reload = useCallback(() => {
requestId.current += 1;
let id = requestId.current;
if (playerName === undefined) {
return;
}
control.send(new GetPlayerDataRequest(playerName)).then(result => {
if (id === requestId.current) {
setResponse(result);
}
}).catch(
notifyErrorHandler("Error loading player data")
);
}, [control, playerName]);
useEffect(() => {
setResponse(undefined);
reload();
}, [reload]);
function changed() {
reload();
props.onChange();
}
async function upload(file: File) {
let playerData: IpcPlayerData;
try {
playerData = JSON.parse(await file.text());
} catch (err: any) {
notify("Invalid JSON", "error", err.message);
return;
}
playerData.name = playerName!;
playerData.generation ??= 0;
let result = await control.send(new SetPlayerDataRequest(playerName!, playerData));
notify(`Stored player data for ${playerName} as generation ${result.generation}`);
changed();
}
function download() {
let json = JSON.stringify(response!.playerData, null, "\t");
let url = URL.createObjectURL(new Blob([json], { type: "application/json" }));
let link = document.createElement("a");
link.href = url;
link.download = `${playerName}.json`;
link.click();
URL.revokeObjectURL(url);
}
const canModify = account.hasPermission("player_sync.inventory.modify");
const playerData = response?.playerData;
const acquiredBy = response?.instanceId !== undefined ? instanceName(response.instanceId) : undefined;
return
{response &&
{acquiredBy !== undefined && control.send(new ForceReleaseRequest(playerName!)).then(changed).catch(
notifyErrorHandler("Error releasing lock")
)}
>
}
/>}
{playerData?.generation ?? "-"}
{playerData ? lib.formatBytes(JSON.stringify(playerData).length) : "-"}
{playerData?.controller ?? "-"}
{playerData?.force ?? "-"}
{canModify && {
upload(file).catch(notifyErrorHandler("Error storing player data"));
return false;
}}
>
}
{canModify && control.send(new DeletePlayerDataRequest(playerName!)).then(changed).catch(
notifyErrorHandler("Error deleting player data")
)}
>
}
{!playerData && No player data stored}
{playerData && summarizePlayerInventories(playerData).map(
inventory =>
)}
}
;
}
function InventoryPage() {
const control = useContext(ControlContext);
const instanceName = useInstanceName();
const [statsData, setStatsData] = useState();
const [players, setPlayers] = useState([]);
const [selected, setSelected] = useState();
const tableState = useTableQueryState({
namespace: "inventory", defaultSortKey: "name", pagination: { defaultPageSize: 50 },
});
const nameSearch = useColumnSearch(tableState, "name", player => player.name, "Search");
const reload = useCallback(() => {
control.send(new DatabaseStatsRequest()).then(setStatsData).catch(
notifyErrorHandler("Error loading player sync statistics")
);
control.send(new ListPlayersRequest()).then(setPlayers).catch(
notifyErrorHandler("Error loading player list")
);
}, [control]);
useEffect(reload, [reload]);
return
{statsData && <>
Database size: {lib.formatBytes(statsData.databaseSize)}
Database entries: {statsData.databaseEntries}
Largest entry is {statsData.largestEntry.name} with {lib.formatBytes(statsData.largestEntry.size)}
>}
strcmp(a.name, b.name),
sortOrder: tableState.sortOrder("name"),
},
{
title: "Generation",
key: "generation",
align: "right",
sorter: (a, b) => (a.generation ?? -1) - (b.generation ?? -1),
sortOrder: tableState.sortOrder("generation"),
render: (_, player) => player.generation ?? "-",
},
{
title: "Size",
key: "size",
align: "right",
sorter: (a, b) => (a.size ?? -1) - (b.size ?? -1),
sortOrder: tableState.sortOrder("size"),
render: (_, player) => (player.size === undefined ? "-" : lib.formatBytes(player.size)),
},
{
title: "Acquired by",
key: "instance",
sorter: (a, b) => strcmp(instanceName(a.instanceId), instanceName(b.instanceId)),
sortOrder: tableState.sortOrder("instance"),
render: (_, player) => instanceName(player.instanceId),
},
]}
dataSource={players}
rowKey="name"
pagination={tableState.pagination}
onChange={tableState.onChange}
onRow={player => ({
style: { cursor: "pointer" },
onClick: () => setSelected(player.name),
})}
/>
setSelected(undefined)} onChange={reload} />
;
}
export default async function(context: WebPluginContext) {
const { control, plugin } = context;
control.hooks.pages.attach(plugin.name, () => [
{
path: "/inventory",
sidebarName: "Player sync",
permission: "player_sync.inventory.view",
content: ,
},
]);
}