import React, { useContext, useState } from "react";
import { useNavigate } from "react-router-dom";
import { Static } from "@sinclair/typebox";
import {
Button, Form, FormInstance, Input, Modal,
Radio, Space, Upload, UploadProps,
} from "antd";
import { InboxOutlined } from "@ant-design/icons";
import * as lib from "@clusterio/lib";
import { useAccount } from "../model/account";
import ControlContext from "./ControlContext";
import { notifyErrorHandler } from "../util/notify";
import { saveJson } from "../util/save_file";
import PageHeader from "./PageHeader";
import PageLayout from "./PageLayout";
import PluginExtra from "./PluginExtra";
import UsersTable from "./UsersTable";
import { InputInstanceWithAll } from "./InputInstance";
import useTableQueryState from "../util/useTableQueryState";
function CreateUserButton() {
let control = useContext(ControlContext);
let navigate = useNavigate();
let [open, setOpen] = useState(false);
let [form] = Form.useForm();
async function createUser() {
let values = form.getFieldsValue();
if (!values.userName) {
form.setFields([{ name: "userName", errors: ["Name is required"] }]);
return;
}
await control.send(new lib.UserCreateRequest(values.userName));
setOpen(false);
navigate(`/users/${values.userName}/view`);
}
return <>
{ createUser().catch(notifyErrorHandler("Error creating user")); }}
onCancel={() => { setOpen(false); }}
destroyOnHidden
>
>;
}
type UserBulkActionProps = {
setApplyAction(func: () => Promise): void,
form: FormInstance,
restore?: boolean,
};
function UserBulkActionImport({ setApplyAction, form, restore }: UserBulkActionProps) {
const control = useContext(ControlContext);
const account = useAccount();
// Combines an array of users into the main array to be sent to the controller
function combineMixed(
prop: "is_admin" | "is_banned" | "is_whitelisted",
users: Array>,
usersToSend: Map>
) {
for (const user of users) {
if (typeof user !== "string") {
// It can only be a ban in this case
const existingUser = usersToSend.get(user.username);
if (existingUser) {
existingUser.is_banned = true;
existingUser.ban_reason = existingUser.ban_reason ? existingUser.ban_reason : user.reason;
} else {
usersToSend.set(user.username, {
is_banned: true,
...user,
});
}
} else {
// We only have the username
const existingUser = usersToSend.get(user);
if (existingUser) {
existingUser[prop] = true;
} else {
usersToSend.set(user, {
username: user,
[prop]: true,
});
}
}
}
}
// Parse a user json and combine into the format to be sent to the controller
function parseUsers(
users: Array>,
usersToSend: Map>
) {
for (const user of users) {
const existingUser = usersToSend.get(user.username);
// Combine all fields with an existing user
if (existingUser) {
existingUser.is_admin ||= user.is_admin;
existingUser.is_banned ||= user.is_banned;
existingUser.is_whitelisted ||= user.is_whitelisted;
existingUser.ban_reason = existingUser.ban_reason ? existingUser.ban_reason : user.ban_reason;
}
// We do not send false values
if (user.is_admin === false) {
delete user.is_admin;
}
if (user.is_banned === false) {
delete user.is_banned;
delete user.ban_reason;
}
if (user.is_whitelisted === false) {
delete user.is_whitelisted;
}
usersToSend.set(user.username, user);
}
}
// Parse a ban json and combine into the format to be sent to the controller
function parseBans(
users: Array>,
usersToSend: Map
) {
for (const user of users) {
if (typeof user === "string") {
if (!usersToSend.has(user)) {
usersToSend.set(user, user);
}
} else if (!user.reason) {
if (!usersToSend.has(user.username)) {
usersToSend.set(user.username, user.username);
}
} else {
usersToSend.set(user.username, user);
}
}
}
// Parse an admin or whitelist json and combine into the format to be sent to the controller
function parseAdminsWhitelist(
users: Array,
usersToSend: Set,
) {
for (const user of users) {
usersToSend.add(user);
}
}
setApplyAction(async () => {
let backup: object | undefined;
const values = form.getFieldsValue();
const importType = restore ? values.restoreType : values.importType;
switch (importType) {
case "mixed": {
// Parse and combine multiple json types then send
const usersToSend = new Map>();
for (const file of values.fileList as File[]) {
const json = JSON.parse(await file.text());
if (json.export_version) {
parseUsers(json.users, usersToSend);
} else if (file.name.includes("ban")) {
const users = new Map();
parseBans(json, users);
combineMixed("is_banned", [...users.values()], usersToSend);
} else if (file.name.includes("admin")) {
const users = new Set();
parseAdminsWhitelist(json, users);
combineMixed("is_admin", [...users.values()], usersToSend);
} else if (file.name.includes("whitelist")) {
const users = new Set();
parseAdminsWhitelist(json, users);
combineMixed("is_whitelisted", [...users.values()], usersToSend);
} else {
throw new Error(`Unknown json (could not guess by file name): ${file.name}`);
}
}
backup = await control.send(new lib.UserBulkImportRequest("users", [...usersToSend.values()], restore));
break;
}
case "users": {
// Parse and user jsons then send
const usersToSend = new Map>();
for (const file of values.fileList as File[]) {
parseUsers(JSON.parse(await file.text()).users, usersToSend);
}
backup = await control.send(new lib.UserBulkImportRequest("users", [...usersToSend.values()], restore));
break;
}
case "bans": {
// Parse and combine ban jsons then send
const usersToSend = new Map>();
for (const file of values.fileList as File[]) {
parseBans(JSON.parse(await file.text()), usersToSend);
}
backup = await control.send(new lib.UserBulkImportRequest("bans", [...usersToSend.values()], restore));
break;
}
case "admins":
case "whitelist": {
// Parse and combine admin or whitelist jsons then send
const usersToSend = new Set();
for (const file of values.fileList as File[]) {
parseAdminsWhitelist(JSON.parse(await file.text()), usersToSend);
}
backup = await control.send(
new lib.UserBulkImportRequest(importType, [...usersToSend.keys()], restore)
);
break;
}
default: {
// Should be unreachable
throw new Error(`Unknown importType: ${importType}`);
}
}
if (restore && backup) {
saveJson(`${importType}-backup.json`, backup);
}
});
const normaliseFiles = (e: any) => (Array.isArray(e) ? e : e.fileList).map((f: any) => f.originFileObj);
const uploadProps: UploadProps = {
accept: ".json",
multiple: true,
beforeUpload: (file) => false,
};
return <>
{restore ? undefined : Mixed}
UsersAdminsBansWhitelist