607 lines
23 KiB
TypeScript
607 lines
23 KiB
TypeScript
import { handleListControlKey } from './listController';
|
|
import { getEditSessionAction } from './editSession';
|
|
import { handleYesNoMenuInput, YES_NO_OPTIONS } from './yesNoMenu';
|
|
import type { IncomingMessage, OutgoingMessage } from '../network/protocol';
|
|
import type { GameMode } from '../state/gameState';
|
|
|
|
export type AdminMenuAction = {
|
|
id: string;
|
|
label: string;
|
|
tooltip?: string;
|
|
};
|
|
|
|
export type AdminRoleSummary = {
|
|
id: number;
|
|
name: string;
|
|
isSystem: boolean;
|
|
userCount: number;
|
|
permissions: string[];
|
|
};
|
|
|
|
export type AdminUserSummary = {
|
|
id: string;
|
|
username: string;
|
|
role: string;
|
|
status: 'active' | 'disabled';
|
|
};
|
|
|
|
export type AdminPendingUserMutation =
|
|
| { action: 'set_role'; username: string; role: string }
|
|
| { action: 'ban'; username: string }
|
|
| { action: 'unban'; username: string }
|
|
| { action: 'delete_account'; username: string };
|
|
|
|
type AdminPendingUserAction = 'set_role' | 'ban' | 'unban' | 'delete_account' | null;
|
|
|
|
type AdminControllerDeps = {
|
|
state: {
|
|
mode: GameMode;
|
|
nicknameInput: string;
|
|
cursorPos: number;
|
|
};
|
|
signalingSend: (message: OutgoingMessage) => void;
|
|
announceMenuEntry: (title: string, firstOption: string) => void;
|
|
updateStatus: (message: string) => void;
|
|
sfxUiBlip: () => void;
|
|
sfxUiCancel: () => void;
|
|
applyTextInputEdit: (code: string, key: string, maxLength: number, ctrlKey?: boolean, allowReplaceOnNextType?: boolean) => void;
|
|
setReplaceTextOnNextType: (value: boolean) => void;
|
|
};
|
|
|
|
/**
|
|
* Creates the admin menu/runtime controller so `main.ts` can treat admin flows as one subsystem.
|
|
*/
|
|
export function createAdminController(deps: AdminControllerDeps): {
|
|
setServerAdminMenuActions: (actions: Array<{ id: string; label: string; tooltip?: string }> | null | undefined) => void;
|
|
getAvailableAdminActions: () => AdminMenuAction[];
|
|
openAdminMenu: () => void;
|
|
handleAdminRolesList: (message: Extract<IncomingMessage, { type: 'admin_roles_list' }>) => void;
|
|
handleAdminUsersList: (message: Extract<IncomingMessage, { type: 'admin_users_list' }>) => void;
|
|
handleAdminActionResult: (message: Extract<IncomingMessage, { type: 'admin_action_result' }>) => void;
|
|
handleAdminMenuModeInput: (code: string, key: string) => void;
|
|
handleAdminRoleListModeInput: (code: string, key: string) => void;
|
|
handleAdminRolePermissionListModeInput: (code: string, key: string) => void;
|
|
handleAdminRoleDeleteReplacementModeInput: (code: string, key: string) => void;
|
|
handleAdminUserListModeInput: (code: string, key: string) => void;
|
|
handleAdminUserRoleSelectModeInput: (code: string, key: string) => void;
|
|
handleAdminUserDeleteConfirmModeInput: (code: string, key: string) => void;
|
|
handleAdminRoleNameEditModeInput: (code: string, key: string, ctrlKey: boolean) => void;
|
|
} {
|
|
const adminMenuActions: AdminMenuAction[] = [];
|
|
let serverAdminMenuActions: AdminMenuAction[] = [];
|
|
let adminMenuIndex = 0;
|
|
let adminRoles: AdminRoleSummary[] = [];
|
|
let adminRoleIndex = 0;
|
|
let adminPermissionKeys: string[] = [];
|
|
let adminPermissionTooltips: Record<string, string> = {};
|
|
let adminRolePermissionIndex = 0;
|
|
let adminRoleDeleteReplacementIndex = 0;
|
|
let adminUsers: AdminUserSummary[] = [];
|
|
let adminUserIndex = 0;
|
|
let adminPendingUserAction: AdminPendingUserAction = null;
|
|
let adminSelectedRoleName = '';
|
|
let adminSelectedUsername = '';
|
|
let adminPendingUserMutation: AdminPendingUserMutation | null = null;
|
|
let adminDeleteConfirmIndex = 0;
|
|
|
|
function setServerAdminMenuActions(actions: Array<{ id: string; label: string; tooltip?: string }> | null | undefined): void {
|
|
serverAdminMenuActions = (actions || [])
|
|
.map((entry) => ({
|
|
id: String(entry.id || '').trim(),
|
|
label: String(entry.label || '').trim(),
|
|
tooltip: typeof entry.tooltip === 'string' && entry.tooltip.trim().length > 0 ? entry.tooltip.trim() : undefined,
|
|
}))
|
|
.filter((entry) => entry.id.length > 0 && entry.label.length > 0);
|
|
}
|
|
|
|
function getAvailableAdminActions(): AdminMenuAction[] {
|
|
return [...serverAdminMenuActions];
|
|
}
|
|
|
|
function openAdminMenu(): void {
|
|
const actions = getAvailableAdminActions();
|
|
if (actions.length === 0) {
|
|
deps.updateStatus('No admin actions available.');
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
adminMenuActions.splice(0, adminMenuActions.length, ...actions);
|
|
adminMenuIndex = 0;
|
|
deps.state.mode = 'adminMenu';
|
|
deps.announceMenuEntry('Admin', adminMenuActions[0].label);
|
|
}
|
|
|
|
function handleAdminRolesList(message: Extract<IncomingMessage, { type: 'admin_roles_list' }>): void {
|
|
adminRoles = [...message.roles].sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
|
|
adminPermissionKeys = [...message.permissionKeys].sort((a, b) => a.localeCompare(b));
|
|
adminPermissionTooltips = { ...(message.permissionTooltips ?? {}) };
|
|
if (adminPendingUserAction === 'set_role' && adminSelectedUsername) {
|
|
deps.state.mode = 'adminUserRoleSelect';
|
|
const selectedUser = adminUsers.find((entry) => entry.username === adminSelectedUsername);
|
|
const currentRoleIndex =
|
|
selectedUser ? adminRoles.findIndex((entry) => entry.name === selectedUser.role) : -1;
|
|
adminRoleIndex = currentRoleIndex >= 0 ? currentRoleIndex : 0;
|
|
const first = adminRoles[0];
|
|
if (first && adminRoles[adminRoleIndex]) {
|
|
deps.announceMenuEntry('Roles', adminRoles[adminRoleIndex].name);
|
|
} else {
|
|
deps.updateStatus('No roles available.');
|
|
deps.sfxUiCancel();
|
|
deps.state.mode = 'normal';
|
|
adminPendingUserAction = null;
|
|
adminSelectedUsername = '';
|
|
}
|
|
return;
|
|
}
|
|
deps.state.mode = 'adminRoleList';
|
|
adminRoleIndex = 0;
|
|
const first = adminRoles[0];
|
|
if (first) {
|
|
deps.announceMenuEntry('Roles', `${first.name}, ${first.userCount}`);
|
|
} else {
|
|
deps.updateStatus('No roles found.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminUsersList(message: Extract<IncomingMessage, { type: 'admin_users_list' }>): void {
|
|
adminUsers = [...message.users].sort((a, b) => a.username.localeCompare(b.username, undefined, { sensitivity: 'base' }));
|
|
if (adminUsers.length === 0) {
|
|
deps.updateStatus('No users available.');
|
|
deps.sfxUiCancel();
|
|
deps.state.mode = 'normal';
|
|
adminPendingUserAction = null;
|
|
return;
|
|
}
|
|
deps.state.mode = 'adminUserList';
|
|
adminUserIndex = 0;
|
|
const first = adminUsers[0];
|
|
deps.announceMenuEntry('Users', `${first.username}, ${first.role}, ${first.status}`);
|
|
}
|
|
|
|
function handleAdminActionResult(message: Extract<IncomingMessage, { type: 'admin_action_result' }>): void {
|
|
if (message.action === 'role_update_permissions') {
|
|
return;
|
|
}
|
|
const suppressStatusMessage =
|
|
message.ok && message.action === 'user_set_role' && adminPendingUserMutation?.action === 'set_role';
|
|
if (!suppressStatusMessage) {
|
|
deps.updateStatus(message.message);
|
|
}
|
|
if (!message.ok) {
|
|
adminPendingUserMutation = null;
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
|
|
if (adminPendingUserMutation) {
|
|
if (adminPendingUserMutation.action === 'set_role') {
|
|
const target = adminUsers.find((entry) => entry.username === adminPendingUserMutation.username);
|
|
if (target) {
|
|
target.role = adminPendingUserMutation.role;
|
|
}
|
|
if (deps.state.mode === 'adminUserRoleSelect') {
|
|
deps.state.mode = 'adminUserList';
|
|
adminPendingUserAction = 'set_role';
|
|
const userIndex = adminUsers.findIndex((entry) => entry.username === adminPendingUserMutation.username);
|
|
if (userIndex >= 0) {
|
|
adminUserIndex = userIndex;
|
|
const selected = adminUsers[adminUserIndex];
|
|
deps.updateStatus(`${selected.username}, ${selected.role}, ${selected.status}.`);
|
|
}
|
|
}
|
|
} else if (adminPendingUserMutation.action === 'ban') {
|
|
adminUsers = adminUsers.filter((entry) => entry.username !== adminPendingUserMutation.username);
|
|
if (deps.state.mode === 'adminUserList' && adminPendingUserAction === 'ban') {
|
|
if (adminUsers.length > 0) {
|
|
adminUserIndex = Math.max(0, Math.min(adminUserIndex, adminUsers.length - 1));
|
|
} else {
|
|
deps.state.mode = 'adminMenu';
|
|
adminPendingUserAction = null;
|
|
}
|
|
}
|
|
} else if (adminPendingUserMutation.action === 'unban') {
|
|
adminUsers = adminUsers.filter((entry) => entry.username !== adminPendingUserMutation.username);
|
|
if (deps.state.mode === 'adminUserList' && adminPendingUserAction === 'unban') {
|
|
if (adminUsers.length > 0) {
|
|
adminUserIndex = Math.max(0, Math.min(adminUserIndex, adminUsers.length - 1));
|
|
} else {
|
|
deps.state.mode = 'adminMenu';
|
|
adminPendingUserAction = null;
|
|
}
|
|
}
|
|
} else if (adminPendingUserMutation.action === 'delete_account') {
|
|
adminUsers = adminUsers.filter((entry) => entry.username !== adminPendingUserMutation.username);
|
|
if (deps.state.mode === 'adminUserList' && adminPendingUserAction === 'delete_account') {
|
|
if (adminUsers.length > 0) {
|
|
adminUserIndex = Math.max(0, Math.min(adminUserIndex, adminUsers.length - 1));
|
|
} else {
|
|
deps.state.mode = 'adminMenu';
|
|
adminPendingUserAction = null;
|
|
}
|
|
}
|
|
}
|
|
adminPendingUserMutation = null;
|
|
}
|
|
|
|
if (message.action === 'role_create' && message.role) {
|
|
adminRoles.push({
|
|
id: message.role.id,
|
|
name: message.role.name,
|
|
isSystem: message.role.isSystem,
|
|
userCount: message.role.userCount,
|
|
permissions: [...message.role.permissions],
|
|
});
|
|
adminRoles.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
|
|
}
|
|
if (message.action === 'role_delete' && message.roleName) {
|
|
adminRoles = adminRoles.filter((entry) => entry.name !== message.roleName);
|
|
if (deps.state.mode === 'adminRoleList') {
|
|
adminRoleIndex = Math.max(0, Math.min(adminRoleIndex, Math.max(0, adminRoles.length)));
|
|
}
|
|
}
|
|
}
|
|
|
|
function handleAdminMenuModeInput(code: string, key: string): void {
|
|
if (adminMenuActions.length === 0) {
|
|
deps.state.mode = 'normal';
|
|
return;
|
|
}
|
|
const control = handleListControlKey(code, key, adminMenuActions, adminMenuIndex, (entry) => entry.label);
|
|
if (control.type === 'move') {
|
|
adminMenuIndex = control.index;
|
|
deps.updateStatus(adminMenuActions[adminMenuIndex].label);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (code === 'Space') {
|
|
deps.updateStatus(adminMenuActions[adminMenuIndex]?.tooltip ?? 'No tooltip available.');
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const selected = adminMenuActions[adminMenuIndex];
|
|
if (!selected) return;
|
|
if (selected.id === 'manage_roles') {
|
|
deps.signalingSend({ type: 'admin_roles_list' });
|
|
deps.updateStatus('Loading roles...');
|
|
return;
|
|
}
|
|
if (selected.id === 'change_user_role') {
|
|
adminPendingUserAction = 'set_role';
|
|
deps.signalingSend({ type: 'admin_users_list', action: 'set_role' });
|
|
deps.updateStatus('Loading users...');
|
|
return;
|
|
}
|
|
if (selected.id === 'ban_user') {
|
|
adminPendingUserAction = 'ban';
|
|
deps.signalingSend({ type: 'admin_users_list', action: 'ban' });
|
|
deps.updateStatus('Loading users...');
|
|
return;
|
|
}
|
|
if (selected.id === 'unban_user') {
|
|
adminPendingUserAction = 'unban';
|
|
deps.signalingSend({ type: 'admin_users_list', action: 'unban' });
|
|
deps.updateStatus('Loading users...');
|
|
return;
|
|
}
|
|
if (selected.id === 'delete_account') {
|
|
adminPendingUserAction = 'delete_account';
|
|
deps.signalingSend({ type: 'admin_users_list', action: 'delete_account' });
|
|
deps.updateStatus('Loading users...');
|
|
}
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'normal';
|
|
deps.updateStatus('Cancelled.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminRoleListModeInput(code: string, key: string): void {
|
|
const entries: Array<{ label: string; role?: AdminRoleSummary }> = [
|
|
...adminRoles.map((role) => ({ label: `${role.name}, ${role.userCount}`, role })),
|
|
{ label: 'Add role' },
|
|
];
|
|
const control = handleListControlKey(code, key, entries, adminRoleIndex, (entry) => entry.label);
|
|
if (control.type === 'move') {
|
|
adminRoleIndex = control.index;
|
|
deps.updateStatus(entries[adminRoleIndex]?.label || '');
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const selected = entries[adminRoleIndex];
|
|
if (!selected) return;
|
|
if (!selected.role) {
|
|
deps.state.mode = 'adminRoleNameEdit';
|
|
deps.state.nicknameInput = '';
|
|
deps.state.cursorPos = 0;
|
|
deps.setReplaceTextOnNextType(false);
|
|
deps.updateStatus('New role name.');
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
adminSelectedRoleName = selected.role.name;
|
|
adminRolePermissionIndex = 0;
|
|
deps.state.mode = 'adminRolePermissionList';
|
|
deps.updateStatus(`${adminSelectedRoleName} permissions.`);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'normal';
|
|
deps.updateStatus('Cancelled.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminRolePermissionListModeInput(code: string, key: string): void {
|
|
const role = adminRoles.find((entry) => entry.name === adminSelectedRoleName);
|
|
if (!role) {
|
|
deps.state.mode = 'adminRoleList';
|
|
return;
|
|
}
|
|
const entries = [...adminPermissionKeys, '__delete_role__'];
|
|
const control = handleListControlKey(code, key, entries, adminRolePermissionIndex, (entry) =>
|
|
entry === '__delete_role__' ? `Delete role ${role.name}` : `${entry}: ${role.permissions.includes(entry) ? 'on' : 'off'}`,
|
|
);
|
|
if (control.type === 'move') {
|
|
adminRolePermissionIndex = control.index;
|
|
const value = entries[adminRolePermissionIndex];
|
|
if (value === '__delete_role__') {
|
|
deps.updateStatus(`Delete role ${role.name}.`);
|
|
} else {
|
|
deps.updateStatus(`${value}: ${role.permissions.includes(value) ? 'on' : 'off'}`);
|
|
}
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (code === 'Space') {
|
|
const value = entries[adminRolePermissionIndex];
|
|
if (value === '__delete_role__') {
|
|
deps.updateStatus('Delete the current role and reassign affected users.');
|
|
} else {
|
|
deps.updateStatus(adminPermissionTooltips[value] || 'No tooltip available.');
|
|
}
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const value = entries[adminRolePermissionIndex];
|
|
if (value === '__delete_role__') {
|
|
if (role.name === 'admin' || role.name === 'user') {
|
|
deps.updateStatus('Admin and user roles cannot be deleted.');
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
const replacementCandidates = adminRoles.filter((entry) => entry.name !== role.name);
|
|
if (replacementCandidates.length === 0) {
|
|
deps.updateStatus('No replacement role available.');
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
adminRoleDeleteReplacementIndex = 0;
|
|
deps.state.mode = 'adminRoleDeleteReplacement';
|
|
deps.updateStatus(`Replacement role: ${replacementCandidates[0].name}.`);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
const nextPermissions = new Set(role.permissions);
|
|
if (nextPermissions.has(value)) {
|
|
nextPermissions.delete(value);
|
|
} else {
|
|
nextPermissions.add(value);
|
|
}
|
|
role.permissions = [...nextPermissions].sort((a, b) => a.localeCompare(b));
|
|
deps.signalingSend({ type: 'admin_role_update_permissions', role: role.name, permissions: role.permissions });
|
|
deps.updateStatus(`${value}: ${role.permissions.includes(value) ? 'on' : 'off'}`);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'adminRoleList';
|
|
deps.updateStatus('Roles.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminRoleDeleteReplacementModeInput(code: string, key: string): void {
|
|
const candidates = adminRoles.filter((entry) => entry.name !== adminSelectedRoleName);
|
|
if (candidates.length === 0) {
|
|
deps.state.mode = 'adminRolePermissionList';
|
|
return;
|
|
}
|
|
const control = handleListControlKey(code, key, candidates, adminRoleDeleteReplacementIndex, (entry) => entry.name);
|
|
if (control.type === 'move') {
|
|
adminRoleDeleteReplacementIndex = control.index;
|
|
deps.updateStatus(candidates[adminRoleDeleteReplacementIndex].name);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const replacement = candidates[adminRoleDeleteReplacementIndex];
|
|
deps.signalingSend({
|
|
type: 'admin_role_delete',
|
|
role: adminSelectedRoleName,
|
|
replacementRole: replacement.name,
|
|
});
|
|
deps.state.mode = 'adminRoleList';
|
|
deps.updateStatus(`Deleting ${adminSelectedRoleName}...`);
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'adminRolePermissionList';
|
|
deps.updateStatus(`${adminSelectedRoleName} permissions.`);
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminUserListModeInput(code: string, key: string): void {
|
|
if (adminUsers.length === 0) {
|
|
deps.state.mode = 'normal';
|
|
adminPendingUserAction = null;
|
|
return;
|
|
}
|
|
const control = handleListControlKey(code, key, adminUsers, adminUserIndex, (entry) => `${entry.username}, ${entry.role}, ${entry.status}`);
|
|
if (control.type === 'move') {
|
|
adminUserIndex = control.index;
|
|
const selected = adminUsers[adminUserIndex];
|
|
deps.updateStatus(`${selected.username}, ${selected.role}, ${selected.status}.`);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const selected = adminUsers[adminUserIndex];
|
|
if (!selected) return;
|
|
adminSelectedUsername = selected.username;
|
|
if (adminPendingUserAction === 'set_role') {
|
|
deps.signalingSend({ type: 'admin_roles_list' });
|
|
deps.updateStatus(`Select new role for ${selected.username}.`);
|
|
return;
|
|
}
|
|
if (adminPendingUserAction === 'ban') {
|
|
adminPendingUserMutation = { action: 'ban', username: selected.username };
|
|
deps.signalingSend({ type: 'admin_user_ban', username: selected.username });
|
|
adminPendingUserAction = 'ban';
|
|
return;
|
|
}
|
|
if (adminPendingUserAction === 'unban') {
|
|
adminPendingUserMutation = { action: 'unban', username: selected.username };
|
|
deps.signalingSend({ type: 'admin_user_unban', username: selected.username });
|
|
adminPendingUserAction = 'unban';
|
|
return;
|
|
}
|
|
if (adminPendingUserAction === 'delete_account') {
|
|
adminDeleteConfirmIndex = 0;
|
|
deps.state.mode = 'adminUserDeleteConfirm';
|
|
deps.announceMenuEntry(`Delete account ${selected.username}?`, YES_NO_OPTIONS[adminDeleteConfirmIndex].label);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'adminMenu';
|
|
adminPendingUserAction = null;
|
|
deps.updateStatus('Admin menu.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminUserRoleSelectModeInput(code: string, key: string): void {
|
|
if (adminRoles.length === 0) {
|
|
deps.state.mode = 'normal';
|
|
adminPendingUserAction = null;
|
|
return;
|
|
}
|
|
const control = handleListControlKey(code, key, adminRoles, adminRoleIndex, (entry) => entry.name);
|
|
if (control.type === 'move') {
|
|
adminRoleIndex = control.index;
|
|
deps.updateStatus(adminRoles[adminRoleIndex].name);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const selectedRole = adminRoles[adminRoleIndex];
|
|
adminPendingUserMutation = { action: 'set_role', username: adminSelectedUsername, role: selectedRole.name };
|
|
deps.signalingSend({ type: 'admin_user_set_role', username: adminSelectedUsername, role: selectedRole.name });
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'adminUserList';
|
|
deps.updateStatus('Select user.');
|
|
deps.sfxUiCancel();
|
|
}
|
|
}
|
|
|
|
function handleAdminUserDeleteConfirmModeInput(code: string, key: string): void {
|
|
if (!adminSelectedUsername || adminPendingUserAction !== 'delete_account') {
|
|
deps.state.mode = 'adminUserList';
|
|
return;
|
|
}
|
|
const control = handleYesNoMenuInput(code, key, adminDeleteConfirmIndex);
|
|
if (control.type === 'move') {
|
|
adminDeleteConfirmIndex = control.index;
|
|
deps.updateStatus(YES_NO_OPTIONS[adminDeleteConfirmIndex].label);
|
|
deps.sfxUiBlip();
|
|
return;
|
|
}
|
|
if (control.type === 'cancel') {
|
|
deps.state.mode = 'adminUserList';
|
|
const selected = adminUsers[adminUserIndex];
|
|
if (selected) {
|
|
deps.updateStatus(`${selected.username}, ${selected.role}, ${selected.status}.`);
|
|
} else {
|
|
deps.updateStatus('Select user.');
|
|
}
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
if (control.type === 'select') {
|
|
const choice = YES_NO_OPTIONS[adminDeleteConfirmIndex];
|
|
if (choice.id === 'no') {
|
|
deps.state.mode = 'adminUserList';
|
|
const selected = adminUsers[adminUserIndex];
|
|
if (selected) {
|
|
deps.updateStatus(`${selected.username}, ${selected.role}, ${selected.status}.`);
|
|
} else {
|
|
deps.updateStatus('Select user.');
|
|
}
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
deps.state.mode = 'adminUserList';
|
|
deps.updateStatus(`Deleting account ${adminSelectedUsername}...`);
|
|
adminPendingUserMutation = { action: 'delete_account', username: adminSelectedUsername };
|
|
deps.signalingSend({ type: 'admin_user_delete', username: adminSelectedUsername });
|
|
}
|
|
}
|
|
|
|
function handleAdminRoleNameEditModeInput(code: string, key: string, ctrlKey: boolean): void {
|
|
const editAction = getEditSessionAction(code);
|
|
if (editAction === 'submit') {
|
|
const name = deps.state.nicknameInput.trim().toLowerCase();
|
|
if (!name) {
|
|
deps.updateStatus('Role name required.');
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
deps.signalingSend({ type: 'admin_role_create', name });
|
|
deps.state.mode = 'adminRoleList';
|
|
deps.state.nicknameInput = '';
|
|
deps.state.cursorPos = 0;
|
|
deps.setReplaceTextOnNextType(false);
|
|
deps.updateStatus(`Creating role ${name}...`);
|
|
return;
|
|
}
|
|
if (editAction === 'cancel') {
|
|
deps.state.mode = 'adminRoleList';
|
|
deps.state.nicknameInput = '';
|
|
deps.state.cursorPos = 0;
|
|
deps.setReplaceTextOnNextType(false);
|
|
deps.updateStatus('Cancelled.');
|
|
deps.sfxUiCancel();
|
|
return;
|
|
}
|
|
deps.applyTextInputEdit(code, key, 32, ctrlKey, true);
|
|
}
|
|
|
|
return {
|
|
setServerAdminMenuActions,
|
|
getAvailableAdminActions,
|
|
openAdminMenu,
|
|
handleAdminRolesList,
|
|
handleAdminUsersList,
|
|
handleAdminActionResult,
|
|
handleAdminMenuModeInput,
|
|
handleAdminRoleListModeInput,
|
|
handleAdminRolePermissionListModeInput,
|
|
handleAdminRoleDeleteReplacementModeInput,
|
|
handleAdminUserListModeInput,
|
|
handleAdminUserRoleSelectModeInput,
|
|
handleAdminUserDeleteConfirmModeInput,
|
|
handleAdminRoleNameEditModeInput,
|
|
};
|
|
}
|