diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index 89116fec0911..697f187d4188 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -1592,6 +1592,14 @@ export interface paths {
         /** Remove the object from user's favorites */
         delete: operations["remove_favorite_api_users__user_id__favorites__object_type___object_id__delete"];
     };
+    "/api/users/{user_id}/recalculate_disk_usage": {
+        /** Triggers a recalculation of the current user disk usage. */
+        put: operations["recalculate_disk_usage_by_user_id_api_users__user_id__recalculate_disk_usage_put"];
+    };
+    "/api/users/{user_id}/send_activation_email": {
+        /** Sends activation email to user. */
+        post: operations["send_activation_email_api_users__user_id__send_activation_email_post"];
+    };
     "/api/users/{user_id}/theme/{theme}": {
         /** Set the user's theme choice */
         put: operations["set_theme_api_users__user_id__theme__theme__put"];
@@ -18988,6 +18996,62 @@ export interface operations {
             };
         };
     };
+    recalculate_disk_usage_by_user_id_api_users__user_id__recalculate_disk_usage_put: {
+        /** Triggers a recalculation of the current user disk usage. */
+        parameters: {
+            /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+            header?: {
+                "run-as"?: string;
+            };
+            /** @description The ID of the user to get. */
+            path: {
+                user_id: string;
+            };
+        };
+        responses: {
+            /** @description The asynchronous task summary to track the task state. */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["AsyncTaskResultSummary"];
+                };
+            };
+            /** @description The background task was submitted but there is no status tracking ID available. */
+            204: never;
+            /** @description Validation Error */
+            422: {
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    send_activation_email_api_users__user_id__send_activation_email_post: {
+        /** Sends activation email to user. */
+        parameters: {
+            /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+            header?: {
+                "run-as"?: string;
+            };
+            /** @description The ID of the user to get. */
+            path: {
+                user_id: string;
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                content: {
+                    "application/json": Record<string, never>;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     set_theme_api_users__user_id__theme__theme__put: {
         /** Set the user's theme choice */
         parameters: {
diff --git a/client/src/api/users.ts b/client/src/api/users.ts
index d3a2a7ac010f..7a59d96ea839 100644
--- a/client/src/api/users.ts
+++ b/client/src/api/users.ts
@@ -1,7 +1,15 @@
 import { fetcher } from "@/api/schema";
 
-export const recalculateDiskUsage = fetcher.path("/api/users/current/recalculate_disk_usage").method("put").create();
+export const createApiKey = fetcher.path("/api/users/{user_id}/api_key").method("post").create();
+export const deleteUser = fetcher.path("/api/users/{user_id}").method("delete").create();
 export const fetchQuotaUsages = fetcher.path("/api/users/{user_id}/usage").method("get").create();
+export const recalculateDiskUsage = fetcher.path("/api/users/current/recalculate_disk_usage").method("put").create();
+export const recalculateDiskUsageByUserId = fetcher
+    .path("/api/users/{user_id}/recalculate_disk_usage")
+    .method("put")
+    .create();
+export const sendActivationEmail = fetcher.path("/api/users/{user_id}/send_activation_email").method("post").create();
+export const undeleteUser = fetcher.path("/api/users/deleted/{user_id}/undelete").method("post").create();
 
 const getUsers = fetcher.path("/api/users").method("get").create();
 export async function getAllUsers() {
diff --git a/client/src/components/Grid/GridElements/GridBoolean.vue b/client/src/components/Grid/GridElements/GridBoolean.vue
new file mode 100644
index 000000000000..c98c590290a3
--- /dev/null
+++ b/client/src/components/Grid/GridElements/GridBoolean.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import { faCheck, faTimes } from "@fortawesome/free-solid-svg-icons";
+
+interface Props {
+    value?: boolean;
+}
+
+defineProps<Props>();
+</script>
+
+<template>
+    <icon v-if="value" :icon="faCheck" />
+    <icon v-else :icon="faTimes" />
+</template>
diff --git a/client/src/components/Grid/GridElements/GridOperations.vue b/client/src/components/Grid/GridElements/GridOperations.vue
index d135109286fc..8f1fae493d6b 100644
--- a/client/src/components/Grid/GridElements/GridOperations.vue
+++ b/client/src/components/Grid/GridElements/GridOperations.vue
@@ -4,12 +4,17 @@ import { faCaretDown } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 
 import type { Operation, RowData } from "@/components/Grid/configs/types";
+import { useConfig } from "@/composables/config";
+import type { GalaxyConfiguration } from "@/stores/configurationStore";
 
 library.add(faCaretDown);
 
+const { config, isConfigLoaded } = useConfig();
+
 interface Props {
     rowData: RowData;
     operations: Array<Operation>;
+    title: string;
 }
 
 const props = defineProps<Props>();
@@ -21,13 +26,13 @@ const emit = defineEmits<{
 /**
  * Availibility of operations might required certain conditions
  */
-function hasCondition(conditionHandler: (rowData: RowData) => Boolean) {
-    return conditionHandler ? conditionHandler(props.rowData) : true;
+function hasCondition(conditionHandler: (rowData: RowData, config: GalaxyConfiguration) => Boolean) {
+    return conditionHandler ? conditionHandler(props.rowData, config) : true;
 }
 </script>
 
 <template>
-    <span>
+    <span v-if="isConfigLoaded">
         <button
             id="grid-operations"
             data-toggle="dropdown"
@@ -35,9 +40,9 @@ function hasCondition(conditionHandler: (rowData: RowData) => Boolean) {
             aria-expanded="false"
             class="ui-link font-weight-bold">
             <FontAwesomeIcon icon="caret-down" class="fa-lg" />
-            <span class="font-weight-bold">{{ rowData.title }}</span>
+            <span class="font-weight-bold">{{ title }}</span>
         </button>
-        <div v-if="operations" class="dropdown-menu" aria-labelledby="dataset-dropdown">
+        <div class="dropdown-menu" aria-labelledby="dataset-dropdown">
             <span v-for="(operation, operationIndex) in operations" :key="operationIndex">
                 <button
                     v-if="operation && operation.condition && hasCondition(operation.condition)"
diff --git a/client/src/components/Grid/GridElements/GridText.vue b/client/src/components/Grid/GridElements/GridText.vue
index 7128471a6ccc..5b6ba76c81bf 100644
--- a/client/src/components/Grid/GridElements/GridText.vue
+++ b/client/src/components/Grid/GridElements/GridText.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 interface Props {
-    text?: string;
+    text?: string | number;
 }
 defineProps<Props>();
 </script>
diff --git a/client/src/components/Grid/GridList.test.js b/client/src/components/Grid/GridList.test.js
index 055e2ea625a1..6ed744727143 100644
--- a/client/src/components/Grid/GridList.test.js
+++ b/client/src/components/Grid/GridList.test.js
@@ -1,15 +1,32 @@
+import { createTestingPinia } from "@pinia/testing";
 import { mount } from "@vue/test-utils";
 import flushPromises from "flush-promises";
+import { PiniaVuePlugin } from "pinia";
 import { getLocalVue } from "tests/jest/helpers";
 
+import { useConfig } from "@/composables/config";
 import Filtering from "@/utils/filtering";
 
 import MountTarget from "./GridList.vue";
 
-const localVue = getLocalVue();
-
 jest.useFakeTimers();
 
+jest.mock("composables/config");
+useConfig.mockReturnValue({
+    config: {
+        value: {
+            disabled: false,
+            enabled: true,
+        },
+    },
+    isConfigLoaded: true,
+});
+
+jest.mock("vue-router/composables");
+
+const localVue = getLocalVue();
+localVue.use(PiniaVuePlugin);
+
 const testGrid = {
     actions: [
         {
@@ -33,24 +50,24 @@ const testGrid = {
             key: "operation",
             title: "operation",
             type: "operations",
-            condition: jest.fn(),
+            condition: jest.fn(() => true),
             operations: [
                 {
                     title: "operation-title-1",
                     icon: "operation-icon-1",
-                    condition: () => true,
+                    condition: (_, config) => config.value.enabled,
                     handler: jest.fn(),
                 },
                 {
                     title: "operation-title-2",
                     icon: "operation-icon-2",
-                    condition: () => false,
+                    condition: (_, config) => config.value.disabled,
                     handler: jest.fn(),
                 },
                 {
                     title: "operation-title-3",
                     icon: "operation-icon-3",
-                    condition: () => true,
+                    condition: (_, config) => config.value.enabled,
                     handler: () => ({
                         status: "success",
                         message: "Operation-3 has been executed.",
@@ -79,9 +96,11 @@ const testGrid = {
 };
 
 function createTarget(propsData) {
+    const pinia = createTestingPinia({ stubActions: false });
     return mount(MountTarget, {
         localVue,
         propsData,
+        pinia,
         stubs: {
             Icon: true,
         },
@@ -91,7 +110,7 @@ function createTarget(propsData) {
 describe("GridList", () => {
     it("basic rendering", async () => {
         const wrapper = createTarget({
-            config: testGrid,
+            gridConfig: testGrid,
         });
         const findInput = wrapper.find("[data-description='filter text input']");
         expect(findInput.attributes().placeholder).toBe("search tests");
@@ -123,7 +142,7 @@ describe("GridList", () => {
 
     it("header rendering", async () => {
         const wrapper = createTarget({
-            config: testGrid,
+            gridConfig: testGrid,
         });
         await wrapper.vm.$nextTick();
         for (const [fieldIndex, field] of Object.entries(testGrid.fields)) {
@@ -133,7 +152,7 @@ describe("GridList", () => {
 
     it("operation handling", async () => {
         const wrapper = createTarget({
-            config: testGrid,
+            gridConfig: testGrid,
         });
         await wrapper.vm.$nextTick();
         const dropdown = wrapper.find("[data-description='grid cell 0-2']");
@@ -155,7 +174,7 @@ describe("GridList", () => {
 
     it("filter handling", async () => {
         const wrapper = createTarget({
-            config: testGrid,
+            gridConfig: testGrid,
         });
         await wrapper.vm.$nextTick();
         const filterInput = wrapper.find("[data-description='filter text input']");
@@ -168,7 +187,7 @@ describe("GridList", () => {
 
     it("pagination", async () => {
         const wrapper = createTarget({
-            config: testGrid,
+            gridConfig: testGrid,
             limit: 2,
         });
         await wrapper.vm.$nextTick();
diff --git a/client/src/components/Grid/GridList.vue b/client/src/components/Grid/GridList.vue
index 16254deeec9a..357b728ca65b 100644
--- a/client/src/components/Grid/GridList.vue
+++ b/client/src/components/Grid/GridList.vue
@@ -1,14 +1,15 @@
 <script setup lang="ts">
 import { library } from "@fortawesome/fontawesome-svg-core";
-import { faCaretDown, faCaretUp } from "@fortawesome/free-solid-svg-icons";
+import { faCaretDown, faCaretUp, faShieldAlt } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { useDebounceFn, useEventBus } from "@vueuse/core";
 import { BAlert, BButton, BLink, BPagination } from "bootstrap-vue";
 import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 import { useRouter } from "vue-router/composables";
 
-import { Config, FieldHandler, Operation, RowData } from "./configs/types";
+import { FieldHandler, GridConfig, Operation, RowData } from "./configs/types";
 
+import GridBoolean from "./GridElements/GridBoolean.vue";
 import GridLink from "./GridElements/GridLink.vue";
 import GridOperations from "./GridElements/GridOperations.vue";
 import GridText from "./GridElements/GridText.vue";
@@ -21,11 +22,11 @@ import UtcDate from "@/components/UtcDate.vue";
 const eventBus = useEventBus<string>("grid-router-push");
 const router = useRouter();
 
-library.add(faCaretDown, faCaretUp);
+library.add(faCaretDown, faCaretUp, faShieldAlt);
 
 interface Props {
     // provide a grid configuration
-    config: Config;
+    gridConfig: GridConfig;
     // debounce delay
     delay?: number;
     // rows per page to be shown
@@ -56,8 +57,8 @@ const loading = ref(true);
 const isAvailable = computed(() => !loading.value && totalRows.value > 0);
 
 // sort references
-const sortBy = ref(props.config ? props.config.sortBy : "");
-const sortDesc = ref(props.config ? props.config.sortDesc : false);
+const sortBy = ref(props.gridConfig ? props.gridConfig.sortBy : "");
+const sortDesc = ref(props.gridConfig ? props.gridConfig.sortDesc : false);
 
 // filtering refs and handlers
 const filterText = ref("");
@@ -73,7 +74,7 @@ const hideMessage = useDebounceFn(() => {
  * Manually set filter value, used for tags and `SharingIndicators`
  */
 function applyFilter(filter: string, value: string | boolean, quoted = false) {
-    const filtering = props.config?.filtering;
+    const filtering = props.gridConfig?.filtering;
     const quotedValue = quoted ? `'${value}'` : value;
     if (filtering) {
         filterText.value = filtering.setFilterValue(filterText.value, filter, quotedValue.toString()) || "";
@@ -84,10 +85,10 @@ function applyFilter(filter: string, value: string | boolean, quoted = false) {
  * Request grid data
  */
 async function getGridData() {
-    if (props.config) {
+    if (props.gridConfig) {
         try {
             const offset = props.limit * (currentPage.value - 1);
-            const [responseData, responseTotal] = await props.config.getData(
+            const [responseData, responseTotal] = await props.gridConfig.getData(
                 offset,
                 props.limit,
                 searchTerm.value,
@@ -183,19 +184,19 @@ watch(operationMessage, () => {
 </script>
 
 <template>
-    <div class="d-flex flex-column overflow-auto">
+    <div :id="gridConfig.id" class="d-flex flex-column overflow-auto">
         <BAlert v-if="!!errorMessage" variant="danger" show>{{ errorMessage }}</BAlert>
         <BAlert v-if="!!operationMessage" :variant="operationStatus" fade show>{{ operationMessage }}</BAlert>
         <div class="grid-header d-flex justify-content-between pb-2">
             <div>
                 <h1 class="m-0" data-description="grid title">
-                    {{ config.title }}
+                    {{ gridConfig.title }}
                 </h1>
                 <FilterMenu
                     class="py-2"
-                    :name="config.plural"
-                    :placeholder="`search ${config.plural.toLowerCase()}`"
-                    :filter-class="config.filtering"
+                    :name="gridConfig.plural"
+                    :placeholder="`search ${gridConfig.plural.toLowerCase()}`"
+                    :filter-class="gridConfig.filtering"
                     :filter-text.sync="filterText"
                     :loading="loading"
                     :show-advanced.sync="showAdvanced"
@@ -204,7 +205,7 @@ watch(operationMessage, () => {
             </div>
             <div v-if="!showAdvanced" class="py-3">
                 <BButton
-                    v-for="(action, actionIndex) in config.actions"
+                    v-for="(action, actionIndex) in gridConfig.actions"
                     :key="actionIndex"
                     class="m-1"
                     size="sm"
@@ -218,20 +219,20 @@ watch(operationMessage, () => {
         </div>
         <LoadingSpan v-if="loading" />
         <BAlert v-else-if="!isAvailable" variant="info" show>
-            <span v-if="searchTerm" v-localize>
-                No entries found for: <b>{{ searchTerm }}</b
-                >.
+            <span v-if="searchTerm">
+                <span v-localize>Nothing found with:</span>
+                <b>{{ searchTerm }}</b>
             </span>
             <span v-else v-localize> No entries found. </span>
         </BAlert>
         <table v-else class="grid-table">
             <thead>
                 <th
-                    v-for="(fieldEntry, fieldIndex) in config.fields"
+                    v-for="(fieldEntry, fieldIndex) in gridConfig.fields"
                     :key="fieldIndex"
                     class="text-nowrap px-2"
                     :data-description="`grid header ${fieldIndex}`">
-                    <span v-if="config.sortKeys.includes(fieldEntry.key)">
+                    <span v-if="gridConfig.sortKeys.includes(fieldEntry.key)">
                         <BLink @click="onSort(fieldEntry.key)">
                             <span>{{ fieldEntry.title || fieldEntry.key }}</span>
                             <span v-if="sortBy === fieldEntry.key">
@@ -245,34 +246,40 @@ watch(operationMessage, () => {
             </thead>
             <tr v-for="(rowData, rowIndex) in gridData" :key="rowIndex" :class="{ 'grid-dark-row': rowIndex % 2 }">
                 <td
-                    v-for="(fieldEntry, fieldIndex) in config.fields"
+                    v-for="(fieldEntry, fieldIndex) in gridConfig.fields"
                     :key="fieldIndex"
                     class="px-2 py-3"
-                    :style="{ width: `${fieldEntry.width}%` }"
-                    :data-description="`grid cell ${rowIndex}-${fieldIndex}`">
-                    <GridOperations
-                        v-if="fieldEntry.type == 'operations' && fieldEntry.operations"
-                        :operations="fieldEntry.operations"
-                        :row-data="rowData"
-                        @execute="onOperation($event, rowData)" />
-                    <GridText v-else-if="fieldEntry.type == 'text'" :text="rowData[fieldEntry.key]" />
-                    <GridLink
-                        v-else-if="fieldEntry.type == 'link'"
-                        :text="rowData[fieldEntry.key]"
-                        @click="fieldEntry.handler && fieldEntry.handler(rowData)" />
-                    <SharingIndicators
-                        v-else-if="fieldEntry.type == 'sharing'"
-                        :object="rowData"
-                        @filter="onFilter($event)" />
-                    <UtcDate v-else-if="fieldEntry.type == 'date'" :date="rowData[fieldEntry.key]" mode="elapsed" />
-                    <StatelessTags
-                        v-else-if="fieldEntry.type == 'tags'"
-                        clickable
-                        :value="rowData[fieldEntry.key]"
-                        :disabled="fieldEntry.disabled"
-                        @input="onTagInput(rowData, $event, fieldEntry.handler)"
-                        @tag-click="applyFilter('tag', $event, true)" />
-                    <span v-else v-localize> Data not available. </span>
+                    :style="{ width: `${fieldEntry.width}%` }">
+                    <div
+                        v-if="!fieldEntry.condition || fieldEntry.condition(rowData)"
+                        :data-description="`grid cell ${rowIndex}-${fieldIndex}`">
+                        <GridOperations
+                            v-if="fieldEntry.type == 'operations' && fieldEntry.operations"
+                            :operations="fieldEntry.operations"
+                            :row-data="rowData"
+                            :title="rowData[fieldEntry.key]"
+                            @execute="onOperation($event, rowData)" />
+                        <GridBoolean v-else-if="fieldEntry.type == 'boolean'" :value="rowData[fieldEntry.key]" />
+                        <GridText v-else-if="fieldEntry.type == 'text'" :text="rowData[fieldEntry.key]" />
+                        <GridLink
+                            v-else-if="fieldEntry.type == 'link'"
+                            :text="rowData[fieldEntry.key]"
+                            @click="fieldEntry.handler && fieldEntry.handler(rowData)" />
+                        <SharingIndicators
+                            v-else-if="fieldEntry.type == 'sharing'"
+                            :object="rowData"
+                            @filter="onFilter($event)" />
+                        <UtcDate v-else-if="fieldEntry.type == 'date'" :date="rowData[fieldEntry.key]" mode="elapsed" />
+                        <StatelessTags
+                            v-else-if="fieldEntry.type == 'tags'"
+                            clickable
+                            :value="rowData[fieldEntry.key]"
+                            :disabled="fieldEntry.disabled"
+                            @input="onTagInput(rowData, $event, fieldEntry.handler)"
+                            @tag-click="applyFilter('tag', $event, true)" />
+                        <span v-else v-localize> Not available. </span>
+                    </div>
+                    <FontAwesomeIcon v-else icon="fa-shield-alt" />
                 </td>
             </tr>
         </table>
diff --git a/client/src/components/Grid/configs/adminUsers.test.js b/client/src/components/Grid/configs/adminUsers.test.js
new file mode 100644
index 000000000000..f10d62a77e2f
--- /dev/null
+++ b/client/src/components/Grid/configs/adminUsers.test.js
@@ -0,0 +1,52 @@
+import adminUsers from "./adminUsers";
+
+describe("AdminUsers", () => {
+    it("configuration", async () => {
+        const fields = adminUsers.fields;
+        expect(fields.length).toBe(10);
+        const fieldEmail = fields[0];
+        expect(fieldEmail.key).toBe("email");
+        expect(fieldEmail.type).toBe("operations");
+        for (const purged of [true, false]) {
+            expect(fieldEmail.condition({ purged })).toBe(!purged);
+        }
+        const ops = fieldEmail.operations;
+        const titles = [
+            "Information",
+            "Roles",
+            "Reset",
+            "Recalculate",
+            "Activate",
+            "Send",
+            "Key",
+            "Impersonate",
+            "Delete",
+            "Purge",
+            "Restore",
+        ];
+        titles.forEach((title, index) => {
+            expect(ops[index].title).toContain(title);
+        });
+        for (const a of [true, false]) {
+            expect(ops[0].condition({ deleted: !a })).toBe(a);
+            expect(ops[1].condition({ deleted: !a })).toBe(a);
+            expect(ops[2].condition({ deleted: !a })).toBe(a);
+            expect(ops[3].condition({ deleted: !a })).toBe(a);
+            expect(ops[6].condition({ deleted: !a })).toBe(a);
+            for (const b of [true, false]) {
+                expect(ops[4].condition({ deleted: !a }, { value: { user_activation_on: b } })).toBe(a && b);
+                expect(ops[5].condition({ deleted: !a }, { value: { user_activation_on: b } })).toBe(a && b);
+                expect(ops[7].condition({ deleted: !a }, { value: { allow_user_impersonation: b } })).toBe(a && b);
+                expect(ops[8].condition({ deleted: !a }, { value: { allow_user_deletion: b } })).toBe(a && b);
+                for (const c of [true, false]) {
+                    expect(ops[9].condition({ deleted: a, purged: !b }, { value: { allow_user_deletion: c } })).toBe(
+                        a && b && c
+                    );
+                    expect(ops[10].condition({ deleted: a, purged: !b }, { value: { allow_user_deletion: c } })).toBe(
+                        a && b && c
+                    );
+                }
+            }
+        }
+    });
+});
diff --git a/client/src/components/Grid/configs/adminUsers.ts b/client/src/components/Grid/configs/adminUsers.ts
new file mode 100644
index 000000000000..d4e0158e2817
--- /dev/null
+++ b/client/src/components/Grid/configs/adminUsers.ts
@@ -0,0 +1,339 @@
+import {
+    faBolt,
+    faCalculator,
+    faEnvelope,
+    faKey,
+    faMask,
+    faPlus,
+    faTrash,
+    faTrashRestore,
+    faUnlock,
+    faUser,
+    faUsers,
+} from "@fortawesome/free-solid-svg-icons";
+import { useEventBus } from "@vueuse/core";
+import axios from "axios";
+
+import { createApiKey, deleteUser, recalculateDiskUsageByUserId, sendActivationEmail, undeleteUser } from "@/api/users";
+import type { GalaxyConfiguration } from "@/stores/configurationStore";
+import Filtering, { contains, equals, toBool, type ValidFilter } from "@/utils/filtering";
+import { withPrefix } from "@/utils/redirect";
+import { errorMessageAsString } from "@/utils/simple-error";
+
+import type { ActionArray, FieldArray, GridConfig } from "./types";
+
+const { emit } = useEventBus<string>("grid-router-push");
+
+/**
+ * Local types
+ */
+type UserEntry = Record<string, unknown>;
+
+/**
+ * Request and return data from server
+ */
+async function getData(offset: number, limit: number, search: string, sort_by: string, sort_desc: boolean) {
+    const query = {
+        limit: String(limit),
+        offset: String(offset),
+        search: search,
+        sort_by: sort_by,
+        sort_desc: String(sort_desc),
+    };
+    const queryString = new URLSearchParams(query).toString();
+    const { data } = await axios.get(withPrefix(`/admin/users_list?${queryString}`));
+    return [data.rows, data.rows_total];
+}
+
+/**
+ * Actions are grid-wide operations
+ */
+const actions: ActionArray = [
+    {
+        title: "Create New User",
+        icon: faPlus,
+        handler: () => {
+            emit("/admin/users/create");
+        },
+    },
+];
+
+/**
+ * Declare columns to be displayed
+ */
+const fields: FieldArray = [
+    {
+        key: "email",
+        title: "Email",
+        type: "operations",
+        condition: (data: UserEntry) => !data.purged,
+        operations: [
+            {
+                title: "Manage Information",
+                icon: faUser,
+                condition: (data: UserEntry) => !data.deleted,
+                handler: (data: UserEntry) => {
+                    emit(`/user/information?id=${data.id}`);
+                },
+            },
+            {
+                title: "Manage Roles and Groups",
+                icon: faUsers,
+                condition: (data: UserEntry) => !data.deleted,
+                handler: (data: UserEntry) => {
+                    emit(`/admin/form/manage_roles_and_groups_for_user?id=${data.id}`);
+                },
+            },
+            {
+                title: "Reset Password",
+                icon: faUnlock,
+                condition: (data: UserEntry) => !data.deleted,
+                handler: (data: UserEntry) => {
+                    emit(`/admin/form/reset_user_password?id=${data.id}`);
+                },
+            },
+            {
+                title: "Recalculate Disk Usage",
+                icon: faCalculator,
+                condition: (data: UserEntry) => !data.deleted,
+                handler: async (data: UserEntry) => {
+                    try {
+                        await recalculateDiskUsageByUserId({ user_id: String(data.id) });
+                        return {
+                            status: "success",
+                            message: `Disk usage of '${data.username}' has been recalculated.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to recalculate disk usage of '${data.username}': ${errorMessageAsString(
+                                e
+                            )}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Activate",
+                icon: faBolt,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.user_activation_on && !data.deleted;
+                },
+                handler: async (data: UserEntry) => {
+                    try {
+                        await axios.put(withPrefix(`/api/users/${data.id}`), { active: true });
+                        return {
+                            status: "success",
+                            message: `'${data.username}' has been activated.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to activate '${data.username}': ${errorMessageAsString(e)}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Send Activation Email",
+                icon: faEnvelope,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.user_activation_on && !data.deleted;
+                },
+                handler: async (data: UserEntry) => {
+                    try {
+                        await sendActivationEmail({ user_id: String(data.id) });
+                        return {
+                            status: "success",
+                            message: `Activation email has been sent to '${data.username}'.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to send activation email to '${data.username}': ${errorMessageAsString(
+                                e
+                            )}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Generate New API Key",
+                icon: faKey,
+                condition: (data: UserEntry) => !data.deleted,
+                handler: async (data: UserEntry) => {
+                    try {
+                        await createApiKey({ user_id: String(data.id) });
+                        return {
+                            status: "success",
+                            message: `New API Key for '${data.username}' has been generated.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to generate new API Key for '${data.username}': ${errorMessageAsString(
+                                e
+                            )}.`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Impersonate User",
+                icon: faMask,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.allow_user_impersonation && !data.deleted;
+                },
+                handler: (data: UserEntry) => {
+                    window.location.href = withPrefix(`/admin/impersonate?id=${String(data.id)}`);
+                },
+            },
+            {
+                title: "Delete",
+                icon: faTrash,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.allow_user_deletion && !data.deleted;
+                },
+                handler: async (data: UserEntry) => {
+                    try {
+                        await deleteUser({ user_id: String(data.id), purge: false });
+                        return {
+                            status: "success",
+                            message: `'${data.username}' has been deleted.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to delete '${data.username}': ${errorMessageAsString(e)}`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Purge",
+                icon: faTrash,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.allow_user_deletion && data.deleted && !data.purged;
+                },
+                handler: async (data: UserEntry) => {
+                    try {
+                        await deleteUser({ user_id: String(data.id), purge: true });
+                        return {
+                            status: "success",
+                            message: `'${data.username}' has been purged.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to purge '${data.username}': ${errorMessageAsString(e)}`,
+                        };
+                    }
+                },
+            },
+            {
+                title: "Restore",
+                icon: faTrashRestore,
+                condition: (data: UserEntry, config: GalaxyConfiguration) => {
+                    return config.value.allow_user_deletion && data.deleted && !data.purged;
+                },
+                handler: async (data: UserEntry) => {
+                    try {
+                        await undeleteUser({ user_id: String(data.id) });
+                        return {
+                            status: "success",
+                            message: `'${data.username}' has been restored.`,
+                        };
+                    } catch (e) {
+                        return {
+                            status: "danger",
+                            message: `Failed to restore '${data.username}': ${errorMessageAsString(e)}`,
+                        };
+                    }
+                },
+            },
+        ],
+    },
+    {
+        key: "username",
+        title: "Username",
+        type: "text",
+        condition: (data: UserEntry) => !data.purged,
+    },
+    {
+        key: "last_login",
+        title: "Last Login",
+        type: "text",
+    },
+    {
+        key: "disk_usage",
+        title: "Disk Usage",
+        type: "text",
+    },
+    {
+        key: "status",
+        title: "Status",
+        type: "text",
+    },
+    {
+        key: "create_time",
+        title: "Created",
+        type: "date",
+    },
+    {
+        key: "active",
+        title: "Active",
+        type: "boolean",
+    },
+    {
+        key: "groups",
+        title: "Groups",
+        type: "text",
+    },
+    {
+        key: "roles",
+        title: "Roles",
+        type: "text",
+    },
+    {
+        key: "external",
+        title: "External",
+        type: "boolean",
+    },
+];
+
+const validFilters: Record<string, ValidFilter<string | boolean | undefined>> = {
+    email: { placeholder: "email", type: String, handler: contains("email"), menuItem: true },
+    username: { placeholder: "username", type: String, handler: contains("username"), menuItem: true },
+    deleted: {
+        placeholder: "Filter on deleted users",
+        type: Boolean,
+        boolType: "is",
+        handler: equals("deleted", "deleted", toBool),
+        menuItem: true,
+    },
+    purged: {
+        placeholder: "Filter on purged users",
+        type: Boolean,
+        boolType: "is",
+        handler: equals("purged", "purged", toBool),
+        menuItem: true,
+    },
+};
+
+/**
+ * Grid configuration
+ */
+const gridConfig: GridConfig = {
+    id: "users-grid",
+    actions: actions,
+    fields: fields,
+    filtering: new Filtering(validFilters, undefined, false, false),
+    getData: getData,
+    plural: "Users",
+    sortBy: "email",
+    sortDesc: true,
+    sortKeys: ["active", "create_time", "disk_usage", "email", "external", "last_login", "status", "username"],
+    title: "Users",
+};
+
+export default gridConfig;
diff --git a/client/src/components/Grid/configs/types.ts b/client/src/components/Grid/configs/types.ts
index 2fc41e04a35d..95385c56351d 100644
--- a/client/src/components/Grid/configs/types.ts
+++ b/client/src/components/Grid/configs/types.ts
@@ -1,5 +1,6 @@
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
 
+import type { GalaxyConfiguration } from "@/stores/configurationStore";
 import Filtering from "@/utils/filtering";
 
 export interface Action {
@@ -10,7 +11,8 @@ export interface Action {
 
 export type ActionArray = Array<Action>;
 
-export interface Config {
+export interface GridConfig {
+    id: string;
     actions?: ActionArray;
     fields: FieldArray;
     filtering: Filtering<any>;
@@ -40,7 +42,7 @@ export type FieldHandler = (data: RowData) => void;
 export interface Operation {
     title: string;
     icon: IconDefinition;
-    condition?: (data: RowData) => boolean;
+    condition?: (data: RowData, config: GalaxyConfiguration) => boolean;
     handler: (data: RowData) => OperationHandlerReturn;
 }
 
@@ -53,4 +55,4 @@ type OperationHandlerReturn = Promise<OperationHandlerMessage> | void;
 
 export type RowData = Record<string, unknown>;
 
-type validTypes = "date" | "link" | "operations" | "sharing" | "tags" | "text";
+type validTypes = "boolean" | "date" | "link" | "operations" | "sharing" | "tags" | "text";
diff --git a/client/src/components/Grid/configs/visualizations.ts b/client/src/components/Grid/configs/visualizations.ts
index 1e84d36eaca0..61a1f947a4cf 100644
--- a/client/src/components/Grid/configs/visualizations.ts
+++ b/client/src/components/Grid/configs/visualizations.ts
@@ -8,7 +8,7 @@ import Filtering, { contains, equals, expandNameTag, toBool, type ValidFilter }
 import { withPrefix } from "@/utils/redirect";
 import { errorMessageAsString, rethrowSimple } from "@/utils/simple-error";
 
-import type { ActionArray, Config, FieldArray } from "./types";
+import type { ActionArray, FieldArray, GridConfig } from "./types";
 
 const { emit } = useEventBus<string>("grid-router-push");
 
@@ -237,7 +237,8 @@ const validFilters: Record<string, ValidFilter<string | boolean | undefined>> =
 /**
  * Grid configuration
  */
-const config: Config = {
+const gridConfig: GridConfig = {
+    id: "visualizations-grid",
     actions: actions,
     fields: fields,
     filtering: new Filtering(validFilters, undefined, false, false),
@@ -248,4 +249,5 @@ const config: Config = {
     sortKeys: ["create_time", "title", "update_time"],
     title: "Saved Visualizations",
 };
-export default config;
+
+export default gridConfig;
diff --git a/client/src/components/Grid/configs/visualizationsPublished.ts b/client/src/components/Grid/configs/visualizationsPublished.ts
index 0be07fb90dbe..5c37ee06cdf9 100644
--- a/client/src/components/Grid/configs/visualizationsPublished.ts
+++ b/client/src/components/Grid/configs/visualizationsPublished.ts
@@ -2,6 +2,8 @@ import { fetcher } from "@/api/schema";
 import Filtering, { contains, expandNameTag, type ValidFilter } from "@/utils/filtering";
 import { withPrefix } from "@/utils/redirect";
 
+import type { FieldArray, GridConfig } from "./types";
+
 /**
  * Api endpoint handlers
  */
@@ -34,12 +36,12 @@ async function getData(offset: number, limit: number, search: string, sort_by: s
 /**
  * Declare columns to be displayed
  */
-const fields = [
+const fields: FieldArray = [
     {
         title: "Title",
         key: "title",
         type: "link",
-        width: "30%",
+        width: 30,
         handler: (data: VisualizationEntry) => {
             window.location.href = withPrefix(`/plugins/visualizations/${data.type}/saved?id=${data.id}`);
         },
@@ -84,7 +86,8 @@ const validFilters: Record<string, ValidFilter<string | boolean | undefined>> =
 /**
  * Grid configuration
  */
-export default {
+const gridConfig: GridConfig = {
+    id: "visualizations-published-grid",
     fields: fields,
     filtering: new Filtering(validFilters, undefined, false, false),
     getData: getData,
@@ -94,3 +97,5 @@ export default {
     sortKeys: ["create_time", "title", "update_time"],
     title: "Published Visualizations",
 };
+
+export default gridConfig;
diff --git a/client/src/components/plugins/icons.js b/client/src/components/plugins/icons.js
index ea99ce1fe0fd..f0d6d8688efe 100644
--- a/client/src/components/plugins/icons.js
+++ b/client/src/components/plugins/icons.js
@@ -4,6 +4,7 @@ import {
     faBell,
     faBolt,
     faBurn,
+    faCalculator,
     faChartArea,
     faChartBar,
     faCheckSquare,
@@ -57,6 +58,7 @@ library.add(
     faBell,
     faBolt,
     faBurn,
+    faCalculator,
     faChartArea,
     faChartBar,
     faCheckSquare,
diff --git a/client/src/entry/analysis/modules/Admin.vue b/client/src/entry/analysis/modules/Admin.vue
index 33d9abf634d4..25b052ab08af 100644
--- a/client/src/entry/analysis/modules/Admin.vue
+++ b/client/src/entry/analysis/modules/Admin.vue
@@ -23,7 +23,7 @@ const panelProperties = computed(() => {
             <AdminPanel v-bind="panelProperties" />
         </FlexPanel>
         <div id="center" class="overflow-auto p-3 w-100">
-            <router-view :key="$route.fullPath" />
+            <router-view :key="$route.fullPath" class="h-100" />
         </div>
     </div>
 </template>
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index 69ce1f28be04..b0618f00a18d 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -7,8 +7,8 @@ import DatasetAttributes from "components/DatasetInformation/DatasetAttributes";
 import DatasetDetails from "components/DatasetInformation/DatasetDetails";
 import DatasetError from "components/DatasetInformation/DatasetError";
 import FormGeneric from "components/Form/FormGeneric";
-import visualizationsGrid from "components/Grid/configs/visualizations";
-import visualizationsPublishedGrid from "components/Grid/configs/visualizationsPublished";
+import visualizationsGridConfig from "components/Grid/configs/visualizations";
+import visualizationsPublishedGridConfig from "components/Grid/configs/visualizationsPublished";
 import GridHistory from "components/Grid/GridHistory";
 import GridList from "components/Grid/GridList";
 import HistoryExportTasks from "components/History/Export/HistoryExport";
@@ -466,14 +466,14 @@ export function getRouter(Galaxy) {
                         path: "visualizations/list",
                         component: GridList,
                         props: {
-                            config: visualizationsGrid,
+                            gridConfig: visualizationsGridConfig,
                         },
                     },
                     {
                         path: "visualizations/list_published",
                         component: GridList,
                         props: {
-                            config: visualizationsPublishedGrid,
+                            gridConfig: visualizationsPublishedGridConfig,
                         },
                     },
                     {
diff --git a/client/src/entry/analysis/routes/admin-routes.js b/client/src/entry/analysis/routes/admin-routes.js
index bf8a7de1a042..7d30e68abc59 100644
--- a/client/src/entry/analysis/routes/admin-routes.js
+++ b/client/src/entry/analysis/routes/admin-routes.js
@@ -18,7 +18,9 @@ import NotificationsManagement from "components/admin/Notifications/Notification
 import ResetMetadata from "components/admin/ResetMetadata";
 import SanitizeAllow from "components/admin/SanitizeAllow";
 import FormGeneric from "components/Form/FormGeneric";
+import adminUsersGridConfig from "components/Grid/configs/adminUsers";
 import Grid from "components/Grid/Grid";
+import GridList from "components/Grid/GridList";
 import RegisterForm from "components/Login/RegisterForm";
 import Toolshed from "components/Toolshed/Index";
 import Admin from "entry/analysis/modules/Admin";
@@ -153,9 +155,9 @@ export default [
             },
             {
                 path: "users",
-                component: Grid,
+                component: GridList,
                 props: {
-                    urlBase: "admin/users_list",
+                    gridConfig: adminUsersGridConfig,
                 },
             },
             {
diff --git a/client/src/stores/configurationStore.ts b/client/src/stores/configurationStore.ts
index 45508619252f..1cd70b0d2c55 100644
--- a/client/src/stores/configurationStore.ts
+++ b/client/src/stores/configurationStore.ts
@@ -4,7 +4,7 @@ import { computed, ref } from "vue";
 import { fetcher } from "@/api/schema";
 
 // Temporary set to any until schema model is defined
-type GalaxyConfiguration = any;
+export type GalaxyConfiguration = any;
 
 const fetchConfiguration = fetcher.path("/api/configuration").method("get").create();
 
diff --git a/client/src/utils/navigation/navigation.yml b/client/src/utils/navigation/navigation.yml
index 1ba8b674d44a..e1dba3b8c8ca 100644
--- a/client/src/utils/navigation/navigation.yml
+++ b/client/src/utils/navigation/navigation.yml
@@ -955,7 +955,7 @@ admin:
     dm_table_button: '#${data_table}-table'
     dm_table_card: '#data-table-card'
     users_grid: '#users-grid'
-    users_grid_create_button: '.manage-table-actions .action-button'
+    users_grid_create_button: '[data-description="grid action create new user"]'
     groups_grid_create_button: '.manage-table-actions .action-button'
     registration_form: 'form#registration'
     groups_grid: '#groups-grid'
diff --git a/lib/galaxy/managers/configuration.py b/lib/galaxy/managers/configuration.py
index e31b8424f83c..a0f68155e3ef 100644
--- a/lib/galaxy/managers/configuration.py
+++ b/lib/galaxy/managers/configuration.py
@@ -205,6 +205,7 @@ def _config_is_truthy(item, key, **context):
             ),
             "object_store_allows_id_selection": lambda item, key, **context: object_store.object_store_allows_id_selection(),
             "object_store_ids_allowing_selection": lambda item, key, **context: object_store.object_store_ids_allowing_selection(),
+            "user_activation_on": _use_config,
             "user_library_import_dir_available": lambda item, key, **context: bool(item.get("user_library_import_dir")),
             "welcome_directory": _use_config,
             "themes": _use_config,
diff --git a/lib/galaxy/managers/users.py b/lib/galaxy/managers/users.py
index 3b6084b04a68..eb067d0af8ca 100644
--- a/lib/galaxy/managers/users.py
+++ b/lib/galaxy/managers/users.py
@@ -493,6 +493,15 @@ def __set_password(self, trans, user, password, confirm):
         else:
             return "Failed to determine user, access denied."
 
+    def impersonate(self, trans, user):
+        if not trans.app.config.allow_user_impersonation:
+            raise exceptions.Message("User impersonation is not enabled in this instance of Galaxy.")
+        if user:
+            trans.handle_user_logout()
+            trans.handle_user_login(user)
+        else:
+            raise exceptions.Message("Please provide a valid user.")
+
     def send_activation_email(self, trans, email, username):
         """
         Send the verification email containing the activation link to the user's email.
@@ -759,11 +768,12 @@ class UserDeserializer(base.ModelDeserializer):
 
     def add_deserializers(self):
         super().add_deserializers()
-        history_deserializers: Dict[str, base.Deserializer] = {
+        user_deserializers: Dict[str, base.Deserializer] = {
+            "active": self.default_deserializer,
             "username": self.deserialize_username,
             "preferred_object_store_id": self.deserialize_preferred_object_store_id,
         }
-        self.deserializers.update(history_deserializers)
+        self.deserializers.update(user_deserializers)
 
     def deserialize_preferred_object_store_id(self, item: Any, key: Any, val: Any, **context):
         preferred_object_store_id = val
diff --git a/lib/galaxy/web/framework/helpers/grids.py b/lib/galaxy/web/framework/helpers/grids.py
index c4fd321c1d65..d34aac73829f 100644
--- a/lib/galaxy/web/framework/helpers/grids.py
+++ b/lib/galaxy/web/framework/helpers/grids.py
@@ -28,6 +28,7 @@
 from galaxy.util import (
     restore_text,
     sanitize_text,
+    string_as_bool,
     unicodify,
 )
 from galaxy.web.framework import (
@@ -56,6 +57,7 @@ def __init__(
         label_id_prefix=None,
         target=None,
         delayed=False,
+        escape=True,
     ):
         """Create a grid column."""
         self.label = label
@@ -70,6 +72,7 @@ def __init__(
         self.visible = visible
         self.filterable = filterable
         self.delayed = delayed
+        self.escape = escape
         # Column must have a key to be sortable.
         self.sortable = self.key is not None and sortable
         self.label_id_prefix = label_id_prefix or ""
@@ -83,7 +86,10 @@ def get_value(self, trans, grid, item):
             value = None
         if self.format:
             value = self.format(value)
-        return escape(unicodify(value))
+        if self.escape:
+            return escape(unicodify(value))
+        else:
+            return value
 
     def get_link(self, trans, grid, item):
         if self.link and self.link(item):
@@ -1046,3 +1052,71 @@ def apply_query_filter(self, trans, query, **kwargs):
         # (gvk) Is this method necessary?  Why not simply build the entire query,
         # including applying filters in the build_initial_query() method?
         return query
+
+
+class GridData:
+    """
+    Specifies the content a grid (data table).
+    """
+
+    model_class: Optional[type] = None
+    columns: List[GridColumn] = []
+    default_limit: int = 1000
+
+    def __init__(self):
+        # If a column does not have a model class, set the column's model class
+        # to be the grid's model class.
+        for column in self.columns:
+            if not column.model_class:
+                column.model_class = self.model_class
+
+    def __call__(self, trans, **kwargs):
+        limit = kwargs.get("limit", self.default_limit)
+        offset = kwargs.get("offset", 0)
+
+        # Build initial query
+        query = self.build_initial_query(trans, **kwargs)
+        query = self.apply_query_filter(query, **kwargs)
+
+        # Process sort arguments.
+        sort_by = kwargs.get("sort_by", self.default_sort_key)
+        sort_desc = string_as_bool(kwargs.get("sort_desc", True))
+        for column in self.columns:
+            if column.key == sort_by:
+                query = column.sort(trans, query, not sort_desc, column_name=sort_by)
+                break
+
+        # Process limit and offset.
+        rows_total = query.count()
+        query = query.limit(limit).offset(offset)
+
+        # Populate and return response
+        grid_config = {
+            "rows": [],
+            "rows_total": rows_total,
+        }
+        for row in query:
+            row_dict = {
+                "id": trans.security.encode_id(row.id),
+            }
+            for column in self.columns:
+                value = column.get_value(trans, self, row)
+                row_dict[column.key] = value
+            grid_config["rows"].append(row_dict)
+        return grid_config
+
+    # ---- Override these ----------------------------------------------------
+    def handle_operation(self, trans, operation, ids, **kwargs):
+        pass
+
+    def get_current_item(self, trans, **kwargs):
+        return None
+
+    def build_initial_query(self, trans, **kwargs):
+        return trans.sa_session.query(self.model_class)
+
+    def apply_query_filter(self, trans, query, **kwargs):
+        # Applies a database filter that holds for all items in the grid.
+        # (gvk) Is this method necessary?  Why not simply build the entire query,
+        # including applying filters in the build_initial_query() method?
+        return query
diff --git a/lib/galaxy/webapps/galaxy/api/users.py b/lib/galaxy/webapps/galaxy/api/users.py
index 1ab007693020..ae2b0d78a3f6 100644
--- a/lib/galaxy/webapps/galaxy/api/users.py
+++ b/lib/galaxy/webapps/galaxy/api/users.py
@@ -172,7 +172,25 @@ def recalculate_disk_usage(
 
         Please use `/api/users/current/recalculate_disk_usage` instead.
         """
-        result = self.service.recalculate_disk_usage(trans)
+        user_id = getattr(trans.user, "id", None)
+        if not user_id:
+            raise exceptions.AuthenticationRequired("Only registered users can recalculate disk usage.")
+        else:
+            result = self.service.recalculate_disk_usage(trans, user_id)
+            return Response(status_code=status.HTTP_204_NO_CONTENT) if result is None else result
+
+    @router.put(
+        "/api/users/{user_id}/recalculate_disk_usage",
+        summary=RecalculateDiskUsageSummary,
+        responses=RecalculateDiskUsageResponseDescriptions,
+        require_admin=True,
+    )
+    def recalculate_disk_usage_by_user_id(
+        self,
+        trans: ProvidesUserContext = DependsOnTrans,
+        user_id: DecodedDatabaseIdField = UserIdPathParamQueryParam,
+    ):
+        result = self.service.recalculate_disk_usage(trans, user_id)
         return Response(status_code=status.HTTP_204_NO_CONTENT) if result is None else result
 
     @router.get(
@@ -674,6 +692,23 @@ def delete(
                 raise exceptions.InsufficientPermissionsException("You may only delete your own account.")
         return self.service.user_to_detailed_model(user_to_update)
 
+    @router.post(
+        "/api/users/{user_id}/send_activation_email",
+        name="send_activation_email",
+        summary="Sends activation email to user.",
+        require_admin=True,
+    )
+    def send_activation_email(
+        self,
+        trans: ProvidesUserContext = DependsOnTrans,
+        user_id: DecodedDatabaseIdField = UserIdPathParamQueryParam,
+    ):
+        user = trans.sa_session.query(trans.model.User).get(user_id)
+        if not user:
+            raise exceptions.ObjectNotFound("User not found for given id.")
+        if not self.service.user_manager.send_activation_email(trans, user.email, user.username):
+            raise exceptions.MessageException("Unable to send activation email.")
+
 
 class UserAPIController(BaseGalaxyAPIController, UsesTagsMixin, BaseUIController, UsesFormDefinitionsMixin):
     service: UsersService = depends(UsersService)
diff --git a/lib/galaxy/webapps/galaxy/controllers/admin.py b/lib/galaxy/webapps/galaxy/controllers/admin.py
index 5495f24943fb..ade0de78b7ca 100644
--- a/lib/galaxy/webapps/galaxy/controllers/admin.py
+++ b/lib/galaxy/webapps/galaxy/controllers/admin.py
@@ -4,6 +4,7 @@
 from sqlalchemy import (
     false,
     func,
+    true,
 )
 from typing_extensions import TypedDict
 
@@ -19,12 +20,17 @@
 from galaxy.managers.quotas import QuotaManager
 from galaxy.model import tool_shed_install as install_model
 from galaxy.model.base import transaction
+from galaxy.model.index_filter_util import (
+    raw_text_column_filter,
+    text_column_filter,
+)
 from galaxy.security.validate_user_input import validate_password
 from galaxy.structured_app import StructuredApp
-from galaxy.util import (
-    nice_size,
-    pretty_print_time_interval,
-    sanitize_text,
+from galaxy.util import pretty_print_time_interval
+from galaxy.util.search import (
+    FilteredTerm,
+    parse_filters_structured,
+    RawTextTerm,
 )
 from galaxy.web import url_for
 from galaxy.web.framework.helpers import (
@@ -37,24 +43,14 @@
 log = logging.getLogger(__name__)
 
 
-class UserListGrid(grids.Grid):
-    class EmailColumn(grids.TextColumn):
-        def get_value(self, trans, grid, user):
-            return escape(user.email)
-
-    class UserNameColumn(grids.TextColumn):
-        def get_value(self, trans, grid, user):
-            if user.username:
-                return escape(user.username)
-            return "not set"
-
+class UserListGrid(grids.GridData):
     class StatusColumn(grids.GridColumn):
         def get_value(self, trans, grid, user):
             if user.purged:
-                return "purged"
+                return "Purged"
             elif user.deleted:
-                return "deleted"
-            return ""
+                return "Deleted"
+            return "Available"
 
     class GroupsColumn(grids.GridColumn):
         def get_value(self, trans, grid, user):
@@ -68,12 +64,6 @@ def get_value(self, trans, grid, user):
                 return len(user.roles)
             return 0
 
-    class ExternalColumn(grids.GridColumn):
-        def get_value(self, trans, grid, user):
-            if user.external:
-                return "yes"
-            return "no"
-
     class LastLoginColumn(grids.GridColumn):
         def get_value(self, trans, grid, user):
             if user.galaxy_sessions:
@@ -97,17 +87,6 @@ def sort(self, trans, query, ascending, column_name=None):
                 query = query.order_by((last_login_subquery.c.last_login).asc().nullsfirst())
             return query
 
-    class TimeCreatedColumn(grids.GridColumn):
-        def get_value(self, trans, grid, user):
-            return user.create_time.strftime("%x")
-
-    class ActivatedColumn(grids.GridColumn):
-        def get_value(self, trans, grid, user):
-            if user.active:
-                return "Y"
-            else:
-                return "N"
-
     class DiskUsageColumn(grids.GridColumn):
         def get_value(self, trans, grid, user):
             return user.get_disk_usage(nice_size=True)
@@ -130,74 +109,54 @@ def sort(self, trans, query, ascending, column_name=None):
     model_class = model.User
     default_sort_key = "email"
     columns = [
-        EmailColumn(
-            "Email",
-            key="email",
-            link=(lambda item: dict(controller="user", action="information", id=item.id, webapp="galaxy")),
-            attach_popup=True,
-            filterable="advanced",
-            target="top",
-        ),
-        UserNameColumn("User Name", key="username", attach_popup=False, filterable="advanced"),
-        LastLoginColumn("Last Login", format=time_ago, key="last_login", sortable=True),
-        DiskUsageColumn("Disk Usage", key="disk_usage", attach_popup=False),
-        StatusColumn("Status", attach_popup=False, key="deleted"),
-        TimeCreatedColumn("Created", attach_popup=False, key="create_time"),
-        ActivatedColumn("Activated", attach_popup=False, key="active"),
-        GroupsColumn("Groups", attach_popup=False),
-        RolesColumn("Roles", attach_popup=False),
-        ExternalColumn("External", attach_popup=False, key="external"),
-        # Columns that are valid for filtering but are not visible.
-        grids.DeletedColumn("Deleted", key="deleted", visible=False, filterable="advanced"),
-        grids.PurgedColumn("Purged", key="purged", visible=False, filterable="advanced"),
-    ]
-    columns.append(
-        grids.MulticolFilterColumn(
-            "Search",
-            cols_to_filter=[columns[0], columns[1]],
-            key="free-text-search",
-            visible=False,
-            filterable="standard",
-        )
-    )
-    global_actions = [grids.GridAction("Create new user", url_args=dict(action="users/create"))]
-    operations = [
-        grids.GridOperation(
-            "Manage Information",
-            condition=(lambda item: not item.deleted),
-            allow_multiple=False,
-            url_args=dict(controller="user", action="information", webapp="galaxy"),
-        ),
-        grids.GridOperation(
-            "Manage Roles and Groups",
-            condition=(lambda item: not item.deleted),
-            allow_multiple=False,
-            url_args=dict(action="form/manage_roles_and_groups_for_user"),
-        ),
-        grids.GridOperation(
-            "Reset Password",
-            condition=(lambda item: not item.deleted),
-            allow_multiple=True,
-            url_args=dict(action="form/reset_user_password"),
-            target="top",
-        ),
-        grids.GridOperation("Recalculate Disk Usage", condition=(lambda item: not item.deleted), allow_multiple=False),
-        grids.GridOperation("Generate New API Key", allow_multiple=False, async_compatible=True),
+        grids.GridColumn("Email", key="email"),
+        grids.GridColumn("User Name", key="username"),
+        LastLoginColumn("Last Login", key="last_login", format=time_ago),
+        DiskUsageColumn("Disk Usage", key="disk_usage"),
+        StatusColumn("Status", key="status"),
+        grids.GridColumn("Created", key="create_time"),
+        grids.GridColumn("Activated", key="active", escape=False),
+        GroupsColumn("Groups", key="groups"),
+        RolesColumn("Roles", key="roles"),
+        grids.GridColumn("External", key="external", escape=False),
+        grids.GridColumn("Deleted", key="deleted", escape=False),
+        grids.GridColumn("Purged", key="purged", escape=False),
     ]
 
-    standard_filters = [
-        grids.GridColumnFilter("Active", args=dict(deleted=False)),
-        grids.GridColumnFilter("Deleted", args=dict(deleted=True, purged=False)),
-        grids.GridColumnFilter("Purged", args=dict(purged=True)),
-        grids.GridColumnFilter("All", args=dict(deleted="All")),
-    ]
-    num_rows_per_page = 50
-    use_paging = True
-    default_filter = dict(purged="False")
-    use_default_filter = True
-
-    def get_current_item(self, trans, **kwargs):
-        return trans.user
+    def apply_query_filter(self, query, **kwargs):
+        INDEX_SEARCH_FILTERS = {
+            "email": "email",
+            "username": "username",
+            "is": "is",
+        }
+        search_query = kwargs.get("search")
+        parsed_search = parse_filters_structured(search_query, INDEX_SEARCH_FILTERS)
+        deleted = False
+        for term in parsed_search.terms:
+            if isinstance(term, FilteredTerm):
+                key = term.filter
+                q = term.text
+                if key == "email":
+                    query = query.filter(text_column_filter(self.model_class.email, term))
+                elif key == "username":
+                    query = query.filter(text_column_filter(self.model_class.username, term))
+                elif key == "is":
+                    if q == "deleted":
+                        deleted = True
+                    elif q == "purged":
+                        query = query.filter(self.model_class.purged == true())
+            elif isinstance(term, RawTextTerm):
+                query = query.filter(
+                    raw_text_column_filter(
+                        [
+                            self.model_class.email,
+                            self.model_class.username,
+                        ],
+                        term,
+                    )
+                )
+        query = query.filter(self.model_class.deleted == (true() if deleted else false()))
+        return query
 
 
 class RoleListGrid(grids.Grid):
@@ -629,45 +588,6 @@ def data_types_list(self, trans, **kwd) -> DatatypesEntryT:
     @web.json
     @web.require_admin
     def users_list(self, trans, **kwd):
-        message = kwd.get("message", "")
-        status = kwd.get("status", "")
-        if "operation" in kwd:
-            id = kwd.get("id")
-            if not id:
-                message, status = (f"Invalid user id ({str(id)}) received.", "error")
-            ids = util.listify(id)
-            operation = kwd["operation"].lower()
-            if operation == "delete":
-                message, status = self._delete_user(trans, ids)
-            elif operation == "undelete":
-                message, status = self._undelete_user(trans, ids)
-            elif operation == "purge":
-                message, status = self._purge_user(trans, ids)
-            elif operation == "recalculate disk usage":
-                message, status = self._recalculate_user(trans, id)
-            elif operation == "generate new api key":
-                message, status = self._new_user_apikey(trans, id)
-            elif operation == "activate user":
-                message, status = self._activate_user(trans, id)
-            elif operation == "resend activation email":
-                message, status = self._resend_activation_email(trans, id)
-        if message and status:
-            kwd["message"] = util.sanitize_text(message)
-            kwd["status"] = status
-        if trans.app.config.allow_user_deletion:
-            if self.delete_operation not in self.user_list_grid.operations:
-                self.user_list_grid.operations.append(self.delete_operation)
-            if self.undelete_operation not in self.user_list_grid.operations:
-                self.user_list_grid.operations.append(self.undelete_operation)
-            if self.purge_operation not in self.user_list_grid.operations:
-                self.user_list_grid.operations.append(self.purge_operation)
-        if trans.app.config.allow_user_impersonation:
-            if self.impersonate_operation not in self.user_list_grid.operations:
-                self.user_list_grid.operations.append(self.impersonate_operation)
-        if trans.app.config.user_activation_on:
-            if self.activate_operation not in self.user_list_grid.operations:
-                self.user_list_grid.operations.append(self.activate_operation)
-                self.user_list_grid.operations.append(self.resend_activation_email)
         return self.user_list_grid(trans, **kwd)
 
     @web.legacy_expose_api
@@ -1490,89 +1410,6 @@ def reset_user_password(self, trans, payload=None, **kwd):
         else:
             return self.message_exception(trans, "Please specify user ids.")
 
-    def _delete_user(self, trans, ids):
-        message = "Deleted %d users: " % len(ids)
-        for user_id in ids:
-            user = get_user(trans, user_id)
-            # Actually do the delete
-            self.user_manager.delete(user)
-            # Accumulate messages for the return message
-            message += f" {user.email} "
-        return (message, "done")
-
-    def _undelete_user(self, trans, ids):
-        count = 0
-        undeleted_users = ""
-        for user_id in ids:
-            user = get_user(trans, user_id)
-            # Actually do the undelete
-            self.user_manager.undelete(user)
-            # Count and accumulate messages to return to the admin panel
-            count += 1
-            undeleted_users += f" {user.email}"
-        message = "Undeleted %d users: %s" % (count, undeleted_users)
-        return (message, "done")
-
-    def _purge_user(self, trans, ids):
-        # This method should only be called for a User that has previously been deleted.
-        # We keep the User in the database ( marked as purged ), and stuff associated
-        # with the user's private role in case we want the ability to unpurge the user
-        # some time in the future.
-        # Purging a deleted User deletes all of the following:
-        # - History where user_id = User.id
-        #    - HistoryDatasetAssociation where history_id = History.id
-        # - UserGroupAssociation where user_id == User.id
-        # - UserRoleAssociation where user_id == User.id EXCEPT FOR THE PRIVATE ROLE
-        # - UserAddress where user_id == User.id
-        # Purging Histories and Datasets must be handled via the cleanup_datasets.py script
-        message = "Purged %d users: " % len(ids)
-        for user_id in ids:
-            user = get_user(trans, user_id)
-            self.user_manager.purge(user)
-            message += f"\t{user.email}\n "
-        return (message, "done")
-
-    def _recalculate_user(self, trans, user_id):
-        user = trans.sa_session.query(trans.model.User).get(trans.security.decode_id(user_id))
-        if not user:
-            return (f"User not found for id ({sanitize_text(str(user_id))})", "error")
-        current = user.get_disk_usage()
-        user.calculate_and_set_disk_usage()
-        new = user.get_disk_usage()
-        if new in (current, None):
-            message = f"Usage is unchanged at {nice_size(current)}."
-        else:
-            message = f"Usage has changed by {nice_size(new - current)} to {nice_size(new)}."
-        return (message, "done")
-
-    def _new_user_apikey(self, trans, user_id):
-        user = trans.sa_session.query(trans.model.User).get(trans.security.decode_id(user_id))
-        if not user:
-            return (f"User not found for id ({sanitize_text(str(user_id))})", "error")
-        new_key = trans.app.model.APIKeys(
-            user_id=trans.security.decode_id(user_id), key=trans.app.security.get_new_guid()
-        )
-        trans.sa_session.add(new_key)
-        with transaction(trans.sa_session):
-            trans.sa_session.commit()
-        return (f"New key '{new_key.key}' generated for requested user '{user.email}'.", "done")
-
-    def _activate_user(self, trans, user_id):
-        user = trans.sa_session.query(trans.model.User).get(trans.security.decode_id(user_id))
-        if not user:
-            return (f"User not found for id ({sanitize_text(str(user_id))})", "error")
-        self.user_manager.activate(user)
-        return (f"Activated user: {user.email}.", "done")
-
-    def _resend_activation_email(self, trans, user_id):
-        user = trans.sa_session.query(trans.model.User).get(trans.security.decode_id(user_id))
-        if not user:
-            return (f"User not found for id ({sanitize_text(str(user_id))})", "error")
-        if self.user_manager.send_activation_email(trans, user.email, user.username):
-            return (f"Activation email has been sent to user: {user.email}.", "done")
-        else:
-            return (f"Unable to send activation email to user: {user.email}.", "error")
-
     @web.legacy_expose_api
     @web.require_admin
     def manage_roles_and_groups_for_user(self, trans, payload=None, **kwd):
diff --git a/lib/galaxy/webapps/galaxy/services/users.py b/lib/galaxy/webapps/galaxy/services/users.py
index de291d9c5b19..b4cb33b1021c 100644
--- a/lib/galaxy/webapps/galaxy/services/users.py
+++ b/lib/galaxy/webapps/galaxy/services/users.py
@@ -70,20 +70,21 @@ def __init__(
     def recalculate_disk_usage(
         self,
         trans: ProvidesUserContext,
+        user_id: int,
     ):
         if trans.anonymous:
             raise glx_exceptions.AuthenticationRequired("Only registered users can recalculate disk usage.")
         if trans.app.config.enable_celery_tasks:
             from galaxy.celery.tasks import recalculate_user_disk_usage
 
-            result = recalculate_user_disk_usage.delay(task_user_id=getattr(trans.user, "id", None))
+            result = recalculate_user_disk_usage.delay(task_user_id=user_id)
             return async_task_summary(result)
         else:
             send_local_control_task(
                 trans.app,
                 "recalculate_user_disk_usage",
                 kwargs={
-                    "user_id": trans.user.id,
+                    "user_id": user_id,
                 },
             )
             return None