import React, { useEffect, useContext, useState, useMemo, useRef } from "react"; import { useNavigate, useParams } from "react-router-dom"; import { Button, Checkbox, Col, Grid, Input, Popconfirm, Row, Space, Spin, Tooltip } from "antd"; import { ExclamationCircleOutlined, StarOutlined, DeleteOutlined} from "@ant-design/icons"; import * as lib from "@clusterio/lib"; import { useRole } from "../model/roles"; import { useAccount } from "../model/account"; import ControlContext from "./ControlContext"; import PageHeader from "./PageHeader"; import PageLayout from "./PageLayout"; import PluginExtra from "./PluginExtra"; import ResourceNotes from "./ResourceNotes"; import { notifyErrorHandler } from "../util/notify"; /** Splits a permission name into parts, removing the last part */ function getGroupName(name: string) { const parts = name.split("."); return parts.length <= 2 ? parts.slice(0, 2).join(".") : parts.slice(0, parts.length - 1).join("."); } /** Converts a group name into Title Case with _ and . removed */ function formatGroupTitle(name: string) { return name .replace(/\./g, " / ") .replace(/_/g, " ") .split(" ") .filter(Boolean) .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()) .join(" "); } /** Check if a permission is dangerous, in the future we might have metadata for this */ function isDangerous(permission: lib.Permission) { return ["delete", "kill", "stop", "revoke", "update", "core.admin"] .some(word => permission.name.includes(word)); } /** A single permission item inside a group; includes a checkbox, name, and description */ function PermissionItem({ permission, baseline, checked, disabled, onChange, }: { permission: lib.Permission; checked: boolean; baseline: boolean; disabled: boolean; onChange: (value: boolean) => void; }) { const modified = checked !== baseline; return (
onChange(e.target.checked)}> {permission.title} {permission.grantByDefault && ( )} {isDangerous(permission) && ( )}
{permission.description}
); } /** A group of permissions; includes a title, clear and select all buttons, and the permission items */ function PermissionGroup({ groupName, permissions, canUpdate, baselineState, permissionState, setPermissions, }: { groupName: string; permissions: lib.Permission[]; canUpdate: boolean; baselineState: Record; permissionState: Record; setPermissions: (names: string[], value: boolean) => void; }) { function setGroup(value: boolean) { setPermissions(permissions.map(p => p.name), value); } return (
{formatGroupTitle(groupName)}
{permissions.map((p: any) => ( setPermissions([p.name], v)} /> ))}
); } /** An entry in the group list; the dot is blue when any permission in the group is granted */ function PermissionGroupNav({ groupName, granted }: { groupName: string; granted: boolean }) { function scrollToGroup() { document.getElementById(`permission-group-${groupName}`)?.scrollIntoView({ behavior: "smooth" }); } return (
{formatGroupTitle(groupName)}
); } /** The role page view */ export default function RoleViewPage() { const params = useParams(); const roleId = Number(params.id); const navigate = useNavigate(); const account = useAccount(); const control = useContext(ControlContext); const [role, synced] = useRole(roleId); // Local edits on top of the live role const [nameEdit, setNameEdit] = useState(); const [descriptionEdit, setDescriptionEdit] = useState(); const [permissionEdits, setPermissionEdits] = useState>({}); const [search, setSearch] = useState(""); const loadedRoleId = useRef(undefined); // Hidden below lg, where the site sider leaves too little room; undefined until measured const screens = Grid.useBreakpoint(); const showGroupList = screens.lg !== false; const allPermissions = useMemo(() => [...lib.permissions.values()], []); const canUpdate = Boolean(account.hasPermission("core.role.update")); const baselineState = useMemo(() => Object.fromEntries( allPermissions.map(p => [p.name, Boolean(role?.permissions.has(p.name))]) ), [role, allPermissions]); // Drop edits that now match the role, and all edits if we can no longer apply them useEffect(() => { if (!role || !canUpdate) { setNameEdit(undefined); setDescriptionEdit(undefined); setPermissionEdits(prev => (Object.keys(prev).length ? {} : prev)); return; } setNameEdit(prev => (prev === role.name ? undefined : prev)); setDescriptionEdit(prev => (prev === role.description ? undefined : prev)); setPermissionEdits(prev => { const next = Object.fromEntries(Object.entries(prev).filter(([k, v]) => v !== baselineState[k])); return Object.keys(next).length === Object.keys(prev).length ? prev : next; }); }, [role, canUpdate, baselineState]); useEffect(() => { setNameEdit(undefined); setDescriptionEdit(undefined); setPermissionEdits({}); }, [roleId]); if (role) { loadedRoleId.current = roleId; } // If no role then display either the loading screen or the not found screen if (!role) { const nav = [{ name: "Roles", path: "/roles" }, { name: String(roleId) }]; if (!synced) { return ; } return

Role with id {roleId} { loadedRoleId.current === roleId ? "has been deleted" : "was not found on the controller" }.

; } const name = nameEdit ?? role.name; const description = descriptionEdit ?? role.description; const permissionState = { ...baselineState, ...permissionEdits }; // Apply the filter by searching all permission fields const filtered = allPermissions.filter(p => { const q = search.toLowerCase(); return p.name.toLowerCase().includes(q) || p.title.toLowerCase().includes(q) || p.description.toLowerCase().includes(q); }); // Organise the permissions into groups const groups = new Map(); for (let p of filtered) { const g = getGroupName(p.name); if (!groups.has(g)) { groups.set(g, []); } groups.get(g)!.push(p); } // Sort permissions alphabetically within their groups const sortedGroups = [...groups.entries()].sort(([a], [b]) => a.localeCompare(b)); for (let [, permissions] of sortedGroups) { permissions.sort((a, b) => a.title.localeCompare(b.title)); } // Groups with at least one granted permission, including those hidden by the search const grantedGroups = new Set(allPermissions.filter(p => permissionState[p.name]).map(p => getGroupName(p.name))); // Check if any changes have been made to the permissions or role metadata const permissionChanged = Object.keys(permissionEdits).some(k => permissionEdits[k] !== baselineState[k]); const metaChanged = name !== role.name || description !== role.description; const edited = permissionChanged || metaChanged; function setPermissions(names: string[], value: boolean) { setPermissionEdits(prev => { const next = { ...prev }; for (let permissionName of names) { next[permissionName] = value; } return next; }); } /** Revert any pending changes */ function revertChanges() { setNameEdit(undefined); setDescriptionEdit(undefined); setPermissionEdits({}); } /** Applies all pending changes */ function applyChanges() { const newPermissions = Object.entries(permissionState).filter(([, v]) => v).map(([k]) => k); control.send(new lib.RoleUpdateRequest(roleId, name, description, newPermissions)) .then(revertChanges) .catch(notifyErrorHandler("Error applying changes")); } return ( {account.hasPermission("core.role.delete") && { control.send(new lib.RoleDeleteRequest(roleId)) .then(() => navigate("/roles")) .catch(notifyErrorHandler("Error deleting role")); }} > } } /> {edited && (
You have unsaved changes
)}
setNameEdit(e.target.value)} />
setDescriptionEdit(e.target.value)} />

Permissions

setSearch(e.target.value)} style={{ marginBottom: 16 }} /> {showGroupList && {/* Clear of the fixed page header */}
{sortedGroups.map(([groupName]) => ( ))}
} {sortedGroups.map(([groupName, permissions]) => ( ))}
); }