From d9c10a3fc89a43789f9cbc5bbb00e6c49176da73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 13:19:42 +0200
Subject: [PATCH 01/36] Change: Split targets query hooks into two modules

Use dedicated modules for single and multiple entity query hooks.
---
 .../hooks/use-query/__tests__/Ticket.test.tsx | 214 ++++++++++++++++++
 .../use-query/__tests__/Tickets.test.tsx      | 201 +---------------
 src/web/hooks/use-query/ticket.ts             | 120 ++++++++++
 src/web/hooks/use-query/tickets.ts            | 115 +---------
 src/web/pages/tickets/TicketComponent.tsx     |   2 +-
 src/web/pages/tickets/TicketDetailsPage.tsx   |   2 +-
 6 files changed, 339 insertions(+), 315 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Ticket.test.tsx
 create mode 100644 src/web/hooks/use-query/ticket.ts

diff --git a/src/web/hooks/use-query/__tests__/Ticket.test.tsx b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
new file mode 100644
index 0000000000..a863b0bea2
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
@@ -0,0 +1,214 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, test, expect, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import Ticket, {TICKET_STATUS} from 'gmp/models/ticket';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneTicket,
+  useCreateTicket,
+  useDeleteTicket,
+  useDownloadTicket,
+  useGetTicket,
+  useSaveTicket,
+} from 'web/hooks/use-query/ticket';
+
+const ticket = Ticket.fromElement({
+  _id: 'ticket-1',
+  name: 'Test Ticket',
+  status: TICKET_STATUS.open,
+  assigned_to: {user: {_id: 'u1', name: 'admin'}},
+  open_time: '2024-01-10T08:00:00Z',
+  open_note: 'Ticket opened',
+});
+
+const SingleTicketComponent = ({id}: {id: string}) => {
+  const {data, isLoading, isError} = useGetTicket({id});
+
+  if (isLoading) return <div data-testid="loading">Loading...</div>;
+  if (isError) return <div data-testid="error">Error</div>;
+  if (!data) return <div data-testid="no-data">No data</div>;
+
+  return (
+    <div data-testid="ticket">
+      <span data-testid="ticket-name">{data.name}</span>
+      <span data-testid="ticket-id">{data.id}</span>
+    </div>
+  );
+};
+
+const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
+  session: createSession({token}),
+  settings: {},
+  ticket: {
+    get: testing.fn().mockResolvedValue({data: ticket}),
+    create: testing.fn().mockResolvedValue({data: {id: 'ticket-3'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'ticket-1'}}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'ticket-3'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    export: testing.fn().mockResolvedValue({data: 'ticket-content'}),
+  },
+});
+
+describe('useGetTicket', () => {
+  test('should fetch a single ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleTicketComponent id="ticket-1" />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('ticket-name')).toHaveTextContent(
+        'Test Ticket',
+      );
+    });
+
+    expect(gmp.ticket.get).toHaveBeenCalledWith({id: 'ticket-1'});
+    expect(screen.getByTestId('ticket-id')).toHaveTextContent('ticket-1');
+  });
+
+  test('should show loading state initially', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleTicketComponent id="ticket-1" />);
+
+    expect(screen.getByTestId('loading')).toBeInTheDocument();
+  });
+
+  test('should not fetch a ticket when the ID is empty', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SingleTicketComponent id="" />);
+
+    expect(screen.getByTestId('no-data')).toBeInTheDocument();
+    expect(gmp.ticket.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch a ticket without a session token', () => {
+    const gmp = createGmp({token: undefined});
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SingleTicketComponent id="ticket-1" />);
+
+    expect(gmp.ticket.get).not.toHaveBeenCalled();
+  });
+
+  test('should show an error when fetching a ticket fails', async () => {
+    const gmp = createGmp();
+    gmp.ticket.get.mockRejectedValue(new Error('Request failed'));
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SingleTicketComponent id="ticket-1" />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('error')).toBeInTheDocument();
+    });
+  });
+});
+
+describe('ticket mutation hooks', () => {
+  test('should create a ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {resultId: 'result-1', userId: 'user-1', note: 'Note'};
+
+    const TestComponent = () => {
+      const mutation = useCreateTicket();
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.ticket.create).toHaveBeenCalledWith(input);
+    });
+  });
+
+  test('should save a ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {
+      id: 'ticket-1',
+      status: TICKET_STATUS.fixed,
+      userId: 'user-1',
+      fixedNote: 'Fixed',
+    };
+
+    const TestComponent = () => {
+      const mutation = useSaveTicket();
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => {
+      expect(gmp.ticket.save).toHaveBeenCalledWith(input);
+    });
+  });
+
+  test('should clone a ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCloneTicket();
+      return (
+        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>Clone</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.ticket.clone).toHaveBeenCalledWith({id: 'ticket-1'});
+    });
+  });
+
+  test('should delete a ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteTicket();
+      return (
+        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.ticket.delete).toHaveBeenCalledWith({id: 'ticket-1'});
+    });
+  });
+
+  test('should download a ticket', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDownloadTicket();
+      return (
+        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
+          Download
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
+
+    await waitFor(() => {
+      expect(gmp.ticket.export).toHaveBeenCalledWith({id: 'ticket-1'});
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Tickets.test.tsx b/src/web/hooks/use-query/__tests__/Tickets.test.tsx
index 7f15e3e4e1..07349a97a7 100644
--- a/src/web/hooks/use-query/__tests__/Tickets.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Tickets.test.tsx
@@ -4,21 +4,13 @@
  */
 
 import {describe, test, expect, testing} from '@gsa/testing';
-import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
 import CollectionCounts from 'gmp/collection/collection-counts';
 import type FilterType from 'gmp/models/filter/filter-type';
 import QueryFilter from 'gmp/models/filter/query-filter';
 import Ticket, {TICKET_STATUS} from 'gmp/models/ticket';
 import {createSession} from 'gmp/testing';
-import {
-  useCloneTicket,
-  useCreateTicket,
-  useDeleteTicket,
-  useDownloadTicket,
-  useGetTicket,
-  useGetTickets,
-  useSaveTicket,
-} from 'web/hooks/use-query/tickets';
+import {useGetTickets} from 'web/hooks/use-query/tickets';
 
 const ticket = Ticket.fromElement({
   _id: 'ticket-1',
@@ -40,27 +32,6 @@ const ticket2 = Ticket.fromElement({
 
 const filter = QueryFilter.fromString('name~test');
 
-const SingleTicketComponent = ({id}: {id: string}) => {
-  const {data, isLoading, isError} = useGetTicket({id});
-
-  if (isLoading) {
-    return <div data-testid="loading">Loading...</div>;
-  }
-  if (isError) {
-    return <div data-testid="error">Error</div>;
-  }
-  if (!data) {
-    return <div data-testid="no-data">No data</div>;
-  }
-
-  return (
-    <div data-testid="ticket">
-      <span data-testid="ticket-name">{data.name}</span>
-      <span data-testid="ticket-id">{data.id}</span>
-    </div>
-  );
-};
-
 const TicketListComponent = ({filter}: {filter?: FilterType}) => {
   const {data, isLoading, isError} = useGetTickets({filter});
 
@@ -88,14 +59,6 @@ const TicketListComponent = ({filter}: {filter?: FilterType}) => {
 const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
   session: createSession({token}),
   settings: {},
-  ticket: {
-    get: testing.fn().mockResolvedValue({data: ticket}),
-    create: testing.fn().mockResolvedValue({data: {id: 'ticket-3'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'ticket-1'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'ticket-3'}}),
-    delete: testing.fn().mockResolvedValue(undefined),
-    export: testing.fn().mockResolvedValue({data: 'ticket-content'}),
-  },
   tickets: {
     get: testing.fn().mockResolvedValue({
       data: [ticket, ticket2],
@@ -107,62 +70,6 @@ const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
   },
 });
 
-describe('useGetTicket', () => {
-  test('should fetch a single ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SingleTicketComponent id="ticket-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('ticket-name')).toHaveTextContent(
-        'Test Ticket',
-      );
-    });
-
-    expect(gmp.ticket.get).toHaveBeenCalledWith({id: 'ticket-1'});
-    expect(screen.getByTestId('ticket-id')).toHaveTextContent('ticket-1');
-  });
-
-  test('should show loading state initially', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SingleTicketComponent id="ticket-1" />);
-
-    expect(screen.getByTestId('loading')).toBeInTheDocument();
-  });
-
-  test('should not fetch a ticket when the ID is empty', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleTicketComponent id="" />);
-
-    expect(screen.getByTestId('no-data')).toBeInTheDocument();
-    expect(gmp.ticket.get).not.toHaveBeenCalled();
-  });
-
-  test('should not fetch a ticket without a session token', () => {
-    const gmp = createGmp({token: undefined});
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleTicketComponent id="ticket-1" />);
-
-    expect(gmp.ticket.get).not.toHaveBeenCalled();
-  });
-
-  test('should show an error when fetching a ticket fails', async () => {
-    const gmp = createGmp();
-    gmp.ticket.get.mockRejectedValue(new Error('Request failed'));
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleTicketComponent id="ticket-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('error')).toBeInTheDocument();
-    });
-  });
-});
-
 describe('useGetTickets', () => {
   test('should fetch a list of tickets', async () => {
     const gmp = createGmp();
@@ -199,107 +106,3 @@ describe('useGetTickets', () => {
     });
   });
 });
-
-describe('ticket mutation hooks', () => {
-  test('should create a ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    const input = {resultId: 'result-1', userId: 'user-1', note: 'Note'};
-
-    const TestComponent = () => {
-      const mutation = useCreateTicket();
-      return <button onClick={() => mutation.mutate(input)}>Create</button>;
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-
-    await waitFor(() => {
-      expect(gmp.ticket.create).toHaveBeenCalledWith(input);
-    });
-  });
-
-  test('should save a ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    const input = {
-      id: 'ticket-1',
-      status: TICKET_STATUS.fixed,
-      userId: 'user-1',
-      fixedNote: 'Fixed',
-    };
-
-    const TestComponent = () => {
-      const mutation = useSaveTicket();
-      return <button onClick={() => mutation.mutate(input)}>Save</button>;
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
-
-    await waitFor(() => {
-      expect(gmp.ticket.save).toHaveBeenCalledWith(input);
-    });
-  });
-
-  test('should clone a ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useCloneTicket();
-      return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>Clone</button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
-
-    await waitFor(() => {
-      expect(gmp.ticket.clone).toHaveBeenCalledWith({id: 'ticket-1'});
-    });
-  });
-
-  test('should delete a ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useDeleteTicket();
-      return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
-          Delete
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-
-    await waitFor(() => {
-      expect(gmp.ticket.delete).toHaveBeenCalledWith({id: 'ticket-1'});
-    });
-  });
-
-  test('should download a ticket', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useDownloadTicket();
-      return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
-          Download
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
-
-    await waitFor(() => {
-      expect(gmp.ticket.export).toHaveBeenCalledWith({id: 'ticket-1'});
-    });
-  });
-});
diff --git a/src/web/hooks/use-query/ticket.ts b/src/web/hooks/use-query/ticket.ts
new file mode 100644
index 0000000000..784bd73d20
--- /dev/null
+++ b/src/web/hooks/use-query/ticket.ts
@@ -0,0 +1,120 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionData} from 'gmp/commands/entity';
+import type Response from 'gmp/http/response';
+import {
+  type default as Ticket,
+  type TicketStatusValue,
+} from 'gmp/models/ticket';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntity from 'web/queries/useGetEntity';
+import useGmpMutation from 'web/queries/useGmpMutation';
+
+interface UseGetTicketParams {
+  id: string;
+}
+
+interface UseTicketMutationCallbacks<TResponse> {
+  onSuccess?: (response: TResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface TicketCreateInput {
+  resultId: string;
+  userId: string;
+  note?: string;
+}
+
+interface TicketSaveInput {
+  id: string;
+  openNote?: string;
+  fixedNote?: string;
+  closedNote?: string;
+  status: TicketStatusValue;
+  userId: string;
+}
+
+export const useGetTicket = ({id}: UseGetTicketParams) => {
+  const gmp = useGmp();
+  return useGetEntity<Ticket>({
+    gmpMethod: gmp.ticket.get.bind(gmp.ticket),
+    queryId: 'get_ticket',
+    id,
+  });
+};
+
+export const useCreateTicket = ({
+  onSuccess,
+  onError,
+}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<TicketCreateInput, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.ticket.create(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_tickets'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useSaveTicket = ({
+  onSuccess,
+  onError,
+}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<TicketSaveInput, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.ticket.save(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_tickets', 'get_ticket'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCloneTicket = ({
+  onSuccess,
+  onError,
+}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string}, EntityActionData>({
+    gmpMethod: async ({id}: {id: string}) => {
+      const response = await gmp.ticket.clone({id});
+      return response.data;
+    },
+    invalidateQueryIds: ['get_tickets'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDeleteTicket = ({
+  onSuccess,
+  onError,
+}: UseTicketMutationCallbacks<void> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string}, void>({
+    gmpMethod: ({id}: {id: string}) => gmp.ticket.delete({id}),
+    invalidateQueryIds: ['get_tickets', 'get_ticket'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDownloadTicket = ({
+  onSuccess,
+  onError,
+}: UseTicketMutationCallbacks<Response<string>> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string}, Response<string>>({
+    gmpMethod: ({id}: {id: string}) => gmp.ticket.export({id}),
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/tickets.ts b/src/web/hooks/use-query/tickets.ts
index d0a45fc3dc..e2aa36deba 100644
--- a/src/web/hooks/use-query/tickets.ts
+++ b/src/web/hooks/use-query/tickets.ts
@@ -3,46 +3,15 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionData} from 'gmp/commands/entity';
-import type Response from 'gmp/http/response';
 import {type FilterType} from 'gmp/models/filter';
-import {
-  type default as Ticket,
-  type TicketStatusValue,
-} from 'gmp/models/ticket';
+import type Ticket from 'gmp/models/ticket';
 import useGmp from 'web/hooks/useGmp';
 import useGetEntities from 'web/queries/useGetEntities';
-import useGetEntity from 'web/queries/useGetEntity';
-import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UseGetTicketsParams {
   filter?: FilterType;
 }
 
-interface UseGetTicketParams {
-  id: string;
-}
-
-interface UseTicketMutationCallbacks<TResponse> {
-  onSuccess?: (response: TResponse) => void;
-  onError?: (error: Error) => void;
-}
-
-interface TicketCreateInput {
-  resultId: string;
-  userId: string;
-  note?: string;
-}
-
-interface TicketSaveInput {
-  id: string;
-  openNote?: string;
-  fixedNote?: string;
-  closedNote?: string;
-  status: TicketStatusValue;
-  userId: string;
-}
-
 export const useGetTickets = ({filter}: UseGetTicketsParams = {}) => {
   const gmp = useGmp();
   return useGetEntities<Ticket>({
@@ -52,85 +21,3 @@ export const useGetTickets = ({filter}: UseGetTicketsParams = {}) => {
     keepPreviousData: true,
   });
 };
-
-export const useGetTicket = ({id}: UseGetTicketParams) => {
-  const gmp = useGmp();
-  return useGetEntity<Ticket>({
-    gmpMethod: gmp.ticket.get.bind(gmp.ticket),
-    queryId: 'get_ticket',
-    id,
-  });
-};
-
-export const useCreateTicket = ({
-  onSuccess,
-  onError,
-}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<TicketCreateInput, EntityActionData>({
-    gmpMethod: async data => {
-      const response = await gmp.ticket.create(data);
-      return response.data;
-    },
-    invalidateQueryIds: ['get_tickets'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useSaveTicket = ({
-  onSuccess,
-  onError,
-}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<TicketSaveInput, EntityActionData>({
-    gmpMethod: async data => {
-      const response = await gmp.ticket.save(data);
-      return response.data;
-    },
-    invalidateQueryIds: ['get_tickets', 'get_ticket'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useCloneTicket = ({
-  onSuccess,
-  onError,
-}: UseTicketMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string}, EntityActionData>({
-    gmpMethod: async ({id}: {id: string}) => {
-      const response = await gmp.ticket.clone({id});
-      return response.data;
-    },
-    invalidateQueryIds: ['get_tickets'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useDeleteTicket = ({
-  onSuccess,
-  onError,
-}: UseTicketMutationCallbacks<void> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string}, void>({
-    gmpMethod: ({id}: {id: string}) => gmp.ticket.delete({id}),
-    invalidateQueryIds: ['get_tickets', 'get_ticket'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useDownloadTicket = ({
-  onSuccess,
-  onError,
-}: UseTicketMutationCallbacks<Response<string>> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string}, Response<string>>({
-    gmpMethod: ({id}: {id: string}) => gmp.ticket.export({id}),
-    onSuccess,
-    onError,
-  });
-};
diff --git a/src/web/pages/tickets/TicketComponent.tsx b/src/web/pages/tickets/TicketComponent.tsx
index d5e0c6bbbc..7c10d27678 100644
--- a/src/web/pages/tickets/TicketComponent.tsx
+++ b/src/web/pages/tickets/TicketComponent.tsx
@@ -21,7 +21,7 @@ import {
   useCreateTicket,
   useDeleteTicket,
   useSaveTicket,
-} from 'web/hooks/use-query/tickets';
+} from 'web/hooks/use-query/ticket';
 import {useGetUsers} from 'web/hooks/use-query/users';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
diff --git a/src/web/pages/tickets/TicketDetailsPage.tsx b/src/web/pages/tickets/TicketDetailsPage.tsx
index 70c57b778f..671216d305 100644
--- a/src/web/pages/tickets/TicketDetailsPage.tsx
+++ b/src/web/pages/tickets/TicketDetailsPage.tsx
@@ -45,7 +45,7 @@ import DeleteIcon from 'web/entity/icon/DeleteIcon';
 import EditIcon from 'web/entity/icon/EditIcon';
 import {goToDetails, goToList} from 'web/entity/navigation';
 import EntityTags from 'web/entity/Tags';
-import {useGetTicket} from 'web/hooks/use-query/tickets';
+import {useGetTicket} from 'web/hooks/use-query/ticket';
 import useTranslation from 'web/hooks/useTranslation';
 import TicketComponent from 'web/pages/tickets/TicketComponent';
 import TicketDetails from 'web/pages/tickets/TicketDetails';

From b9c267e614deae7879576d35d6fde07f2d703c51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 13:30:28 +0200
Subject: [PATCH 02/36] Change: Split users query hooks into two modules

Use dedicated modules for single and multiple entity query hooks.
---
 .../hooks/use-query/__tests__/User.test.tsx   | 260 ++++++++++++++++
 .../hooks/use-query/__tests__/Users.test.tsx  | 289 +-----------------
 src/web/hooks/use-query/user.ts               | 125 ++++++++
 src/web/hooks/use-query/users.ts              | 111 -------
 src/web/pages/users/UserComponent.tsx         |   2 +-
 src/web/pages/users/UserDetailsPage.tsx       |   2 +-
 6 files changed, 389 insertions(+), 400 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/User.test.tsx
 create mode 100644 src/web/hooks/use-query/user.ts

diff --git a/src/web/hooks/use-query/__tests__/User.test.tsx b/src/web/hooks/use-query/__tests__/User.test.tsx
new file mode 100644
index 0000000000..b350a5b08d
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/User.test.tsx
@@ -0,0 +1,260 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import User from 'gmp/models/user';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneUser,
+  useCreateUser,
+  useDeleteUser,
+  useDownloadUser,
+  useGetUser,
+  useSaveUser,
+} from 'web/hooks/use-query/user';
+
+const userData = {
+  accessHosts: ['localhost', '127.0.0.1'],
+  authMethod: 'password',
+  comment: 'comment',
+  groupIds: ['group-id'],
+  hostsAllow: '0',
+  name: 'user',
+  password: 'password',
+  roleIds: ['role-id'],
+};
+
+const user = new User({id: 'user-id', name: 'user'});
+
+const createGmp = (
+  userMethods: Record<string, unknown> = {},
+  token = 'test-token',
+) => ({
+  session: createSession({token}),
+  settings: {},
+  user: {
+    get: testing.fn().mockResolvedValue({data: user}),
+    create: testing.fn().mockResolvedValue({data: {id: 'created'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'saved'}}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'cloned'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    export: testing.fn().mockResolvedValue({data: 'user-content'}),
+    ...userMethods,
+  },
+});
+
+describe('useGetUser', () => {
+  test('should fetch a user by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetUser({id: 'user-id'});
+      return <div data-testid="user">{data?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('user')).toHaveTextContent('user');
+    });
+
+    expect(gmp.user.get).toHaveBeenCalledWith({id: 'user-id'});
+  });
+
+  test('should not fetch a user without a session token', () => {
+    const gmp = createGmp({}, '');
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetUser({id: 'user-id'});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.user.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch a user when the ID is empty', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetUser({id: ''});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.user.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useCreateUser', () => {
+  test('forwards access_hosts arrays when creating a user', async () => {
+    const create = testing.fn().mockResolvedValue({data: {id: 'created'}});
+    const gmp = createGmp({create});
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateUser();
+      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => expect(create).toHaveBeenCalledWith(userData));
+  });
+
+  test('calls onSuccess with created user data', async () => {
+    const onSuccess = testing.fn();
+    const gmp = createGmp({onSuccess: undefined});
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateUser({onSuccess});
+      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() =>
+      expect(onSuccess).toHaveBeenCalledWith({id: 'created'}),
+    );
+  });
+
+  test('calls onError when creating a user fails', async () => {
+    const error = new Error('Create failed');
+    const onError = testing.fn();
+    const gmp = createGmp({create: testing.fn().mockRejectedValue(error)});
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateUser({onError});
+      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+});
+
+describe('useSaveUser', () => {
+  test('derives oldName when saving', async () => {
+    const save = testing.fn().mockResolvedValue({data: {id: 'saved'}});
+    const gmp = createGmp({save});
+    const {render} = rendererWith({gmp, router: true});
+    const input = {...userData, id: 'user-id'};
+
+    const TestComponent = () => {
+      const mutation = useSaveUser();
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => {
+      expect(save).toHaveBeenCalledWith({...input, oldName: userData.name});
+    });
+  });
+
+  test('preserves an explicit oldName when saving', async () => {
+    const save = testing.fn().mockResolvedValue({data: {id: 'saved'}});
+    const gmp = createGmp({save});
+    const {render} = rendererWith({gmp, router: true});
+    const input = {...userData, id: 'user-id', oldName: 'previous-user'};
+
+    const TestComponent = () => {
+      const mutation = useSaveUser();
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => expect(save).toHaveBeenCalledWith(input));
+  });
+
+  test('calls callbacks when saving fails', async () => {
+    const error = new Error('Save failed');
+    const onError = testing.fn();
+    const save = testing.fn().mockRejectedValue(error);
+    const gmp = createGmp({save});
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useSaveUser({onError});
+      return (
+        <button onClick={() => mutation.mutate({...userData, id: 'user-id'})}>
+          Save
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+});
+
+describe('remaining user mutation hooks', () => {
+  test('should clone a user', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useCloneUser();
+      return (
+        <button onClick={() => mutation.mutate({id: 'user-id'})}>Clone</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+    await waitFor(() =>
+      expect(gmp.user.clone).toHaveBeenCalledWith({id: 'user-id'}),
+    );
+  });
+
+  test('should delete a user and forward the inheritor ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: 'user-id', inheritorId: 'inheritor-id'};
+    const TestComponent = () => {
+      const mutation = useDeleteUser();
+      return <button onClick={() => mutation.mutate(input)}>Delete</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+    await waitFor(() => expect(gmp.user.delete).toHaveBeenCalledWith(input));
+  });
+
+  test('should download a user', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDownloadUser();
+      return (
+        <button onClick={() => mutation.mutate({id: 'user-id'})}>
+          Download
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
+    await waitFor(() =>
+      expect(gmp.user.export).toHaveBeenCalledWith({id: 'user-id'}),
+    );
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Users.test.tsx b/src/web/hooks/use-query/__tests__/Users.test.tsx
index bd9bb7a08e..912881bf6e 100644
--- a/src/web/hooks/use-query/__tests__/Users.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Users.test.tsx
@@ -12,13 +12,7 @@ import {createSession} from 'gmp/testing';
 import {
   useBulkDeleteUsers,
   useBulkExportUsers,
-  useCloneUser,
-  useCreateUser,
-  useDeleteUser,
-  useDownloadUser,
-  useGetUser,
   useGetUsers,
-  useSaveUser,
 } from 'web/hooks/use-query/users';
 
 const userData = {
@@ -41,15 +35,7 @@ const createGmp = (
 ) => ({
   session: createSession({token}),
   settings: {},
-  user: {
-    get: testing.fn().mockResolvedValue({data: user}),
-    create: testing.fn().mockResolvedValue({data: {id: 'created'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'saved'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'cloned'}}),
-    delete: testing.fn().mockResolvedValue(undefined),
-    export: testing.fn().mockResolvedValue({data: 'user-content'}),
-    ...userMethods,
-  },
+  user: userMethods,
   users: {
     get: testing.fn().mockResolvedValue({
       data: [user],
@@ -64,7 +50,7 @@ const createGmp = (
   },
 });
 
-describe('user query hooks', () => {
+describe('useGetUsers', () => {
   test('should fetch users with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -83,24 +69,6 @@ describe('user query hooks', () => {
     expect(gmp.users.get).toHaveBeenCalledWith({filter: userFilter});
   });
 
-  test('should fetch a user by ID', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const {data} = useGetUser({id: 'user-id'});
-      return <div data-testid="user">{data?.name}</div>;
-    };
-
-    render(<TestComponent />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('user')).toHaveTextContent('user');
-    });
-
-    expect(gmp.user.get).toHaveBeenCalledWith({id: 'user-id'});
-  });
-
   test('should not fetch users without a session token', () => {
     const gmp = createGmp({}, '');
     const {render} = rendererWith({gmp, router: true});
@@ -115,238 +83,6 @@ describe('user query hooks', () => {
     expect(gmp.users.get).not.toHaveBeenCalled();
   });
 
-  test('should not fetch a user when the ID is empty', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      useGetUser({id: ''});
-      return <div />;
-    };
-
-    render(<TestComponent />);
-
-    expect(gmp.user.get).not.toHaveBeenCalled();
-  });
-});
-
-describe('useCreateUser', () => {
-  test('forwards access_hosts arrays when creating a user', async () => {
-    const create = testing.fn().mockResolvedValue({data: {id: 'created'}});
-    const gmp = createGmp({create});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useCreateUser();
-      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-
-    await waitFor(() => {
-      expect(create).toHaveBeenCalledWith(userData);
-    });
-  });
-  test('calls onSuccess with created user data', async () => {
-    const create = testing.fn().mockResolvedValue({data: {id: 'created'}});
-    const onSuccess = testing.fn();
-    const gmp = createGmp({create});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useCreateUser({onSuccess});
-      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-
-    await waitFor(() => {
-      expect(onSuccess).toHaveBeenCalledWith({id: 'created'});
-    });
-  });
-
-  test('calls onError when creating a user fails', async () => {
-    const error = new Error('Create failed');
-    const create = testing.fn().mockRejectedValue(error);
-    const onError = testing.fn();
-    const gmp = createGmp({create});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useCreateUser({onError});
-      return <button onClick={() => mutation.mutate(userData)}>Create</button>;
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-
-    await waitFor(() => {
-      expect(onError).toHaveBeenCalled();
-      expect(onError.mock.calls[0][0]).toBe(error);
-    });
-  });
-});
-
-describe('useSaveUser', () => {
-  test('forwards accessHosts arrays and derives oldName when saving', async () => {
-    const save = testing.fn().mockResolvedValue({data: {id: 'saved'}});
-    const gmp = createGmp({save});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useSaveUser();
-      return (
-        <button onClick={() => mutation.mutate({...userData, id: 'user-id'})}>
-          Save
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledWith({
-        ...userData,
-        id: 'user-id',
-        oldName: userData.name,
-      });
-    });
-  });
-
-  test('preserves an explicit oldName when saving', async () => {
-    const save = testing.fn().mockResolvedValue({data: {id: 'saved'}});
-    const gmp = createGmp({save});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useSaveUser();
-      return (
-        <button
-          onClick={() =>
-            mutation.mutate({
-              ...userData,
-              id: 'user-id',
-              oldName: 'previous-user',
-            })
-          }
-        >
-          Save
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledWith({
-        ...userData,
-        id: 'user-id',
-        oldName: 'previous-user',
-      });
-    });
-  });
-
-  test('calls onSuccess with saved user data', async () => {
-    const save = testing.fn().mockResolvedValue({data: {id: 'saved'}});
-    const onSuccess = testing.fn();
-    const gmp = createGmp({save});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useSaveUser({onSuccess});
-      return (
-        <button onClick={() => mutation.mutate({...userData, id: 'user-id'})}>
-          Save
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
-
-    await waitFor(() => {
-      expect(onSuccess).toHaveBeenCalledWith({id: 'saved'});
-    });
-  });
-
-  test('calls onError when saving a user fails', async () => {
-    const error = new Error('Save failed');
-    const save = testing.fn().mockRejectedValue(error);
-    const onError = testing.fn();
-    const gmp = createGmp({save});
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useSaveUser({onError});
-      return (
-        <button onClick={() => mutation.mutate({...userData, id: 'user-id'})}>
-          Save
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
-
-    await waitFor(() => {
-      expect(onError).toHaveBeenCalled();
-      expect(onError.mock.calls[0][0]).toBe(error);
-    });
-  });
-});
-
-describe('remaining user mutation hooks', () => {
-  test('should clone a user', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useCloneUser();
-      return (
-        <button onClick={() => mutation.mutate({id: 'user-id'})}>Clone</button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
-
-    await waitFor(() => {
-      expect(gmp.user.clone).toHaveBeenCalledWith({id: 'user-id'});
-    });
-  });
-
-  test('should delete a user and forward the inheritor ID', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useDeleteUser();
-      return (
-        <button
-          onClick={() =>
-            mutation.mutate({id: 'user-id', inheritorId: 'inheritor-id'})
-          }
-        >
-          Delete
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-
-    await waitFor(() => {
-      expect(gmp.user.delete).toHaveBeenCalledWith({
-        id: 'user-id',
-        inheritorId: 'inheritor-id',
-      });
-    });
-  });
-
   test('should bulk delete users with options', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -368,27 +104,6 @@ describe('remaining user mutation hooks', () => {
     });
   });
 
-  test('should download a user', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useDownloadUser();
-      return (
-        <button onClick={() => mutation.mutate({id: 'user-id'})}>
-          Download
-        </button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
-
-    await waitFor(() => {
-      expect(gmp.user.export).toHaveBeenCalledWith({id: 'user-id'});
-    });
-  });
-
   test('should bulk export users by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
new file mode 100644
index 0000000000..6e357556f1
--- /dev/null
+++ b/src/web/hooks/use-query/user.ts
@@ -0,0 +1,125 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionData} from 'gmp/commands/entity';
+import type Response from 'gmp/http/response';
+import type User from 'gmp/models/user';
+import useGmp from 'web/hooks/useGmp';
+import {type RefetchIntervalFn} from 'web/queries/helpers';
+import useGetEntity from 'web/queries/useGetEntity';
+import useGmpMutation from 'web/queries/useGmpMutation';
+
+interface UseGetUserParams {
+  id: string;
+  refetchInterval?: RefetchIntervalFn<User>;
+}
+
+interface UseUserMutationCallbacks<TResponse> {
+  onSuccess?: (response: TResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UserCreateInput {
+  accessHosts: string[];
+  authMethod: string;
+  comment: string;
+  groupIds: string[];
+  hostsAllow: string;
+  name: string;
+  password: string;
+  roleIds: string[];
+}
+
+interface UserSaveInput extends UserCreateInput {
+  id: string;
+  oldName?: string;
+}
+
+export const useGetUser = ({id, refetchInterval}: UseGetUserParams) => {
+  const gmp = useGmp();
+  return useGetEntity<User>({
+    gmpMethod: gmp.user.get.bind(gmp.user),
+    queryId: 'get_user',
+    id,
+    refetchInterval,
+  });
+};
+
+export const useCreateUser = ({
+  onSuccess,
+  onError,
+}: UseUserMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UserCreateInput, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.user.create(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_users'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useSaveUser = ({
+  onSuccess,
+  onError,
+}: UseUserMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UserSaveInput, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.user.save({
+        ...data,
+        oldName: data.oldName ?? data.name,
+      });
+      return response.data;
+    },
+    invalidateQueryIds: ['get_users', 'get_user'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCloneUser = ({
+  onSuccess,
+  onError,
+}: UseUserMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string}, EntityActionData>({
+    gmpMethod: async ({id}: {id: string}) => {
+      const response = await gmp.user.clone({id});
+      return response.data;
+    },
+    invalidateQueryIds: ['get_users'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDeleteUser = ({
+  onSuccess,
+  onError,
+}: UseUserMutationCallbacks<void> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string; inheritorId?: string}, void>({
+    gmpMethod: ({id, inheritorId}: {id: string; inheritorId?: string}) =>
+      gmp.user.delete({id, inheritorId: inheritorId ?? ''}),
+    invalidateQueryIds: ['get_users', 'get_user'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDownloadUser = ({
+  onSuccess,
+  onError,
+}: UseUserMutationCallbacks<Response<string | ArrayBuffer>> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<{id: string}, Response<string | ArrayBuffer>>({
+    gmpMethod: (entity: {id: string}) => gmp.user.export(entity),
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/users.ts b/src/web/hooks/use-query/users.ts
index a5de2994f7..4c608935bf 100644
--- a/src/web/hooks/use-query/users.ts
+++ b/src/web/hooks/use-query/users.ts
@@ -3,15 +3,12 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionData} from 'gmp/commands/entity';
 import type Response from 'gmp/http/response';
 import {type FilterType} from 'gmp/models/filter';
 import {isFilterType} from 'gmp/models/filter/utils';
 import type User from 'gmp/models/user';
 import useGmp from 'web/hooks/useGmp';
-import {type RefetchIntervalFn} from 'web/queries/helpers';
 import useGetEntities from 'web/queries/useGetEntities';
-import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UseGetUsersParams {
@@ -19,32 +16,11 @@ interface UseGetUsersParams {
   enabled?: boolean;
 }
 
-interface UseGetUserParams {
-  id: string;
-  refetchInterval?: RefetchIntervalFn<User>;
-}
-
 interface UseUserMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
   onError?: (error: Error) => void;
 }
 
-interface UserCreateInput {
-  accessHosts: string[];
-  authMethod: string;
-  comment: string;
-  groupIds: string[];
-  hostsAllow: string;
-  name: string;
-  password: string;
-  roleIds: string[];
-}
-
-interface UserSaveInput extends UserCreateInput {
-  id: string;
-  oldName?: string;
-}
-
 interface BulkDeleteUsersInput {
   users: User[];
   options?: {inheritor_id?: string};
@@ -66,81 +42,6 @@ export const useGetUsers = ({
   });
 };
 
-export const useGetUser = ({id, refetchInterval}: UseGetUserParams) => {
-  const gmp = useGmp();
-  return useGetEntity<User>({
-    gmpMethod: gmp.user.get.bind(gmp.user),
-    queryId: 'get_user',
-    id,
-    refetchInterval,
-  });
-};
-
-export const useCreateUser = ({
-  onSuccess,
-  onError,
-}: UseUserMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<UserCreateInput, EntityActionData>({
-    gmpMethod: async data => {
-      const response = await gmp.user.create(data);
-      return response.data;
-    },
-    invalidateQueryIds: ['get_users'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useSaveUser = ({
-  onSuccess,
-  onError,
-}: UseUserMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<UserSaveInput, EntityActionData>({
-    gmpMethod: async data => {
-      const response = await gmp.user.save({
-        ...data,
-        oldName: data.oldName ?? data.name,
-      });
-      return response.data;
-    },
-    invalidateQueryIds: ['get_users', 'get_user'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useCloneUser = ({
-  onSuccess,
-  onError,
-}: UseUserMutationCallbacks<EntityActionData> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string}, EntityActionData>({
-    gmpMethod: async ({id}: {id: string}) => {
-      const response = await gmp.user.clone({id});
-      return response.data;
-    },
-    invalidateQueryIds: ['get_users'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useDeleteUser = ({
-  onSuccess,
-  onError,
-}: UseUserMutationCallbacks<void> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string; inheritorId?: string}, void>({
-    gmpMethod: ({id, inheritorId}: {id: string; inheritorId?: string}) =>
-      gmp.user.delete({id, inheritorId: inheritorId ?? ''}),
-    invalidateQueryIds: ['get_users', 'get_user'],
-    onSuccess,
-    onError,
-  });
-};
-
 export const useBulkDeleteUsers = ({
   onSuccess,
   onError,
@@ -154,18 +55,6 @@ export const useBulkDeleteUsers = ({
   });
 };
 
-export const useDownloadUser = ({
-  onSuccess,
-  onError,
-}: UseUserMutationCallbacks<Response<string | ArrayBuffer>> = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<{id: string}, Response<string | ArrayBuffer>>({
-    gmpMethod: (entity: {id: string}) => gmp.user.export(entity),
-    onSuccess,
-    onError,
-  });
-};
-
 export const useBulkExportUsers = ({
   onSuccess,
   onError,
diff --git a/src/web/pages/users/UserComponent.tsx b/src/web/pages/users/UserComponent.tsx
index 45d83b09ea..bcfd94300d 100644
--- a/src/web/pages/users/UserComponent.tsx
+++ b/src/web/pages/users/UserComponent.tsx
@@ -16,7 +16,7 @@ import {
   useCreateUser,
   useDeleteUser,
   useSaveUser,
-} from 'web/hooks/use-query/users';
+} from 'web/hooks/use-query/user';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
 import UserDialog, {type UserDialogSaveData} from 'web/pages/users/UsersDialog';
diff --git a/src/web/pages/users/UserDetailsPage.tsx b/src/web/pages/users/UserDetailsPage.tsx
index ef37e4ed9e..b4524f12e8 100644
--- a/src/web/pages/users/UserDetailsPage.tsx
+++ b/src/web/pages/users/UserDetailsPage.tsx
@@ -38,7 +38,7 @@ import EditIcon from 'web/entity/icon/EditIcon';
 import {goToDetails, goToList} from 'web/entity/navigation';
 import EntityTags from 'web/entity/Tags';
 import {useGetPermissions} from 'web/hooks/use-query/permissions';
-import {useGetUser} from 'web/hooks/use-query/users';
+import {useGetUser} from 'web/hooks/use-query/user';
 import useTranslation from 'web/hooks/useTranslation';
 import UserComponent from 'web/pages/users/UserComponent';
 import UserDetails from 'web/pages/users/UserDetails';

From c4a60c1f4321f29140930c2c17309470c8328a9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 13:44:02 +0200
Subject: [PATCH 03/36] Change: Add Ticket clone and delete success messages to
 query hooks

Ensure when cloning and deleting tickets via their query hooks a
notification message is displayed.
---
 .../hooks/use-query/__tests__/Ticket.test.tsx | 84 +++++++++++++++++--
 src/web/hooks/use-query/ticket.ts             | 23 +++--
 2 files changed, 94 insertions(+), 13 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/Ticket.test.tsx b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
index a863b0bea2..bec30ab764 100644
--- a/src/web/hooks/use-query/__tests__/Ticket.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
@@ -151,14 +151,21 @@ describe('ticket mutation hooks', () => {
     });
   });
 
-  test('should clone a ticket', async () => {
+  test('should clone a ticket with its name and call onSuccess', async () => {
     const gmp = createGmp();
+    const onSuccess = testing.fn();
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      const mutation = useCloneTicket();
+      const mutation = useCloneTicket({onSuccess});
       return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>Clone</button>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'ticket-1', name: 'Cloned Ticket'})
+          }
+        >
+          Clone
+        </button>
       );
     };
 
@@ -166,18 +173,50 @@ describe('ticket mutation hooks', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
 
     await waitFor(() => {
-      expect(gmp.ticket.clone).toHaveBeenCalledWith({id: 'ticket-1'});
+      expect(gmp.ticket.clone).toHaveBeenCalledWith({
+        id: 'ticket-1',
+        name: 'Cloned Ticket',
+      });
+      expect(onSuccess).toHaveBeenCalledWith({id: 'ticket-3'});
+      expect(
+        screen.getByText('Cloned Ticket cloned successfully.'),
+      ).toBeInTheDocument();
     });
   });
 
-  test('should delete a ticket', async () => {
+  test('should call onError when cloning a ticket fails', async () => {
+    const error = new Error('Clone failed');
     const gmp = createGmp();
+    gmp.ticket.clone.mockRejectedValue(error);
+    const onError = testing.fn();
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      const mutation = useDeleteTicket();
+      const mutation = useCloneTicket({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
+        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>Clone</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+
+  test('should delete a ticket with its name and call onSuccess', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteTicket({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'ticket-1', name: 'Deleted Ticket'})
+          }
+        >
           Delete
         </button>
       );
@@ -187,10 +226,39 @@ describe('ticket mutation hooks', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
 
     await waitFor(() => {
-      expect(gmp.ticket.delete).toHaveBeenCalledWith({id: 'ticket-1'});
+      expect(gmp.ticket.delete).toHaveBeenCalledWith({
+        id: 'ticket-1',
+        name: 'Deleted Ticket',
+      });
+      expect(onSuccess).toHaveBeenCalledWith(undefined);
+      expect(
+        screen.getByText('Deleted Ticket deleted successfully.'),
+      ).toBeInTheDocument();
     });
   });
 
+  test('should call onError when deleting a ticket fails', async () => {
+    const error = new Error('Delete failed');
+    const gmp = createGmp();
+    gmp.ticket.delete.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteTicket({onError});
+      return (
+        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+
   test('should download a ticket', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
diff --git a/src/web/hooks/use-query/ticket.ts b/src/web/hooks/use-query/ticket.ts
index 784bd73d20..de7b94069a 100644
--- a/src/web/hooks/use-query/ticket.ts
+++ b/src/web/hooks/use-query/ticket.ts
@@ -5,6 +5,7 @@
 
 import {type EntityActionData} from 'gmp/commands/entity';
 import type Response from 'gmp/http/response';
+import _ from 'gmp/locale';
 import {
   type default as Ticket,
   type TicketStatusValue,
@@ -17,6 +18,10 @@ interface UseGetTicketParams {
   id: string;
 }
 
+interface UseModifyTicketParams extends UseGetTicketParams {
+  name?: string;
+}
+
 interface UseTicketMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
   onError?: (error: Error) => void;
@@ -83,12 +88,16 @@ export const useCloneTicket = ({
   onError,
 }: UseTicketMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<{id: string}, EntityActionData>({
-    gmpMethod: async ({id}: {id: string}) => {
-      const response = await gmp.ticket.clone({id});
+  return useGmpMutation<UseModifyTicketParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.ticket.clone(data);
       return response.data;
     },
     invalidateQueryIds: ['get_tickets'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} cloned successfully.', {
+        name: entity.name as string,
+      }),
     onSuccess,
     onError,
   });
@@ -99,9 +108,13 @@ export const useDeleteTicket = ({
   onError,
 }: UseTicketMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<{id: string}, void>({
-    gmpMethod: ({id}: {id: string}) => gmp.ticket.delete({id}),
+  return useGmpMutation<UseModifyTicketParams, void>({
+    gmpMethod: data => gmp.ticket.delete(data),
     invalidateQueryIds: ['get_tickets', 'get_ticket'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} deleted successfully.', {
+        name: entity.name as string,
+      }),
     onSuccess,
     onError,
   });

From 559cca432beb6d5a3337c91954bacf222aec7f8e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 13:52:28 +0200
Subject: [PATCH 04/36] test: Update Group and Role query hook tests

Use dedicated describe blocks for each hook and use real model instances
in the tests.
---
 .../hooks/use-query/__tests__/Groups.test.tsx | 40 ++++++++++++++++---
 .../hooks/use-query/__tests__/Roles.test.tsx  | 40 ++++++++++++++++---
 2 files changed, 68 insertions(+), 12 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/Groups.test.tsx b/src/web/hooks/use-query/__tests__/Groups.test.tsx
index 7b4f839651..a4c576d023 100644
--- a/src/web/hooks/use-query/__tests__/Groups.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Groups.test.tsx
@@ -7,11 +7,12 @@ import {describe, expect, test, testing} from '@gsa/testing';
 import {rendererWith, screen, waitFor} from 'web/testing';
 import CollectionCounts from 'gmp/collection/collection-counts';
 import QueryFilter from 'gmp/models/filter/query-filter';
+import Group from 'gmp/models/group';
 import {createSession} from 'gmp/testing';
 import {useGetAllGroups, useGetGroups} from 'web/hooks/use-query/groups';
 
 const filter = QueryFilter.fromString('name~group');
-const groups = [{id: 'group-1', name: 'Group 1'}];
+const groups = [new Group({id: 'group-1', name: 'Group 1'})];
 
 const createGmp = () => {
   const response = {
@@ -32,7 +33,7 @@ const createGmp = () => {
   };
 };
 
-describe('group query hooks', () => {
+describe('useGetGroups', () => {
   test('should fetch groups with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -52,6 +53,37 @@ describe('group query hooks', () => {
     expect(gmp.groups.getAll).not.toHaveBeenCalled();
   });
 
+  test('should not fetch groups when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetGroups({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.groups.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch groups without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetGroups({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.groups.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useGetAllGroups', () => {
   test('should fetch all groups with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -76,14 +108,12 @@ describe('group query hooks', () => {
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      useGetGroups({enabled: false});
       useGetAllGroups({enabled: false});
       return <div />;
     };
 
     render(<TestComponent />);
 
-    expect(gmp.groups.get).not.toHaveBeenCalled();
     expect(gmp.groups.getAll).not.toHaveBeenCalled();
   });
 
@@ -93,14 +123,12 @@ describe('group query hooks', () => {
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      useGetGroups({filter});
       useGetAllGroups({filter});
       return <div />;
     };
 
     render(<TestComponent />);
 
-    expect(gmp.groups.get).not.toHaveBeenCalled();
     expect(gmp.groups.getAll).not.toHaveBeenCalled();
   });
 });
diff --git a/src/web/hooks/use-query/__tests__/Roles.test.tsx b/src/web/hooks/use-query/__tests__/Roles.test.tsx
index bcad03a074..c40814fb2b 100644
--- a/src/web/hooks/use-query/__tests__/Roles.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Roles.test.tsx
@@ -7,11 +7,12 @@ import {describe, expect, test, testing} from '@gsa/testing';
 import {rendererWith, screen, waitFor} from 'web/testing';
 import CollectionCounts from 'gmp/collection/collection-counts';
 import QueryFilter from 'gmp/models/filter/query-filter';
+import Role from 'gmp/models/role';
 import {createSession} from 'gmp/testing';
 import {useGetAllRoles, useGetRoles} from 'web/hooks/use-query/roles';
 
 const filter = QueryFilter.fromString('name~role');
-const roles = [{id: 'role-1', name: 'Role 1'}];
+const roles = [new Role({id: 'role-1', name: 'Role 1'})];
 
 const createGmp = () => {
   const response = {
@@ -32,7 +33,7 @@ const createGmp = () => {
   };
 };
 
-describe('role query hooks', () => {
+describe('useGetRoles', () => {
   test('should fetch roles with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -52,6 +53,37 @@ describe('role query hooks', () => {
     expect(gmp.roles.getAll).not.toHaveBeenCalled();
   });
 
+  test('should not fetch roles when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetRoles({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.roles.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch roles without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetRoles({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.roles.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useGetAllRoles', () => {
   test('should fetch all roles with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -76,14 +108,12 @@ describe('role query hooks', () => {
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      useGetRoles({enabled: false});
       useGetAllRoles({enabled: false});
       return <div />;
     };
 
     render(<TestComponent />);
 
-    expect(gmp.roles.get).not.toHaveBeenCalled();
     expect(gmp.roles.getAll).not.toHaveBeenCalled();
   });
 
@@ -93,14 +123,12 @@ describe('role query hooks', () => {
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      useGetRoles({filter});
       useGetAllRoles({filter});
       return <div />;
     };
 
     render(<TestComponent />);
 
-    expect(gmp.roles.get).not.toHaveBeenCalled();
     expect(gmp.roles.getAll).not.toHaveBeenCalled();
   });
 });

From 60da0ac1acc410d5fd1aa68ec91edae7858d5230 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 14:08:12 +0200
Subject: [PATCH 05/36] Change: Add User clone and delete success messages to
 query hooks

Ensure when cloning and deleting users via their query hooks a
notification message is displayed.
---
 .../hooks/use-query/__tests__/User.test.tsx   | 86 +++++++++++++++++--
 src/web/hooks/use-query/user.ts               | 26 +++++-
 2 files changed, 99 insertions(+), 13 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/User.test.tsx b/src/web/hooks/use-query/__tests__/User.test.tsx
index b350a5b08d..15c3837242 100644
--- a/src/web/hooks/use-query/__tests__/User.test.tsx
+++ b/src/web/hooks/use-query/__tests__/User.test.tsx
@@ -208,11 +208,45 @@ describe('useSaveUser', () => {
 });
 
 describe('remaining user mutation hooks', () => {
-  test('should clone a user', async () => {
+  test('should clone a user with its name and call onSuccess', async () => {
     const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useCloneUser({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({
+              id: 'user-id',
+              name: 'Cloned User',
+            })
+          }
+        >
+          Clone
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.user.clone).toHaveBeenCalledWith({id: 'user-id'});
+      expect(onSuccess).toHaveBeenCalledWith({id: 'cloned'});
+      expect(
+        screen.getByText('Cloned User cloned successfully.'),
+      ).toBeInTheDocument();
+    });
+  });
+
+  test('should call onError when cloning a user fails', async () => {
+    const error = new Error('Clone failed');
+    const gmp = createGmp({clone: testing.fn().mockRejectedValue(error)});
+    const onError = testing.fn();
     const {render} = rendererWith({gmp, router: true});
     const TestComponent = () => {
-      const mutation = useCloneUser();
+      const mutation = useCloneUser({onError});
       return (
         <button onClick={() => mutation.mutate({id: 'user-id'})}>Clone</button>
       );
@@ -220,23 +254,57 @@ describe('remaining user mutation hooks', () => {
 
     render(<TestComponent />);
     fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
-    await waitFor(() =>
-      expect(gmp.user.clone).toHaveBeenCalledWith({id: 'user-id'}),
-    );
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
 
-  test('should delete a user and forward the inheritor ID', async () => {
+  test('should delete a user with its name and forward the inheritor ID', async () => {
     const gmp = createGmp();
+    const onSuccess = testing.fn();
     const {render} = rendererWith({gmp, router: true});
-    const input = {id: 'user-id', inheritorId: 'inheritor-id'};
+    const input = {
+      id: 'user-id',
+      name: 'Deleted User',
+      inheritorId: 'inheritor-id',
+    };
     const TestComponent = () => {
-      const mutation = useDeleteUser();
+      const mutation = useDeleteUser({onSuccess});
       return <button onClick={() => mutation.mutate(input)}>Delete</button>;
     };
 
     render(<TestComponent />);
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-    await waitFor(() => expect(gmp.user.delete).toHaveBeenCalledWith(input));
+
+    await waitFor(() => {
+      expect(gmp.user.delete).toHaveBeenCalledWith({
+        id: 'user-id',
+        inheritorId: 'inheritor-id',
+      });
+      expect(onSuccess).toHaveBeenCalledWith(undefined);
+      expect(
+        screen.getByText('Deleted User deleted successfully.'),
+      ).toBeInTheDocument();
+    });
+  });
+
+  test('should call onError when deleting a user fails', async () => {
+    const error = new Error('Delete failed');
+    const gmp = createGmp({
+      delete: testing.fn().mockRejectedValue(error),
+    });
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDeleteUser({onError});
+      return (
+        <button onClick={() => mutation.mutate({id: 'user-id'})}>Delete</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
 
   test('should download a user', async () => {
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
index 6e357556f1..ce827cb37c 100644
--- a/src/web/hooks/use-query/user.ts
+++ b/src/web/hooks/use-query/user.ts
@@ -5,6 +5,7 @@
 
 import {type EntityActionData} from 'gmp/commands/entity';
 import type Response from 'gmp/http/response';
+import _ from 'gmp/locale';
 import type User from 'gmp/models/user';
 import useGmp from 'web/hooks/useGmp';
 import {type RefetchIntervalFn} from 'web/queries/helpers';
@@ -16,6 +17,15 @@ interface UseGetUserParams {
   refetchInterval?: RefetchIntervalFn<User>;
 }
 
+interface UseModifyUserParams {
+  id: string;
+  name?: string;
+}
+
+interface UseDeleteUserParams extends UseModifyUserParams {
+  inheritorId?: string;
+}
+
 interface UseUserMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
   onError?: (error: Error) => void;
@@ -87,12 +97,16 @@ export const useCloneUser = ({
   onError,
 }: UseUserMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<{id: string}, EntityActionData>({
-    gmpMethod: async ({id}: {id: string}) => {
+  return useGmpMutation<UseModifyUserParams, EntityActionData>({
+    gmpMethod: async ({id}: UseModifyUserParams) => {
       const response = await gmp.user.clone({id});
       return response.data;
     },
     invalidateQueryIds: ['get_users'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} cloned successfully.', {
+        name: entity.name as string,
+      }),
     onSuccess,
     onError,
   });
@@ -103,10 +117,14 @@ export const useDeleteUser = ({
   onError,
 }: UseUserMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<{id: string; inheritorId?: string}, void>({
-    gmpMethod: ({id, inheritorId}: {id: string; inheritorId?: string}) =>
+  return useGmpMutation<UseDeleteUserParams, void>({
+    gmpMethod: ({id, inheritorId}: UseDeleteUserParams) =>
       gmp.user.delete({id, inheritorId: inheritorId ?? ''}),
     invalidateQueryIds: ['get_users', 'get_user'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} deleted successfully.', {
+        name: entity.name as string,
+      }),
     onSuccess,
     onError,
   });

From 8254800f0c30eaf589a9e74791022bb12b10a974 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 14:12:40 +0200
Subject: [PATCH 06/36] Add query hooks for Target

Allow to query Target data via use query hooks.
---
 src/gmp/commands/target.ts                    |   2 +-
 .../hooks/use-query/__tests__/Target.test.tsx | 201 ++++++++++++++++++
 .../use-query/__tests__/Targets.test.tsx      | 134 ++++++++++++
 src/web/hooks/use-query/target.ts             | 106 +++++++++
 src/web/hooks/use-query/targets.ts            |  45 ++++
 5 files changed, 487 insertions(+), 1 deletion(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Target.test.tsx
 create mode 100644 src/web/hooks/use-query/__tests__/Targets.test.tsx
 create mode 100644 src/web/hooks/use-query/target.ts
 create mode 100644 src/web/hooks/use-query/targets.ts

diff --git a/src/gmp/commands/target.ts b/src/gmp/commands/target.ts
index 1971f78f23..a0c5b53d06 100644
--- a/src/gmp/commands/target.ts
+++ b/src/gmp/commands/target.ts
@@ -16,7 +16,7 @@ import {UNSET_VALUE} from 'web/utils/Render';
 export type TargetSource = 'manual' | 'file' | 'asset_hosts';
 export type TargetExcludeSource = 'manual' | 'file';
 
-interface TargetCommandCreateParams {
+export interface TargetCommandCreateParams {
   aliveTests?: AliveTest[];
   allowSimultaneousIPs?: boolean;
   comment?: string;
diff --git a/src/web/hooks/use-query/__tests__/Target.test.tsx b/src/web/hooks/use-query/__tests__/Target.test.tsx
new file mode 100644
index 0000000000..668b9ae249
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Target.test.tsx
@@ -0,0 +1,201 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import Target from 'gmp/models/target';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneTarget,
+  useDeleteTarget,
+  useGetTarget,
+} from 'web/hooks/use-query/target';
+
+const target = new Target({id: 'target-1', name: 'Target 1'});
+
+const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
+  session: createSession({token}),
+  settings: {},
+  target: {
+    get: testing.fn().mockResolvedValue({data: target}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+  },
+});
+
+describe('useGetTarget', () => {
+  test('should fetch a target by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetTarget({id: target.id});
+      return <div data-testid="target">{data?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('target')).toHaveTextContent('Target 1');
+    });
+
+    expect(gmp.target.get).toHaveBeenCalledWith({id: target.id});
+  });
+
+  test('should not fetch when the ID is empty', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetTarget({id: ''});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.target.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch without a session token', () => {
+    const gmp = createGmp({token: undefined});
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetTarget({id: target.id});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.target.get).not.toHaveBeenCalled();
+  });
+
+  test('should show an error when fetching a target fails', async () => {
+    const gmp = createGmp();
+    gmp.target.get.mockRejectedValue(new Error('Request failed'));
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {isError} = useGetTarget({id: target.id});
+      return <div data-testid="error">{isError ? 'Error' : ''}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('error')).toHaveTextContent('Error');
+    });
+  });
+});
+
+describe('target mutation hooks', () => {
+  test('should clone a target with its name and call onSuccess', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCloneTarget({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'target-1', name: 'Cloned Target'})
+          }
+        >
+          Clone
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.target.clone).toHaveBeenCalledWith({
+        id: 'target-1',
+        name: 'Cloned Target',
+      });
+      expect(onSuccess).toHaveBeenCalledWith({id: 'target-2'});
+      expect(
+        screen.getByText('Cloned Target cloned successfully.'),
+      ).toBeInTheDocument();
+    });
+  });
+
+  test('should call onError when cloning a target fails', async () => {
+    const error = new Error('Clone failed');
+    const gmp = createGmp();
+    gmp.target.clone.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCloneTarget({onError});
+      return (
+        <button onClick={() => mutation.mutate({id: 'target-1'})}>Clone</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+
+  test('should delete a target with its name and call onSuccess', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteTarget({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'target-1', name: 'Deleted Target'})
+          }
+        >
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.target.delete).toHaveBeenCalledWith({
+        id: 'target-1',
+        name: 'Deleted Target',
+      });
+      expect(onSuccess).toHaveBeenCalledWith(undefined);
+      expect(
+        screen.getByText('Deleted Target deleted successfully.'),
+      ).toBeInTheDocument();
+    });
+  });
+
+  test('should call onError when deleting a target fails', async () => {
+    const error = new Error('Delete failed');
+    const gmp = createGmp();
+    gmp.target.delete.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteTarget({onError});
+      return (
+        <button onClick={() => mutation.mutate({id: 'target-1'})}>
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Targets.test.tsx b/src/web/hooks/use-query/__tests__/Targets.test.tsx
new file mode 100644
index 0000000000..dbd88f5482
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Targets.test.tsx
@@ -0,0 +1,134 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import CollectionCounts from 'gmp/collection/collection-counts';
+import QueryFilter from 'gmp/models/filter/query-filter';
+import Target from 'gmp/models/target';
+import {createSession} from 'gmp/testing';
+import {useGetAllTargets, useGetTargets} from 'web/hooks/use-query/targets';
+
+const filter = QueryFilter.fromString('name~target');
+const targets = [new Target({id: 'target-1', name: 'Target 1'})];
+
+const createGmp = () => {
+  const response = {
+    data: targets,
+    meta: {
+      filter,
+      counts: new CollectionCounts({all: 1, filtered: 1, length: 1}),
+    },
+  };
+
+  return {
+    session: createSession({token: 'test-token'}),
+    settings: {},
+    targets: {
+      get: testing.fn().mockResolvedValue(response),
+      getAll: testing.fn().mockResolvedValue(response),
+    },
+  };
+};
+
+describe('useGetTargets', () => {
+  test('should fetch targets with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetTargets({filter});
+      return <div data-testid="target">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('target')).toHaveTextContent('Target 1');
+    });
+
+    expect(gmp.targets.get).toHaveBeenCalledWith({filter});
+    expect(gmp.targets.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch targets when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetTargets({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.targets.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch targets without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetTargets({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.targets.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useGetAllTargets', () => {
+  test('should fetch all targets with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetAllTargets({filter});
+      return <div data-testid="target">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('target')).toHaveTextContent('Target 1');
+    });
+
+    expect(gmp.targets.getAll).toHaveBeenCalledWith({filter});
+    expect(gmp.targets.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch targets when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllTargets({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.targets.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch targets without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllTargets({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.targets.getAll).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/web/hooks/use-query/target.ts b/src/web/hooks/use-query/target.ts
new file mode 100644
index 0000000000..428c0a81e1
--- /dev/null
+++ b/src/web/hooks/use-query/target.ts
@@ -0,0 +1,106 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionData} from 'gmp/commands/entity';
+import {
+  type TargetCommandCreateParams,
+  type TargetCommandSaveParams,
+} from 'gmp/commands/target';
+import _ from 'gmp/locale';
+import type Target from 'gmp/models/target';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntity from 'web/queries/useGetEntity';
+import useGmpMutation from 'web/queries/useGmpMutation';
+
+interface UseTargetMutationCallbacks<TResponse> {
+  onSuccess?: (response: TResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseGetTargetParams {
+  id: string;
+}
+
+interface UseModifyTargetParams extends UseGetTargetParams {
+  name?: string;
+}
+
+export const useGetTarget = ({id}: UseGetTargetParams) => {
+  const gmp = useGmp();
+  return useGetEntity<Target>({
+    gmpMethod: (data: UseGetTargetParams) => gmp.target.get(data),
+    queryId: 'get_targets',
+    id,
+  });
+};
+
+export const useCreateTarget = ({
+  onSuccess,
+  onError,
+}: UseTargetMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<TargetCommandCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.target.create(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_targets'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useSaveTarget = ({
+  onSuccess,
+  onError,
+}: UseTargetMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<TargetCommandSaveParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.target.save(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_targets', 'get_target'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCloneTarget = ({
+  onSuccess,
+  onError,
+}: UseTargetMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UseModifyTargetParams, EntityActionData>({
+    gmpMethod: async ({id}: UseModifyTargetParams) => {
+      const response = await gmp.target.clone({id});
+      return response.data;
+    },
+    invalidateQueryIds: ['get_targets'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} cloned successfully.', {
+        name: entity.name as string,
+      }),
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDeleteTarget = ({
+  onSuccess,
+  onError,
+}: UseTargetMutationCallbacks<void> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UseModifyTargetParams, void>({
+    gmpMethod: ({id}: UseModifyTargetParams) => gmp.target.delete({id}),
+    invalidateQueryIds: ['get_targets', 'get_target'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} deleted successfully.', {
+        name: entity.name as string,
+      }),
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/targets.ts b/src/web/hooks/use-query/targets.ts
new file mode 100644
index 0000000000..b227b64fb2
--- /dev/null
+++ b/src/web/hooks/use-query/targets.ts
@@ -0,0 +1,45 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type FilterType} from 'gmp/models/filter';
+import type Target from 'gmp/models/target';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntities from 'web/queries/useGetEntities';
+
+interface UseGetTasksParams {
+  enabled?: boolean;
+  filter?: FilterType;
+  staleTime?: number;
+}
+
+export const useGetTargets = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetTasksParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<Target>({
+    gmpMethod: gmp.targets.get.bind(gmp.targets),
+    queryId: 'get_targets',
+    enabled,
+    filter,
+    staleTime,
+  });
+};
+
+export const useGetAllTargets = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetTasksParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<Target>({
+    gmpMethod: gmp.targets.getAll.bind(gmp.targets),
+    queryId: 'get_targets',
+    enabled,
+    filter,
+    staleTime,
+  });
+};

From 2784fcd77fb703a9a2a2c7c600a85aae5ddecf64 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 14:13:47 +0200
Subject: [PATCH 07/36] Change: Allow to pass a response or the data directly
 to goToDetails

As query hooks might not return a response object and instead the data
directly the goToDetails function needs to support this use case.
---
 src/web/entity/navigation.ts | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/web/entity/navigation.ts b/src/web/entity/navigation.ts
index 86e5b39dd8..93c4ab1cd6 100644
--- a/src/web/entity/navigation.ts
+++ b/src/web/entity/navigation.ts
@@ -7,21 +7,23 @@ import {type EntityType} from 'gmp/utils/entity-type';
 import {isDefined, isFunction} from 'gmp/utils/identity';
 import {entityListURL, entityURL, type EntityListType} from 'web/route-paths';
 
-export type NavigateFunc = (path: string) => void;
+type NavigateFunc = (path: string) => void;
 
-export interface NavigateObj {
+interface NavigateObj {
   navigate: NavigateFunc;
 }
 
-export type Navigate = NavigateFunc | NavigateObj;
+type Navigate = NavigateFunc | NavigateObj;
 
-export interface GotoDetailsObj {
-  data: {
-    id: string;
-  };
+interface GotoDetailsData {
+  id: string;
 }
 
-export type GotoDetailsFunc = ({data}: GotoDetailsObj) => void;
+interface GotoDetailsObj {
+  data: GotoDetailsData;
+}
+
+export type GotoDetailsFunc = (data: GotoDetailsObj | GotoDetailsData) => void;
 export type GotoListFunc = () => void;
 
 /**
@@ -47,7 +49,8 @@ export const goToDetails = (
       throw new Error('navigate function is required for goToDetails');
     }
   }
-  return ({data}) => navigate(entityURL(type, String(data.id)));
+  return data =>
+    navigate(entityURL(type, String('id' in data ? data.id : data.data.id)));
 };
 
 /**

From 0359edc60a6b6162e68b79c499f69098bb39ceba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Mon, 5 Oct 2026 14:17:26 +0200
Subject: [PATCH 08/36] Change: Use new target query hooks in TargetComponent

Refactor TargetComponent to use the new query hooks for target.
---
 src/web/pages/policies/PoliciesComponent.tsx |  3 +-
 src/web/pages/targets/TargetComponent.tsx    | 93 ++++++++++----------
 src/web/pages/tasks/TaskComponent.tsx        |  5 +-
 3 files changed, 51 insertions(+), 50 deletions(-)

diff --git a/src/web/pages/policies/PoliciesComponent.tsx b/src/web/pages/policies/PoliciesComponent.tsx
index b3d028d084..98ff2af39d 100644
--- a/src/web/pages/policies/PoliciesComponent.tsx
+++ b/src/web/pages/policies/PoliciesComponent.tsx
@@ -5,6 +5,7 @@
 
 import React, {useState, useCallback, useEffect} from 'react';
 import {useDispatch} from 'react-redux';
+import {type EntityActionData} from 'gmp/commands/entity';
 import {type NvtFamily} from 'gmp/commands/nvt-families';
 import {
   type ScanConfigFamilyNvt,
@@ -285,7 +286,7 @@ const PolicyComponent = ({
     setScheduleId(data.id);
   };
 
-  const handleTargetCreated = ({data}) => {
+  const handleTargetCreated = (data: EntityActionData) => {
     fetchTargets();
     setTargetId(data.id);
   };
diff --git a/src/web/pages/targets/TargetComponent.tsx b/src/web/pages/targets/TargetComponent.tsx
index fcf15e4e35..909636cb20 100644
--- a/src/web/pages/targets/TargetComponent.tsx
+++ b/src/web/pages/targets/TargetComponent.tsx
@@ -4,6 +4,7 @@
  */
 
 import {useState, useRef} from 'react';
+import {type EntityActionData} from 'gmp/commands/entity';
 import {
   type TargetCommandSaveParams,
   type TargetExcludeSource,
@@ -22,19 +23,15 @@ import {
 } from 'gmp/models/target';
 import {first} from 'gmp/utils/array';
 import {isDefined} from 'gmp/utils/identity';
-import useEntityClone, {
-  type EntityCloneResponse,
-} from 'web/entity/hooks/useEntityClone';
-import useEntityCreate, {
-  type EntityCreateResponse,
-} from 'web/entity/hooks/useEntityCreate';
-import useEntityDelete from 'web/entity/hooks/useEntityDelete';
 import useEntityDownload, {
   type OnDownloadedFunc,
 } from 'web/entity/hooks/useEntityDownload';
-import useEntitySave, {
-  type EntitySaveResponse,
-} from 'web/entity/hooks/useEntitySave';
+import {
+  useCloneTarget,
+  useCreateTarget,
+  useDeleteTarget,
+  useSaveTarget,
+} from 'web/hooks/use-query/target';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
 import CredentialDialog, {
@@ -66,15 +63,15 @@ interface TargetComponentRenderProps {
 
 interface TargetComponentProps {
   children: (props: TargetComponentRenderProps) => React.ReactNode;
-  onCloned?: (response: EntityCloneResponse) => void;
+  onCloned?: (data: EntityActionData) => void;
   onCloneError?: (error: Error) => void;
-  onCreated?: (response: EntityCreateResponse) => void;
+  onCreated?: (data: EntityActionData) => void;
   onCreateError?: (error: Error) => void;
   onDeleted?: () => void;
   onDeleteError?: (error: Error) => void;
   onDownloaded?: OnDownloadedFunc;
   onDownloadError?: (error: Error) => void;
-  onSaved?: (response: EntitySaveResponse) => void;
+  onSaved?: (data: EntityActionData) => void;
   onSaveError?: (error: Error) => void;
 }
 
@@ -339,33 +336,45 @@ const TargetComponent = ({
     setKrb5CredentialId(krb5CredentialId ?? UNSET_VALUE);
   };
 
-  const handleEntityClone = useEntityClone<Target>(
-    entity => gmp.target.clone(entity),
-    {
-      onCloned,
-      onCloneError,
-    },
-  );
+  const cloneTarget = useCloneTarget({
+    onSuccess: onCloned,
+    onError: onCloneError,
+  });
 
-  const handleEntitySave = useEntitySave<TargetCommandSaveParams>(
-    data => gmp.target.save(data),
-    {
-      onSaved,
-      onSaveError,
-    },
-  );
+  const handleTargetClone = async (entity: Target) => {
+    await cloneTarget.mutateAsync(entity);
+  };
 
-  const handleEntityCreate = useEntityCreate<TargetDialogData>(
-    data => gmp.target.create(data),
-    {
-      onCreated,
-      onCreateError,
-    },
-  );
+  const saveTarget = useSaveTarget({
+    onSuccess: onSaved,
+    onError: onSaveError,
+  });
+
+  const handleTargetSave = async (data: TargetCommandSaveParams) => {
+    await saveTarget.mutateAsync(data);
+  };
+
+  const createTarget = useCreateTarget({
+    onSuccess: onCreated,
+    onError: onCreateError,
+  });
+
+  const handleTargetCreate = async (data: TargetDialogData) => {
+    await createTarget.mutateAsync(data);
+  };
+
+  const deleteTarget = useDeleteTarget({
+    onSuccess: onDeleted,
+    onError: onDeleteError,
+  });
+
+  const handleTargetDelete = async (entity: Target) => {
+    await deleteTarget.mutateAsync(entity);
+  };
 
   const handleSaveClick = async (data: TargetDialogData) => {
     const promise = isDefined(data.id)
-      ? handleEntitySave(
+      ? handleTargetSave(
           data.inUse
             ? {
                 id: data.id as string,
@@ -378,7 +387,7 @@ const TargetComponent = ({
                 id: data.id as string,
               },
         )
-      : handleEntityCreate(data);
+      : handleTargetCreate(data);
     await promise;
     closeTargetDialog();
   };
@@ -391,20 +400,12 @@ const TargetComponent = ({
     },
   );
 
-  const handleEntityDelete = useEntityDelete<Target>(
-    entity => gmp.target.delete(entity),
-    {
-      onDeleted,
-      onDeleteError,
-    },
-  );
-
   return (
     <>
       {children({
-        clone: handleEntityClone,
+        clone: handleTargetClone,
         create: openCreateTargetDialog,
-        delete: handleEntityDelete,
+        delete: handleTargetDelete,
         download: handleEntityDownload,
         edit: openTargetDialog,
       })}
diff --git a/src/web/pages/tasks/TaskComponent.tsx b/src/web/pages/tasks/TaskComponent.tsx
index c26df7e757..a3ac73456c 100644
--- a/src/web/pages/tasks/TaskComponent.tsx
+++ b/src/web/pages/tasks/TaskComponent.tsx
@@ -5,6 +5,7 @@
 
 import React, {useState, useEffect, useCallback} from 'react';
 import {useDispatch} from 'react-redux';
+import {type EntityActionData} from 'gmp/commands/entity';
 import type Rejection from 'gmp/http/rejection';
 import type AgentGroup from 'gmp/models/agent-group';
 import date, {type Date} from 'gmp/models/date';
@@ -486,9 +487,7 @@ const TaskComponent = ({
     setScheduleId(data.id);
   };
 
-  const handleTargetCreated = (resp: {data: {id?: string}}) => {
-    const {data} = resp;
-
+  const handleTargetCreated = (data: EntityActionData) => {
     fetchTargets();
 
     setTargetId(data.id);

From b274ff6a7955edcfd20f8106cfda564a9e990539 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 10:52:39 +0200
Subject: [PATCH 09/36] Change deletePortRange command to just delete the port
 range

Before the changed port list was re-loaded after a port range was
deleted. This is completely unnecessary and also created several
additional requests when a user deleted several port ranges in the
dialog.
---
 src/gmp/commands/__tests__/port-list.test.ts |  8 +++-----
 src/gmp/commands/port-list.ts                | 15 +++++----------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/gmp/commands/__tests__/port-list.test.ts b/src/gmp/commands/__tests__/port-list.test.ts
index db67b84d17..f7aa7dfa9f 100644
--- a/src/gmp/commands/__tests__/port-list.test.ts
+++ b/src/gmp/commands/__tests__/port-list.test.ts
@@ -8,7 +8,6 @@ import PortListCommand, {FROM_FILE} from 'gmp/commands/port-list';
 import {
   createHttp,
   createActionResultResponse,
-  createHttpMany,
   createEntityResponse,
 } from 'gmp/commands/testing';
 
@@ -95,14 +94,13 @@ describe('PortListCommand tests', () => {
       action: 'delete_port_range',
       id: '12345',
     });
-    const entityResponse = createEntityResponse('port_list', {id: '324'});
-    const http = createHttpMany([response, entityResponse]);
+    const http = createHttp(response);
     const command = new PortListCommand(http);
     const result = await command.deletePortRange({
       id: '12345',
-      portListId: '67890',
     });
-    expect(result.data.id).toEqual('324');
+    expect(result).toBeUndefined();
+    expect(http.request).toHaveBeenCalledTimes(1);
   });
 
   test('should allow to get a port list', async () => {
diff --git a/src/gmp/commands/port-list.ts b/src/gmp/commands/port-list.ts
index 9a95d87312..64108e6fcb 100644
--- a/src/gmp/commands/port-list.ts
+++ b/src/gmp/commands/port-list.ts
@@ -26,19 +26,18 @@ export interface PortListCommandSaveParams {
   comment?: string;
 }
 
-interface PortListCommandCreatePortRangeParams {
+export interface PortListCommandCreatePortRangeParams {
   portListId: string;
   portRangeStart: number;
   portRangeEnd: number;
   portType: string;
 }
 
-interface PortListCommandDeletePortRangeParams {
+export interface PortListCommandDeletePortRangeParams {
   id: string;
-  portListId: string;
 }
 
-interface PortListCommandImportParams {
+export interface PortListCommandImportParams {
   xmlFile?: File;
 }
 
@@ -101,16 +100,12 @@ class PortListCommand extends EntityCommand<PortList, PortListElement> {
     });
   }
 
-  async deletePortRange({
-    id,
-    portListId,
-  }: PortListCommandDeletePortRangeParams) {
-    await this.httpPostWithTransform({
+  async deletePortRange({id}: PortListCommandDeletePortRangeParams) {
+    await this.action({
       cmd: 'delete_port_range',
       port_range_id: id,
       no_redirect: 1,
     });
-    return await this.get({id: portListId});
   }
 
   import({xmlFile}: PortListCommandImportParams) {

From db2e1221a605a793d78ff0dc6af76d1a15495685 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:13:12 +0200
Subject: [PATCH 10/36] Add query hooks for port list handling

Allow to query and mutate port lists via query hooks.
---
 .../use-query/__tests__/PortList.test.tsx     | 246 ++++++++++++++++++
 .../use-query/__tests__/PortLists.test.tsx    | 137 ++++++++++
 src/web/hooks/use-query/port-list.ts          | 146 +++++++++++
 src/web/hooks/use-query/port-lists.ts         |  45 ++++
 4 files changed, 574 insertions(+)
 create mode 100644 src/web/hooks/use-query/__tests__/PortList.test.tsx
 create mode 100644 src/web/hooks/use-query/__tests__/PortLists.test.tsx
 create mode 100644 src/web/hooks/use-query/port-list.ts
 create mode 100644 src/web/hooks/use-query/port-lists.ts

diff --git a/src/web/hooks/use-query/__tests__/PortList.test.tsx b/src/web/hooks/use-query/__tests__/PortList.test.tsx
new file mode 100644
index 0000000000..bbded3475d
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/PortList.test.tsx
@@ -0,0 +1,246 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {createSession} from 'gmp/testing';
+import {
+  useClonePortList,
+  useCreatePortList,
+  useCreatePortRange,
+  useDeletePortList,
+  useDeletePortRange,
+  useImportPortList,
+  useSavePortList,
+} from 'web/hooks/use-query/port-list';
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  portlist: {
+    create: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'port-list-2'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    import: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
+    createPortRange: testing.fn().mockResolvedValue({
+      data: {id: 'port-range-1'},
+    }),
+    deletePortRange: testing.fn().mockResolvedValue(undefined),
+  },
+});
+
+describe('useCreatePortList', () => {
+  test('should create a port list', async () => {
+    const gmp = createGmp();
+    const input = {
+      name: 'Port List 1',
+      comment: 'Port list comment',
+      portRange: '1-1024',
+    };
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreatePortList();
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.create).toHaveBeenCalledWith(input);
+    });
+  });
+
+  test('should call onSuccess with the created port list data', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreatePortList({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({name: 'Port List 1', portRange: '1-1024'})
+          }
+        >
+          Create
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(onSuccess).toHaveBeenCalledWith({id: 'port-list-1'});
+    });
+  });
+
+  test('should call onError when creating a port list fails', async () => {
+    const error = new Error('Create failed');
+    const gmp = createGmp();
+    gmp.portlist.create.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreatePortList({onError});
+      return (
+        <button onClick={() => mutation.mutate({name: 'Port List 1'})}>
+          Create
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+});
+
+describe('useSavePortList', () => {
+  test('should save a port list', async () => {
+    const gmp = createGmp();
+    const input = {id: 'port-list-1', name: 'Saved Port List'};
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useSavePortList();
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.save).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useClonePortList', () => {
+  test('should clone a port list by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useClonePortList();
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'port-list-1', name: 'Cloned Port List'})
+          }
+        >
+          Clone
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.clone).toHaveBeenCalledWith({id: 'port-list-1'});
+    });
+  });
+});
+
+describe('useDeletePortList', () => {
+  test('should delete a port list by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeletePortList();
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'port-list-1', name: 'Deleted Port List'})
+          }
+        >
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.delete).toHaveBeenCalledWith({id: 'port-list-1'});
+    });
+  });
+});
+
+describe('useImportPortList', () => {
+  test('should import a port list', async () => {
+    const gmp = createGmp();
+    const input = {xmlFile: new File(['port list'], 'port-list.xml')};
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useImportPortList();
+      return <button onClick={() => mutation.mutate(input)}>Import</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Import'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.import).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useCreatePortRange', () => {
+  test('should create a port range', async () => {
+    const gmp = createGmp();
+    const input = {
+      portListId: 'port-list-1',
+      portRangeStart: 1,
+      portRangeEnd: 1024,
+      portType: 'tcp',
+    };
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreatePortRange();
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.createPortRange).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useDeletePortRange', () => {
+  test('should delete a port range', async () => {
+    const gmp = createGmp();
+    const input = {id: 'port-range-1', portListId: 'port-list-1'};
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeletePortRange();
+      return <button onClick={() => mutation.mutate(input)}>Delete</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.portlist.deletePortRange).toHaveBeenCalledWith({
+        id: 'port-range-1',
+      });
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/PortLists.test.tsx b/src/web/hooks/use-query/__tests__/PortLists.test.tsx
new file mode 100644
index 0000000000..31607284f6
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/PortLists.test.tsx
@@ -0,0 +1,137 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import CollectionCounts from 'gmp/collection/collection-counts';
+import QueryFilter from 'gmp/models/filter/query-filter';
+import PortList from 'gmp/models/port-list';
+import {createSession} from 'gmp/testing';
+import {
+  useGetAllPortLists,
+  useGetPortLists,
+} from 'web/hooks/use-query/port-lists';
+
+const filter = QueryFilter.fromString('name~port-list');
+const portLists = [new PortList({id: 'port-list-1', name: 'Port List 1'})];
+
+const createGmp = () => {
+  const response = {
+    data: portLists,
+    meta: {
+      filter,
+      counts: new CollectionCounts({all: 1, filtered: 1, length: 1}),
+    },
+  };
+
+  return {
+    session: createSession({token: 'test-token'}),
+    settings: {},
+    portlists: {
+      get: testing.fn().mockResolvedValue(response),
+      getAll: testing.fn().mockResolvedValue(response),
+    },
+  };
+};
+
+describe('useGetPortLists', () => {
+  test('should fetch port lists with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetPortLists({filter});
+      return <div data-testid="port-list">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('port-list')).toHaveTextContent('Port List 1');
+    });
+
+    expect(gmp.portlists.get).toHaveBeenCalledWith({filter});
+    expect(gmp.portlists.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch port lists when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetPortLists({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.portlists.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch port lists without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetPortLists({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.portlists.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useGetAllPortLists', () => {
+  test('should fetch all port lists with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetAllPortLists({filter});
+      return <div data-testid="port-list">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('port-list')).toHaveTextContent('Port List 1');
+    });
+
+    expect(gmp.portlists.getAll).toHaveBeenCalledWith({filter});
+    expect(gmp.portlists.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch port lists when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllPortLists({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.portlists.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch port lists without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllPortLists({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.portlists.getAll).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/web/hooks/use-query/port-list.ts b/src/web/hooks/use-query/port-list.ts
new file mode 100644
index 0000000000..43ae48b116
--- /dev/null
+++ b/src/web/hooks/use-query/port-list.ts
@@ -0,0 +1,146 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionData} from 'gmp/commands/entity';
+import {
+  type PortListCommandImportParams,
+  type PortListCommandCreateParams,
+  type PortListCommandSaveParams,
+  type PortListCommandCreatePortRangeParams,
+  type PortListCommandDeletePortRangeParams,
+} from 'gmp/commands/port-list';
+import _ from 'gmp/locale';
+import useGmp from 'web/hooks/useGmp';
+import useGmpMutation from 'web/queries/useGmpMutation';
+
+interface UsePortListMutationCallbacks<TResponse> {
+  onSuccess?: (response: TResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseGetPortListParams {
+  id: string;
+}
+
+interface UseModifyPortListParams extends UseGetPortListParams {
+  name?: string;
+}
+
+export const useCreatePortList = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<PortListCommandCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.portlist.create(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_port_lists'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useSavePortList = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<PortListCommandSaveParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.portlist.save(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_port_lists', 'get_port_list'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useClonePortList = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UseModifyPortListParams, EntityActionData>({
+    gmpMethod: async ({id}: UseModifyPortListParams) => {
+      const response = await gmp.portlist.clone({id});
+      return response.data;
+    },
+    invalidateQueryIds: ['get_port_lists'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} cloned successfully.', {
+        name: entity.name as string,
+      }),
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDeletePortList = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<void> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<UseModifyPortListParams, void>({
+    gmpMethod: ({id}: UseModifyPortListParams) => gmp.portlist.delete({id}),
+    invalidateQueryIds: ['get_port_lists', 'get_port_list'],
+    successMessage: (_data, entity) =>
+      _('{{- name}} deleted successfully.', {
+        name: entity.name as string,
+      }),
+    onSuccess,
+    onError,
+  });
+};
+
+export const useImportPortList = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<PortListCommandImportParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.portlist.import(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_port_lists'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCreatePortRange = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<PortListCommandCreatePortRangeParams, EntityActionData>(
+    {
+      gmpMethod: async data => {
+        const response = await gmp.portlist.createPortRange(data);
+        return response.data;
+      },
+      invalidateQueryIds: ['get_port_lists', 'get_port_list'],
+      onSuccess,
+      onError,
+    },
+  );
+};
+
+export const useDeletePortRange = ({
+  onSuccess,
+  onError,
+}: UsePortListMutationCallbacks<void> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<PortListCommandDeletePortRangeParams, void>({
+    gmpMethod: async ({id}: PortListCommandDeletePortRangeParams) =>
+      gmp.portlist.deletePortRange({id}),
+    invalidateQueryIds: ['get_port_lists', 'get_port_list'],
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/port-lists.ts b/src/web/hooks/use-query/port-lists.ts
new file mode 100644
index 0000000000..e4178ca36f
--- /dev/null
+++ b/src/web/hooks/use-query/port-lists.ts
@@ -0,0 +1,45 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type FilterType} from 'gmp/models/filter';
+import type PortList from 'gmp/models/port-list';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntities from 'web/queries/useGetEntities';
+
+interface UseGetPortListsParams {
+  enabled?: boolean;
+  filter?: FilterType;
+  staleTime?: number;
+}
+
+export const useGetPortLists = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetPortListsParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<PortList>({
+    gmpMethod: gmp.portlists.get.bind(gmp.portlists),
+    queryId: 'get_port_lists',
+    enabled,
+    filter,
+    staleTime,
+  });
+};
+
+export const useGetAllPortLists = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetPortListsParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<PortList>({
+    gmpMethod: gmp.portlists.getAll.bind(gmp.portlists),
+    queryId: 'get_port_lists',
+    enabled,
+    filter,
+    staleTime,
+  });
+};

From dee5670ccf06291d688e4e7a61346dd18f8bfb9a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:15:21 +0200
Subject: [PATCH 11/36] Change: Adapt PortListComponent to use new port list
 query hooks

Use the new port list query hooks within the PortListComponent.
---
 src/web/pages/portlists/PortListComponent.tsx | 117 ++++++++++--------
 src/web/pages/portlists/PortListDialog.tsx    |   4 +-
 .../__tests__/PortListComponent.test.tsx      |  31 +++--
 3 files changed, 84 insertions(+), 68 deletions(-)

diff --git a/src/web/pages/portlists/PortListComponent.tsx b/src/web/pages/portlists/PortListComponent.tsx
index d6b32ec828..1c5a4a36eb 100644
--- a/src/web/pages/portlists/PortListComponent.tsx
+++ b/src/web/pages/portlists/PortListComponent.tsx
@@ -5,7 +5,7 @@
 
 import React, {useState} from 'react';
 import {
-  type EntityActionResponse,
+  type EntityActionData,
   type EntityCommandParams,
 } from 'gmp/commands/entity';
 import {
@@ -19,23 +19,22 @@ import {
 } from 'gmp/models/port-list';
 import {isDefined} from 'gmp/utils/identity';
 import {shorten} from 'gmp/utils/string';
-import useEntityClone, {
-  type EntityCloneResponse,
-} from 'web/entity/hooks/useEntityClone';
-import useEntityCreate, {
-  type EntityCreateResponse,
-} from 'web/entity/hooks/useEntityCreate';
-import useEntityDelete from 'web/entity/hooks/useEntityDelete';
 import useEntityDownload, {
   type OnDownloadedFunc,
 } from 'web/entity/hooks/useEntityDownload';
-import useEntitySave, {
-  type EntitySaveResponse,
-} from 'web/entity/hooks/useEntitySave';
+import {
+  useClonePortList,
+  useCreatePortList,
+  useCreatePortRange,
+  useDeletePortList,
+  useDeletePortRange,
+  useImportPortList,
+  useSavePortList,
+} from 'web/hooks/use-query/port-list';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
 import PortListsDialog, {
-  type SavePortListData,
+  type PortListDialogSaveData,
 } from 'web/pages/portlists/PortListDialog';
 import ImportPortListDialog, {
   type PortListImportDialogState,
@@ -65,17 +64,17 @@ interface PortListComponentRenderProps {
 interface PortListComponentProps {
   children: (props: PortListComponentRenderProps) => React.ReactNode;
   onCloneError?: (error: Error) => void;
-  onCloned?: (response: EntityCloneResponse) => void;
+  onCloned?: (response: EntityActionData) => void;
   onCreateError?: (error: Error) => void;
-  onCreated?: (response: EntityCreateResponse) => void;
+  onCreated?: (response: EntityActionData) => void;
   onDeleteError?: (error: Error) => void;
   onDeleted?: () => void;
   onDownloadError?: (error: Error) => void;
   onDownloaded?: OnDownloadedFunc;
   onImportError?: (error: Error) => void;
-  onImported?: (response: EntityActionResponse) => void;
+  onImported?: (response: EntityActionData) => void;
   onSaveError?: (error: Error) => void;
-  onSaved?: (response: EntitySaveResponse) => void;
+  onSaved?: (response: EntityActionData) => void;
 }
 
 const PortListComponent = ({
@@ -106,27 +105,43 @@ const PortListComponent = ({
   const [createdPortRanges, setCreatedPortRanges] = useState<PortRange[]>([]);
   const [deletedPortRanges, setDeletedPortRanges] = useState<PortRange[]>([]);
 
-  const handleSave = useEntitySave<PortListCommandSaveParams>(
-    data => gmp.portlist.save(data),
-    {
-      onSaveError,
-      onSaved,
-    },
-  );
-  const handleCreate = useEntityCreate<PortListCommandCreateParams>(
-    data => gmp.portlist.create(data),
-    {
-      onCreated,
-      onCreateError,
-    },
-  );
-  const handleClone = useEntityClone<PortList>(
-    entity => gmp.portlist.clone(entity),
-    {
-      onCloned,
-      onCloneError,
-    },
-  );
+  const savePortListMutation = useSavePortList({
+    onSuccess: onSaved,
+    onError: onSaveError,
+  });
+  const savePortList = async (data: PortListCommandSaveParams) =>
+    await savePortListMutation.mutateAsync(data);
+
+  const createPortListMutation = useCreatePortList({
+    onSuccess: onCreated,
+    onError: onCreateError,
+  });
+  const createPortList = async (data: PortListCommandCreateParams) =>
+    await createPortListMutation.mutateAsync(data);
+
+  const clonePortListMutation = useClonePortList({
+    onSuccess: onCloned,
+    onError: onCloneError,
+  });
+  const clonePortList = async (data: PortList) =>
+    await clonePortListMutation.mutateAsync(data);
+
+  const deletePortListMutation = useDeletePortList({
+    onSuccess: onDeleted,
+    onError: onDeleteError,
+  });
+  const deletePortList = async (data: PortList) =>
+    await deletePortListMutation.mutateAsync(data);
+
+  const importPortListMutation = useImportPortList({
+    onSuccess: onImported,
+    onError: onImportError,
+  });
+
+  const createPortRangeMutation = useCreatePortRange();
+
+  const deletePortRangeMutation = useDeletePortRange();
+
   const handleDownload = useEntityDownload<PortList>(
     entity => gmp.portlist.export(entity),
     {
@@ -134,13 +149,6 @@ const PortListComponent = ({
       onDownloaded,
     },
   );
-  const handleDelete = useEntityDelete<PortList>(
-    entity => gmp.portlist.delete(entity),
-    {
-      onDeleteError,
-      onDeleted,
-    },
-  );
 
   const openPortListDialog = async (entity?: PortList) => {
     if (entity) {
@@ -199,9 +207,8 @@ const PortListComponent = ({
   };
 
   const handleDeletePortRange = async (range: PortRange) => {
-    await gmp.portlist.deletePortRange({
+    await deletePortRangeMutation.mutateAsync({
       id: range.id as string,
-      portListId: range.portListId,
     });
   };
 
@@ -211,13 +218,13 @@ const PortListComponent = ({
     portRangeEnd: number;
     portType: ProtocolType;
   }) => {
-    const response = await gmp.portlist.createPortRange(data);
-    return response.data.id;
+    const response = await createPortRangeMutation.mutateAsync(data);
+    return response.id;
   };
 
   const handleImportPortList = async (data: PortListImportDialogState) => {
     try {
-      const response = await gmp.portlist.import(data);
+      const response = await importPortListMutation.mutateAsync(data);
       if (isDefined(onImported)) {
         onImported(response);
       }
@@ -229,7 +236,9 @@ const PortListComponent = ({
     }
   };
 
-  const handleSavePortList = async (data: SavePortListData<PortRange>) => {
+  const handleSavePortList = async (
+    data: PortListDialogSaveData<PortRange>,
+  ) => {
     if (isDefined(data.id)) {
       // save existing port list
       try {
@@ -270,13 +279,13 @@ const PortListComponent = ({
         }
         throw error;
       }
-      await handleSave({
+      await savePortList({
         id: data.id,
         name: data.name,
         comment: data.comment,
       });
     } else {
-      await handleCreate(data);
+      await createPortList(data);
     }
     closePortListDialog();
   };
@@ -360,9 +369,9 @@ const PortListComponent = ({
   return (
     <>
       {children({
-        clone: handleClone,
+        clone: clonePortList,
         download: handleDownload,
-        delete: handleDelete,
+        delete: deletePortList,
         create: openPortListDialog,
         edit: openPortListDialog,
         import: openImportDialog,
diff --git a/src/web/pages/portlists/PortListDialog.tsx b/src/web/pages/portlists/PortListDialog.tsx
index 24f74eec99..51de15e74b 100644
--- a/src/web/pages/portlists/PortListDialog.tsx
+++ b/src/web/pages/portlists/PortListDialog.tsx
@@ -20,7 +20,7 @@ import PortRangesTable, {
   type PortRange,
 } from 'web/pages/portlists/PortRangesTable';
 
-export interface SavePortListData<TPortRange extends PortRange> {
+export interface PortListDialogSaveData<TPortRange extends PortRange> {
   id?: string;
   comment: string;
   file?: File;
@@ -41,7 +41,7 @@ interface PortListsDialogProps<TPortRange extends PortRange> {
   title?: string;
   onClose?: () => void;
   onNewPortRangeClick?: () => void;
-  onSave?: (data: SavePortListData<TPortRange>) => void | Promise<void>;
+  onSave?: (data: PortListDialogSaveData<TPortRange>) => void | Promise<void>;
   onTmpDeletePortRange?: (portRange: TPortRange) => void;
 }
 
diff --git a/src/web/pages/portlists/__tests__/PortListComponent.test.tsx b/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
index 79cef1b04d..a3d8726070 100644
--- a/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
+++ b/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
@@ -26,11 +26,11 @@ const currentSettings = testing
   .mockResolvedValue(currentSettingsDefaultResponse);
 const createGmp = ({
   getPortListResponse = defaultGetPortListResponse,
-  createPortListResponse = {id: '123'},
+  createPortListResponse = {data: {id: '123'}},
   // oxlint-disable-next-line typescript/no-useless-default-assignment
   deletePortListResponse = undefined,
-  savePortListResponse = {id: '123'},
-  clonePortListResponse = {id: '123'},
+  savePortListResponse = {data: {id: '123'}},
+  clonePortListResponse = {data: {id: '123'}},
   createPortRangeResponse = {id: '1234'},
   getPortList = testing.fn().mockResolvedValue(getPortListResponse),
   createPortList = testing.fn().mockResolvedValue(createPortListResponse),
@@ -181,8 +181,8 @@ describe('PortListComponent tests', () => {
     const saveButton = screen.getDialogSaveButton();
     fireEvent.click(saveButton);
     await wait();
-    expect(screen.queryByText('New Port List')).not.toBeInTheDocument();
-    expect(onCreateError).toHaveBeenCalledWith(error);
+    expect(screen.getByText('New Port List')).toBeInTheDocument();
+    expect(onCreateError.mock.calls[0][0]).toBe(error);
     expect(onCreated).not.toHaveBeenCalled();
   });
 
@@ -345,7 +345,6 @@ describe('PortListComponent tests', () => {
 
     expect(deletePortRange).toHaveBeenCalledExactlyOnceWith({
       id: portList.portRanges[0].id,
-      portListId: portList.id,
     });
     expect(onSaveError).not.toHaveBeenCalled();
     expect(gmp.portlist.save).toHaveBeenCalledExactlyOnceWith({
@@ -390,9 +389,9 @@ describe('PortListComponent tests', () => {
     fireEvent.click(saveButton);
     await wait();
 
-    expect(screen.queryByText('Edit Port List foo')).not.toBeInTheDocument();
+    expect(screen.getByText('Edit Port List foo')).toBeInTheDocument();
     expect(onSaved).not.toHaveBeenCalled();
-    expect(onSaveError).toHaveBeenCalledExactlyOnceWith(error);
+    expect(onSaveError.mock.calls[0][0]).toBe(error);
   });
 
   test('should show error in dialog if saving a port list fails', async () => {
@@ -469,7 +468,11 @@ describe('PortListComponent tests', () => {
         {({clone}) => (
           <Button
             data-testid="button"
-            onClick={() => clone(new PortList({id: '123'}))}
+            onClick={() =>
+              void (
+                clone(new PortList({id: '123'})) as unknown as Promise<void>
+              ).catch(() => undefined)
+            }
           />
         )}
       </PortListComponent>,
@@ -478,7 +481,7 @@ describe('PortListComponent tests', () => {
     fireEvent.click(screen.getByTestId('button'));
     await wait();
     expect(onCloned).not.toHaveBeenCalled();
-    expect(onCloneError).toHaveBeenCalledExactlyOnceWith(error);
+    expect(onCloneError.mock.calls[0][0]).toBe(error);
   });
 
   test('should allow deleting a port list', async () => {
@@ -516,7 +519,11 @@ describe('PortListComponent tests', () => {
         {({delete: del}) => (
           <Button
             data-testid="button"
-            onClick={() => del(new PortList({id: '123'}))}
+            onClick={() =>
+              void (
+                del(new PortList({id: '123'})) as unknown as Promise<void>
+              ).catch(() => undefined)
+            }
           />
         )}
       </PortListComponent>,
@@ -525,6 +532,6 @@ describe('PortListComponent tests', () => {
     fireEvent.click(screen.getByTestId('button'));
     await wait();
     expect(onDeleted).not.toHaveBeenCalled();
-    expect(onDeleteError).toHaveBeenCalledExactlyOnceWith(error);
+    expect(onDeleteError.mock.calls[0][0]).toBe(error);
   });
 });

From e0e2d8badf3de030f6c7a906b850fccdf7b166d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:16:24 +0200
Subject: [PATCH 12/36] Add first query hooks for credentials

Implement the basic set of query hooks for credentials.
---
 src/gmp/commands/credential.ts                |   6 +-
 .../use-query/__tests__/Credential.test.tsx   |  94 +++++++++++
 .../use-query/__tests__/Credentials.test.tsx  | 149 ++++++++++++++++++
 src/web/hooks/use-query/credential.ts         |  30 ++++
 src/web/hooks/use-query/credentials.ts        |  45 ++++++
 5 files changed, 321 insertions(+), 3 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Credential.test.tsx
 create mode 100644 src/web/hooks/use-query/__tests__/Credentials.test.tsx
 create mode 100644 src/web/hooks/use-query/credential.ts
 create mode 100644 src/web/hooks/use-query/credentials.ts

diff --git a/src/gmp/commands/credential.ts b/src/gmp/commands/credential.ts
index c6aee885c9..3a89ff0f97 100644
--- a/src/gmp/commands/credential.ts
+++ b/src/gmp/commands/credential.ts
@@ -49,7 +49,7 @@ interface CredentialCommandSnmpFields {
 }
 
 // Create operation interfaces
-type CredentialCommandCreateArgs = CredentialCommandBaseArgs;
+export type CredentialCommandCreateParams = CredentialCommandBaseArgs;
 
 interface CredentialCommandKrb5Args
   extends CredentialCommandBaseArgs, CredentialCommandKrb5Fields {}
@@ -145,9 +145,9 @@ class CredentialCommand extends EntityCommand<
     };
   }
 
-  create(args: CredentialCommandCreateArgs) {
+  create(args: CredentialCommandCreateParams) {
     const baseData = this.createBase(args);
-    return this.action(baseData);
+    return this.entityAction(baseData);
   }
 
   createKrb5(args: CredentialCommandKrb5Args) {
diff --git a/src/web/hooks/use-query/__tests__/Credential.test.tsx b/src/web/hooks/use-query/__tests__/Credential.test.tsx
new file mode 100644
index 0000000000..0972df9c91
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Credential.test.tsx
@@ -0,0 +1,94 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {type CredentialCommandCreateParams} from 'gmp/commands/credential';
+import {USERNAME_PASSWORD_CREDENTIAL_TYPE} from 'gmp/models/credential';
+import {createSession} from 'gmp/testing';
+import {useCreateCredential} from 'web/hooks/use-query/credential';
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  credential: {
+    create: testing.fn().mockResolvedValue({data: {id: 'credential-1'}}),
+  },
+});
+
+describe('useCreateCredential', () => {
+  test('should create a credential', async () => {
+    const gmp = createGmp();
+    const input: CredentialCommandCreateParams = {
+      name: 'Credential 1',
+      credentialType: USERNAME_PASSWORD_CREDENTIAL_TYPE,
+      credentialLogin: 'admin',
+    };
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateCredential();
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.credential.create).toHaveBeenCalledWith(input);
+    });
+  });
+
+  test('should call onSuccess with the created credential data', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateCredential({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({
+              name: 'Credential 1',
+              credentialType: USERNAME_PASSWORD_CREDENTIAL_TYPE,
+            })
+          }
+        >
+          Create
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(onSuccess).toHaveBeenCalledWith({id: 'credential-1'});
+    });
+  });
+
+  test('should call onError when creating a credential fails', async () => {
+    const error = new Error('Create failed');
+    const gmp = createGmp();
+    gmp.credential.create.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCreateCredential({onError});
+      return (
+        <button onClick={() => mutation.mutate({name: 'Credential 1'})}>
+          Create
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Credentials.test.tsx b/src/web/hooks/use-query/__tests__/Credentials.test.tsx
new file mode 100644
index 0000000000..c4f43af5e6
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Credentials.test.tsx
@@ -0,0 +1,149 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import CollectionCounts from 'gmp/collection/collection-counts';
+import Credential, {
+  USERNAME_PASSWORD_CREDENTIAL_TYPE,
+} from 'gmp/models/credential';
+import QueryFilter from 'gmp/models/filter/query-filter';
+import {createSession} from 'gmp/testing';
+import {
+  useGetAllCredentials,
+  useGetCredentials,
+} from 'web/hooks/use-query/credentials';
+
+const filter = QueryFilter.fromString('name~credential');
+const credentials = [
+  new Credential({
+    id: 'credential-1',
+    name: 'Credential 1',
+    credentialType: USERNAME_PASSWORD_CREDENTIAL_TYPE,
+  }),
+];
+
+const createGmp = () => {
+  const response = {
+    data: credentials,
+    meta: {
+      filter,
+      counts: new CollectionCounts({all: 1, filtered: 1, length: 1}),
+    },
+  };
+
+  return {
+    session: createSession({token: 'test-token'}),
+    settings: {},
+    credentials: {
+      get: testing.fn().mockResolvedValue(response),
+      getAll: testing.fn().mockResolvedValue(response),
+    },
+  };
+};
+
+describe('useGetCredentials', () => {
+  test('should fetch credentials with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetCredentials({filter});
+      return <div data-testid="credential">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('credential')).toHaveTextContent(
+        'Credential 1',
+      );
+    });
+
+    expect(gmp.credentials.get).toHaveBeenCalledWith({filter});
+    expect(gmp.credentials.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch credentials when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetCredentials({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.credentials.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch credentials without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetCredentials({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.credentials.get).not.toHaveBeenCalled();
+  });
+});
+
+describe('useGetAllCredentials', () => {
+  test('should fetch all credentials with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const {data} = useGetAllCredentials({filter});
+      return <div data-testid="credential">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('credential')).toHaveTextContent(
+        'Credential 1',
+      );
+    });
+
+    expect(gmp.credentials.getAll).toHaveBeenCalledWith({filter});
+    expect(gmp.credentials.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch credentials when disabled', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllCredentials({enabled: false});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.credentials.getAll).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch credentials without a session token', () => {
+    const gmp = createGmp();
+    gmp.session.token = undefined;
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      useGetAllCredentials({filter});
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    expect(gmp.credentials.getAll).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/web/hooks/use-query/credential.ts b/src/web/hooks/use-query/credential.ts
new file mode 100644
index 0000000000..0324b551ae
--- /dev/null
+++ b/src/web/hooks/use-query/credential.ts
@@ -0,0 +1,30 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type CredentialCommandCreateParams} from 'gmp/commands/credential';
+import {type EntityActionData} from 'gmp/commands/entity';
+import useGmp from 'web/hooks/useGmp';
+import useGmpMutation from 'web/queries/useGmpMutation';
+
+interface UseCredentialMutationCallbacks<TResponse> {
+  onSuccess?: (response: TResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+export const useCreateCredential = ({
+  onSuccess,
+  onError,
+}: UseCredentialMutationCallbacks<EntityActionData> = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<CredentialCommandCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.credential.create(data);
+      return response.data;
+    },
+    invalidateQueryIds: ['get_credentials'],
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/credentials.ts b/src/web/hooks/use-query/credentials.ts
new file mode 100644
index 0000000000..18e722174e
--- /dev/null
+++ b/src/web/hooks/use-query/credentials.ts
@@ -0,0 +1,45 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type Credential from 'gmp/models/credential';
+import {type FilterType} from 'gmp/models/filter';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntities from 'web/queries/useGetEntities';
+
+interface UseGetCredentialsParams {
+  enabled?: boolean;
+  filter?: FilterType;
+  staleTime?: number;
+}
+
+export const useGetCredentials = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetCredentialsParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<Credential>({
+    gmpMethod: gmp.credentials.get.bind(gmp.credentials),
+    queryId: 'get_credentials',
+    enabled,
+    filter,
+    staleTime,
+  });
+};
+
+export const useGetAllCredentials = ({
+  enabled,
+  filter,
+  staleTime,
+}: UseGetCredentialsParams = {}) => {
+  const gmp = useGmp();
+  return useGetEntities<Credential>({
+    gmpMethod: gmp.credentials.getAll.bind(gmp.credentials),
+    queryId: 'get_credentials',
+    enabled,
+    filter,
+    staleTime,
+  });
+};

From 0383de3543a377bb7cabf4fd79f7082c4db21631 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:18:34 +0200
Subject: [PATCH 13/36] Change: Use new port list and credential query hooks

Update TargetComponent and TargetDialog to use the new port list and
credential query hooks internally instead of directly querying the gmp
API.
---
 src/web/pages/targets/TargetComponent.tsx     | 81 ++++++++-----------
 src/web/pages/targets/TargetDialog.tsx        | 12 ++-
 .../__tests__/TargetComponent.test.tsx        | 52 ++++++------
 .../targets/__tests__/TargetDialog.test.tsx   | 50 +++++++-----
 4 files changed, 98 insertions(+), 97 deletions(-)

diff --git a/src/web/pages/targets/TargetComponent.tsx b/src/web/pages/targets/TargetComponent.tsx
index 909636cb20..5002af6604 100644
--- a/src/web/pages/targets/TargetComponent.tsx
+++ b/src/web/pages/targets/TargetComponent.tsx
@@ -10,12 +10,9 @@ import {
   type TargetExcludeSource,
   type TargetSource,
 } from 'gmp/commands/target';
-import {
-  type default as Credential,
-  type CredentialType,
-} from 'gmp/models/credential';
+import {type CredentialType} from 'gmp/models/credential';
 import type Filter from 'gmp/models/filter';
-import type PortList from 'gmp/models/port-list';
+import {type PortRange} from 'gmp/models/port-list';
 import {
   type default as Target,
   type AliveTest,
@@ -26,6 +23,8 @@ import {isDefined} from 'gmp/utils/identity';
 import useEntityDownload, {
   type OnDownloadedFunc,
 } from 'web/entity/hooks/useEntityDownload';
+import {useCreateCredential} from 'web/hooks/use-query/credential';
+import {useCreatePortList} from 'web/hooks/use-query/port-list';
 import {
   useCloneTarget,
   useCreateTarget,
@@ -37,7 +36,9 @@ import useTranslation from 'web/hooks/useTranslation';
 import CredentialDialog, {
   type CredentialDialogState,
 } from 'web/pages/credentials/CredentialDialog';
-import PortListDialog from 'web/pages/portlists/PortListDialog';
+import PortListDialog, {
+  type PortListDialogSaveData,
+} from 'web/pages/portlists/PortListDialog';
 import TargetDialog, {
   DEFAULT_PORT_LIST_ID,
   type NewCredentialData,
@@ -104,14 +105,12 @@ const TargetComponent = ({
     useState(false);
   const [credentialsTitle, setCredentialsTitle] = useState('');
   const [credentialTypes, setCredentialTypes] = useState<CredentialType[]>([]);
-  const [credentials, setCredentials] = useState<Credential[]>([]);
   const [portListDialogVisible, setPortListDialogVisible] = useState(false);
   const [targetDialogVisible, setTargetDialogVisible] = useState(false);
   const [targetTitle, setTargetTitle] = useState('');
   const [portListId, setPortListId] = useState<string | undefined>(
     DEFAULT_PORT_LIST_ID,
   );
-  const [portLists, setPortLists] = useState<PortList[]>([]);
   const [portListsTitle, setPortListsTitle] = useState('');
   const [port, setPort] = useState<number | undefined>(undefined);
   const [aliveTests, setAliveTests] = useState<AliveTest[]>([
@@ -158,19 +157,8 @@ const TargetComponent = ({
   const [hostsCount, setHostsCount] = useState<number | undefined>(undefined);
   const [hostsFilter, setHostsFilter] = useState<Filter | undefined>(undefined);
 
-  const loadCredentials = async () => {
-    const response = await gmp.credentials.getAll();
-    setCredentials(response.data);
-  };
-
-  const loadPortLists = async () => {
-    const response = await gmp.portlists.getAll();
-    setPortLists(response.data);
-  };
-
-  const loadAll = async () => {
-    await Promise.all([loadCredentials(), loadPortLists()]);
-  };
+  const createPortListMutation = useCreatePortList();
+  const createCredentialMutation = useCreateCredential();
 
   const openCredentialsDialog = ({
     idField,
@@ -257,7 +245,6 @@ const TargetComponent = ({
     }
     setHostsCount(hostsCount);
     setHostsFilter(hostsFilter);
-    await loadAll();
     setTargetDialogVisible(true);
   };
 
@@ -274,10 +261,9 @@ const TargetComponent = ({
   };
 
   const handleCreateCredential = async (data: CredentialDialogState) => {
-    const response = await gmp.credential.create(data);
-    const credentialId = response.data.id;
+    const response = await createCredentialMutation.mutateAsync(data);
+    const credentialId = response.id;
     closeCredentialsDialog();
-    await loadCredentials();
     if (idFieldRef.current === 'sshElevateCredentialId') {
       setSshElevateCredentialId(credentialId);
     } else if (idFieldRef.current === 'sshCredentialId') {
@@ -293,11 +279,12 @@ const TargetComponent = ({
     }
   };
 
-  const handleCreatePortList = async data => {
-    const response = await gmp.portlist.create(data);
-    setPortListId(response.data.id);
+  const handleCreatePortList = async (
+    data: PortListDialogSaveData<PortRange>,
+  ) => {
+    const response = await createPortListMutation.mutateAsync(data);
+    setPortListId(response.id);
     closePortListDialog();
-    await loadPortLists();
   };
 
   const handlePortListChange = (portListId: string | undefined) => {
@@ -336,45 +323,43 @@ const TargetComponent = ({
     setKrb5CredentialId(krb5CredentialId ?? UNSET_VALUE);
   };
 
-  const cloneTarget = useCloneTarget({
+  const cloneTargetMutation = useCloneTarget({
     onSuccess: onCloned,
     onError: onCloneError,
   });
 
-  const handleTargetClone = async (entity: Target) => {
-    await cloneTarget.mutateAsync(entity);
+  const cloneTarget = async (entity: Target) => {
+    await cloneTargetMutation.mutateAsync(entity);
   };
 
-  const saveTarget = useSaveTarget({
+  const saveTargetMutation = useSaveTarget({
     onSuccess: onSaved,
     onError: onSaveError,
   });
-
-  const handleTargetSave = async (data: TargetCommandSaveParams) => {
-    await saveTarget.mutateAsync(data);
+  const saveTarget = async (data: TargetCommandSaveParams) => {
+    await saveTargetMutation.mutateAsync(data);
   };
 
-  const createTarget = useCreateTarget({
+  const createTargetMutation = useCreateTarget({
     onSuccess: onCreated,
     onError: onCreateError,
   });
-
-  const handleTargetCreate = async (data: TargetDialogData) => {
-    await createTarget.mutateAsync(data);
+  const createTarget = async (data: TargetDialogData) => {
+    await createTargetMutation.mutateAsync(data);
   };
 
-  const deleteTarget = useDeleteTarget({
+  const deleteTargetMutation = useDeleteTarget({
     onSuccess: onDeleted,
     onError: onDeleteError,
   });
 
-  const handleTargetDelete = async (entity: Target) => {
-    await deleteTarget.mutateAsync(entity);
+  const deleteTarget = async (entity: Target) => {
+    await deleteTargetMutation.mutateAsync(entity);
   };
 
   const handleSaveClick = async (data: TargetDialogData) => {
     const promise = isDefined(data.id)
-      ? handleTargetSave(
+      ? saveTarget(
           data.inUse
             ? {
                 id: data.id as string,
@@ -387,7 +372,7 @@ const TargetComponent = ({
                 id: data.id as string,
               },
         )
-      : handleTargetCreate(data);
+      : createTarget(data);
     await promise;
     closeTargetDialog();
   };
@@ -403,9 +388,9 @@ const TargetComponent = ({
   return (
     <>
       {children({
-        clone: handleTargetClone,
+        clone: cloneTarget,
         create: openCreateTargetDialog,
-        delete: handleTargetDelete,
+        delete: deleteTarget,
         download: handleEntityDownload,
         edit: openTargetDialog,
       })}
@@ -414,7 +399,6 @@ const TargetComponent = ({
           aliveTests={aliveTests}
           allowSimultaneousIPs={allowSimultaneousIPs}
           comment={comment}
-          credentials={credentials}
           esxiCredentialId={esxiCredentialId}
           excludeHosts={excludeHosts}
           hosts={hosts}
@@ -426,7 +410,6 @@ const TargetComponent = ({
           name={name}
           port={port}
           portListId={portListId}
-          portLists={portLists}
           reverseLookupOnly={reverseLookupOnly}
           reverseLookupUnify={reverseLookupUnify}
           smbCredentialId={smbCredentialId}
diff --git a/src/web/pages/targets/TargetDialog.tsx b/src/web/pages/targets/TargetDialog.tsx
index 75faa8cb87..1ee94646ae 100644
--- a/src/web/pages/targets/TargetDialog.tsx
+++ b/src/web/pages/targets/TargetDialog.tsx
@@ -49,6 +49,8 @@ import TextField from 'web/components/form/TextField';
 import YesNoRadio from 'web/components/form/YesNoRadio';
 import {InfoIcon, NewIcon} from 'web/components/icon';
 import Row from 'web/components/layout/Row';
+import {useGetAllCredentials} from 'web/hooks/use-query/credentials';
+import {useGetAllPortLists} from 'web/hooks/use-query/port-lists';
 import useCapabilities from 'web/hooks/useCapabilities';
 import useFeatures from 'web/hooks/useFeatures';
 import useGmp from 'web/hooks/useGmp';
@@ -111,7 +113,6 @@ interface TargetDialogProps {
   aliveTests?: AliveTest[];
   allowSimultaneousIPs?: boolean;
   comment?: string;
-  credentials?: Credential[];
   esxiCredentialId?: string;
   excludeHosts?: string[];
   hosts?: string[];
@@ -122,7 +123,6 @@ interface TargetDialogProps {
   name?: string;
   port?: number;
   portListId?: string;
-  portLists?: PortList[];
   reverseLookupOnly?: boolean;
   reverseLookupUnify?: boolean;
   smbCredentialId?: string;
@@ -165,7 +165,6 @@ const TargetDialog = ({
   aliveTests: initialAliveTests = [SCAN_CONFIG_DEFAULT],
   allowSimultaneousIPs = true,
   comment = '',
-  credentials = [],
   esxiCredentialId,
   excludeHosts = [],
   hosts = [],
@@ -176,7 +175,6 @@ const TargetDialog = ({
   name,
   port = DEFAULT_PORT,
   portListId = DEFAULT_PORT_LIST_ID,
-  portLists = DEFAULT_PORT_LISTS,
   reverseLookupOnly = false,
   reverseLookupUnify = false,
   smbCredentialId,
@@ -206,6 +204,11 @@ const TargetDialog = ({
   const enableKrb5 = gmp.settings.enableKrb5;
   const hasPermissionToCreateCredential = capabilities.mayCreate('credential');
   const [aliveTests, setAliveTests] = useState<AliveTest[]>(initialAliveTests);
+  const portListQuery = useGetAllPortLists();
+  const credentialsQuery = useGetAllCredentials();
+
+  const portLists = portListQuery.data?.entities ?? DEFAULT_PORT_LISTS;
+  const credentials = credentialsQuery.data?.entities ?? [];
 
   // Feature flag configuration
   const isCredentialStoresEnabled = features.featureEnabled(
@@ -544,6 +547,7 @@ const TargetDialog = ({
                 <Select
                   disabled={inUse}
                   grow="1"
+                  isLoading={portListQuery.isLoading}
                   items={renderSelectItems(
                     portLists as RenderSelectItemProps[],
                   )}
diff --git a/src/web/pages/targets/__tests__/TargetComponent.test.tsx b/src/web/pages/targets/__tests__/TargetComponent.test.tsx
index 5440412798..964016977e 100644
--- a/src/web/pages/targets/__tests__/TargetComponent.test.tsx
+++ b/src/web/pages/targets/__tests__/TargetComponent.test.tsx
@@ -47,7 +47,7 @@ const createGmp = ({
       enableGreenboneSensor: true,
       enableKrb5: false,
     },
-    session: createSession(),
+    session: createSession({token: 'test-token'}),
     user: {
       currentSettings: testing.fn().mockResolvedValue(
         new Response({
@@ -112,7 +112,9 @@ describe('TargetComponent tests', () => {
     await wait();
 
     expect(screen.getDialog()).toBeInTheDocument();
+    await wait();
     fireEvent.click(screen.getDialogSaveButton());
+    await wait();
 
     expect(gmp.target.create).toHaveBeenCalledWith({
       aliveTests: [SCAN_CONFIG_DEFAULT],
@@ -143,12 +145,10 @@ describe('TargetComponent tests', () => {
 
     expect(onCreated).toHaveBeenCalledWith(
       expect.objectContaining({
-        _data: {
-          envelope: {
-            action_result: expect.objectContaining({
-              id: 'new-id',
-            }),
-          },
+        envelope: {
+          action_result: expect.objectContaining({
+            id: 'new-id',
+          }),
         },
       }),
     );
@@ -171,10 +171,11 @@ describe('TargetComponent tests', () => {
 
     fireEvent.click(screen.getByTestId('open'));
     await wait();
+    await wait();
     fireEvent.click(screen.getDialogSaveButton());
     await wait();
 
-    expect(onCreateError).toHaveBeenCalledWith(error);
+    expect(onCreateError.mock.calls[0][0]).toBe(error);
   });
 
   test('should allow to edit an existing target', async () => {
@@ -203,7 +204,9 @@ describe('TargetComponent tests', () => {
     await wait();
 
     expect(screen.getDialog()).toBeInTheDocument();
+    await wait();
     fireEvent.click(screen.getDialogSaveButton());
+    await wait();
 
     expect(gmp.target.save).toHaveBeenCalledWith({
       aliveTests: [],
@@ -234,12 +237,10 @@ describe('TargetComponent tests', () => {
 
     expect(onSaved).toHaveBeenCalledWith(
       expect.objectContaining({
-        _data: {
-          envelope: {
-            action_result: expect.objectContaining({
-              id: 'saved-id',
-            }),
-          },
+        envelope: {
+          action_result: expect.objectContaining({
+            id: 'saved-id',
+          }),
         },
       }),
     );
@@ -261,10 +262,11 @@ describe('TargetComponent tests', () => {
 
     fireEvent.click(screen.getByTestId('open'));
     await wait();
+    await wait();
     fireEvent.click(screen.getDialogSaveButton());
     await wait();
 
-    expect(onSaveError).toHaveBeenCalledWith(error);
+    expect(onSaveError.mock.calls[0][0]).toBe(error);
   });
 
   test('only saves editable fields for a target in use', async () => {
@@ -290,6 +292,7 @@ describe('TargetComponent tests', () => {
     fireEvent.click(screen.getByTestId('button'));
     await wait();
     fireEvent.click(screen.getDialogSaveButton());
+    await wait();
 
     expect(gmp.target.save).toHaveBeenCalledWith({
       id: '1234',
@@ -316,18 +319,17 @@ describe('TargetComponent tests', () => {
 
     const button = screen.getByTestId('button');
     fireEvent.click(button);
-    expect(gmp.target.clone).toHaveBeenCalledWith(target);
+    await wait();
+    expect(gmp.target.clone).toHaveBeenCalledWith({id: target.id});
 
     await wait();
 
     expect(onCloned).toHaveBeenCalledWith(
       expect.objectContaining({
-        _data: {
-          envelope: {
-            action_result: expect.objectContaining({
-              id: 'cloned-id',
-            }),
-          },
+        envelope: {
+          action_result: expect.objectContaining({
+            id: 'cloned-id',
+          }),
         },
       }),
     );
@@ -404,8 +406,10 @@ describe('TargetComponent tests', () => {
       </TargetComponent>,
     );
 
-    await actions?.delete(new Target({id: 'target-id', name: 'Target'}));
-    expect(onDeleteError).toHaveBeenCalledWith(error);
+    await expect(
+      actions?.delete(new Target({id: 'target-id', name: 'Target'})),
+    ).rejects.toThrow(error);
+    expect(onDeleteError.mock.calls[0][0]).toBe(error);
   });
 
   test('should create a credential from the target dialog', async () => {
diff --git a/src/web/pages/targets/__tests__/TargetDialog.test.tsx b/src/web/pages/targets/__tests__/TargetDialog.test.tsx
index 1f19b9d92c..59f400fe66 100644
--- a/src/web/pages/targets/__tests__/TargetDialog.test.tsx
+++ b/src/web/pages/targets/__tests__/TargetDialog.test.tsx
@@ -13,6 +13,7 @@ import {
   rendererWith,
   changeSelectInput,
 } from 'web/testing';
+import Response from 'gmp/http/response';
 import Credential, {
   USERNAME_PASSWORD_CREDENTIAL_TYPE,
   CERTIFICATE_CREDENTIAL_TYPE,
@@ -24,12 +25,14 @@ import Credential, {
   SNMP_CREDENTIAL_TYPES,
 } from 'gmp/models/credential';
 import Filter from 'gmp/models/filter';
+import PortList from 'gmp/models/port-list';
 import {
   ARP_PING,
   CONSIDER_ALIVE,
   ICMP_PING,
   SCAN_CONFIG_DEFAULT,
 } from 'gmp/models/target';
+import {createSession} from 'gmp/testing';
 import TargetDialog, {
   DEFAULT_PORT_LIST_ID,
   DEFAULT_PORT_LIST_NAME,
@@ -67,16 +70,29 @@ const cred5 = new Credential({
 });
 
 const credentials = [cred1, cred2, cred3, cred4, cred5];
+const portLists = [
+  new PortList({
+    id: DEFAULT_PORT_LIST_ID,
+    name: DEFAULT_PORT_LIST_NAME,
+  }),
+];
 
 const gmp = {
+  session: createSession({token: 'test-token'}),
   settings: {
     enableGreenboneSensor: true,
     enableKrb5: false,
   },
+  credentials: {
+    getAll: testing.fn().mockResolvedValue(new Response(credentials)),
+  },
+  portlists: {
+    getAll: testing.fn().mockResolvedValue(new Response(portLists)),
+  },
 };
 
 describe('TargetDialog tests', () => {
-  test('should render with default values', () => {
+  test('should render with default values', async () => {
     const handleClose = testing.fn();
     const handleChange = testing.fn();
     const handleSave = testing.fn();
@@ -86,7 +102,6 @@ describe('TargetDialog tests', () => {
 
     render(
       <TargetDialog
-        credentials={credentials}
         onClose={handleClose}
         onNewCredentialsClick={handleCreate}
         onNewPortListClick={handleCreate}
@@ -95,6 +110,8 @@ describe('TargetDialog tests', () => {
       />,
     );
 
+    await wait();
+
     const fileInputs = screen.queryFileInputs();
 
     const nameField = screen.getByName('name');
@@ -172,7 +189,7 @@ describe('TargetDialog tests', () => {
     expect(reverseLookupUnifyInputs[1]).toBeChecked();
   });
 
-  test('should display value from props', () => {
+  test('should display value from props', async () => {
     const handleClose = testing.fn();
     const handleChange = testing.fn();
     const handleSave = testing.fn();
@@ -185,7 +202,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={false}
@@ -201,6 +217,8 @@ describe('TargetDialog tests', () => {
       />,
     );
 
+    await wait();
+
     const fileInputs = screen.queryFileInputs();
 
     const nameField = screen.getByName('name');
@@ -291,7 +309,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={false}
@@ -359,7 +376,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={false}
@@ -399,7 +415,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={false}
@@ -459,20 +474,20 @@ describe('TargetDialog tests', () => {
       const handleSave = testing.fn();
       const handleCreate = testing.fn();
 
-      const gmp = {
+      const krb5Gmp = {
+        ...gmp,
         settings: {
-          enableGreenboneSensor: true,
+          ...gmp.settings,
           enableKrb5: true,
         },
       };
-      const {render} = rendererWith({gmp, capabilities: true});
+      const {render} = rendererWith({gmp: krb5Gmp, capabilities: true});
 
       render(
         <TargetDialog
           aliveTests={[SCAN_CONFIG_DEFAULT]}
           allowSimultaneousIPs={false}
           comment="hello world"
-          credentials={credentials}
           excludeHosts={[]}
           hosts={['123.455.67.434']}
           inUse={false}
@@ -517,7 +532,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={false}
@@ -546,7 +560,7 @@ describe('TargetDialog tests', () => {
     expect(selectItems[1]).toHaveTextContent('ssh_key');
   });
 
-  test('should disable editing certain fields if target is in use', () => {
+  test('should disable editing certain fields if target is in use', async () => {
     const handleClose = testing.fn();
     const handleChange = testing.fn();
     const handleSave = testing.fn();
@@ -559,7 +573,6 @@ describe('TargetDialog tests', () => {
         aliveTests={[SCAN_CONFIG_DEFAULT]}
         allowSimultaneousIPs={false}
         comment="hello world"
-        credentials={credentials}
         excludeHosts={[]}
         hosts={['123.455.67.434']}
         inUse={true}
@@ -576,6 +589,8 @@ describe('TargetDialog tests', () => {
       />,
     );
 
+    await wait();
+
     expect(screen.getDialogContent()).toHaveTextContent('Elevate privileges');
 
     const newIcons = screen.queryAllByTitle('Create a new credential');
@@ -613,7 +628,6 @@ describe('TargetDialog tests', () => {
 
     render(
       <TargetDialog
-        credentials={credentials}
         onClose={handleClose}
         onNewCredentialsClick={handleCreate}
         onNewPortListClick={handleCreate}
@@ -715,11 +729,7 @@ describe('TargetDialog tests', () => {
         const {render} = rendererWith({gmp, capabilities: true});
 
         render(
-          <TargetDialog
-            credentials={credentials}
-            inUse={false}
-            onNewCredentialsClick={handleCreate}
-          />,
+          <TargetDialog inUse={false} onNewCredentialsClick={handleCreate} />,
         );
 
         const newIcon = screen.getByTestId(testId);

From 211cdfb173d406706f29ac63ea8b2f093adbb164 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:23:43 +0200
Subject: [PATCH 14/36] test: Improve organization of query hook tests for
 users

---
 .../hooks/use-query/__tests__/Users.test.tsx    | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/Users.test.tsx b/src/web/hooks/use-query/__tests__/Users.test.tsx
index 912881bf6e..fcf9e31396 100644
--- a/src/web/hooks/use-query/__tests__/Users.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Users.test.tsx
@@ -15,18 +15,7 @@ import {
   useGetUsers,
 } from 'web/hooks/use-query/users';
 
-const userData = {
-  accessHosts: ['localhost', '127.0.0.1'],
-  authMethod: 'password',
-  comment: 'comment',
-  groupIds: ['group-id'],
-  hostsAllow: '0',
-  name: 'user',
-  password: 'password',
-  roleIds: ['role-id'],
-};
-
-const user = User.fromElement({_id: 'user-id', name: 'user'});
+const user = new User({id: 'user-id', name: 'user'});
 const userFilter = QueryFilter.fromString('name~user');
 
 const createGmp = (
@@ -82,7 +71,9 @@ describe('useGetUsers', () => {
 
     expect(gmp.users.get).not.toHaveBeenCalled();
   });
+});
 
+describe('useBulkDeleteUsers', () => {
   test('should bulk delete users with options', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -103,7 +94,9 @@ describe('useGetUsers', () => {
       expect(gmp.users.delete).toHaveBeenCalledWith(input.users, input.options);
     });
   });
+});
 
+describe('useBulkExportUsers', () => {
   test('should bulk export users by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});

From 1b41955b84d1a9be11afb0633ad04575521fddc5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:58:43 +0200
Subject: [PATCH 15/36] Update and fix TargetDetailsPage test

---
 src/web/pages/targets/__tests__/TargetDetailsPage.test.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/web/pages/targets/__tests__/TargetDetailsPage.test.tsx b/src/web/pages/targets/__tests__/TargetDetailsPage.test.tsx
index ac4be36b7d..ca8cbcd8ee 100644
--- a/src/web/pages/targets/__tests__/TargetDetailsPage.test.tsx
+++ b/src/web/pages/targets/__tests__/TargetDetailsPage.test.tsx
@@ -311,7 +311,8 @@ describe('TargetDetailsPage tests', () => {
 
     const cloneIcon = screen.getByTitle('Clone Target');
     fireEvent.click(cloneIcon);
-    expect(gmp.target.clone).toHaveBeenCalledWith(target);
+    await wait();
+    expect(gmp.target.clone).toHaveBeenCalledWith({id: target.id});
 
     const exportIcon = screen.getByTitle('Export Target as XML');
     fireEvent.click(exportIcon);
@@ -319,6 +320,7 @@ describe('TargetDetailsPage tests', () => {
 
     const deleteIcon = screen.getByTitle('Move Target to trashcan');
     fireEvent.click(deleteIcon);
+    await wait();
     expect(gmp.target.delete).toHaveBeenCalledWith({id: target.id});
   });
 });

From 76e40854472fa8e717e5a1134f2686890170ad6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 11:59:16 +0200
Subject: [PATCH 16/36] Change: Split query hooks for agent groups into two
 modules

Entity and entities queries are separated everywhere else already.
---
 .../use-query/__tests__/AgentGroup.test.tsx   | 105 ++++++++++++++++++
 .../use-query/__tests__/AgentGroups.test.tsx  |  42 +------
 src/web/hooks/use-query/agent-group.ts        |  87 +++++++++++++++
 src/web/hooks/use-query/agent-groups.ts       |  82 +-------------
 .../agent-groups/AgentGroupsComponent.tsx     |   2 +-
 5 files changed, 197 insertions(+), 121 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
 create mode 100644 src/web/hooks/use-query/agent-group.ts

diff --git a/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx b/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
new file mode 100644
index 0000000000..54e2785ec3
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
@@ -0,0 +1,105 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneAgentGroup,
+  useCreateAgentGroup,
+  useDeleteAgentGroup,
+  useSaveAgentGroup,
+} from 'web/hooks/use-query/agent-group';
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  agentgroup: {
+    create: testing.fn().mockResolvedValue({data: {id: 'group-2'}}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'group-2'}}),
+    save: testing.fn().mockResolvedValue(undefined),
+    delete: testing.fn().mockResolvedValue(undefined),
+  },
+});
+
+describe('useCreateAgentGroup', () => {
+  test('should create an agent group', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {name: 'New Group'};
+
+    const TestComponent = () => {
+      const mutation = useCreateAgentGroup({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+
+    await waitFor(() => {
+      expect(gmp.agentgroup.create.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useCloneAgentGroup', () => {
+  test('should clone an agent group', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: 'group-1'};
+
+    const TestComponent = () => {
+      const mutation = useCloneAgentGroup({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+
+    await waitFor(() => {
+      expect(gmp.agentgroup.clone).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useSaveAgentGroup', () => {
+  test('should save an agent group', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: 'group-1', name: 'Saved Group'};
+
+    const TestComponent = () => {
+      const mutation = useSaveAgentGroup({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+
+    await waitFor(() => {
+      expect(gmp.agentgroup.save.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useDeleteAgentGroup', () => {
+  test('should delete an agent group', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: 'group-1'};
+
+    const TestComponent = () => {
+      const mutation = useDeleteAgentGroup({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+
+    await waitFor(() => {
+      expect(gmp.agentgroup.delete).toHaveBeenCalledWith(input);
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/AgentGroups.test.tsx b/src/web/hooks/use-query/__tests__/AgentGroups.test.tsx
index 678f86c716..4e39b13d4d 100644
--- a/src/web/hooks/use-query/__tests__/AgentGroups.test.tsx
+++ b/src/web/hooks/use-query/__tests__/AgentGroups.test.tsx
@@ -4,17 +4,11 @@
  */
 
 import {describe, expect, test, testing} from '@gsa/testing';
-import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
 import CollectionCounts from 'gmp/collection/collection-counts';
 import QueryFilter from 'gmp/models/filter/query-filter';
 import {createSession} from 'gmp/testing';
-import {
-  useCloneAgentGroup,
-  useCreateAgentGroup,
-  useDeleteAgentGroup,
-  useGetAgentGroups,
-  useSaveAgentGroup,
-} from 'web/hooks/use-query/agent-groups';
+import {useGetAgentGroups} from 'web/hooks/use-query/agent-groups';
 
 const filter = QueryFilter.fromString('name~group');
 const group = {id: 'group-1', name: 'Agent Group 1'};
@@ -31,15 +25,9 @@ const createGmp = () => ({
       },
     }),
   },
-  agentgroup: {
-    create: testing.fn().mockResolvedValue({data: {id: 'group-2'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'group-2'}}),
-    save: testing.fn().mockResolvedValue(undefined),
-    delete: testing.fn().mockResolvedValue(undefined),
-  },
 });
 
-describe('agent group query hooks', () => {
+describe('useGetAgentGroups', () => {
   test('should fetch agent groups with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -57,28 +45,4 @@ describe('agent group query hooks', () => {
 
     expect(gmp.agentgroups.get).toHaveBeenCalledWith({filter});
   });
-
-  test.each([
-    ['create', useCreateAgentGroup, 'create', {name: 'New Group'}],
-    ['clone', useCloneAgentGroup, 'clone', {id: 'group-1'}],
-    ['save', useSaveAgentGroup, 'save', {id: 'group-1', name: 'Saved Group'}],
-    ['delete', useDeleteAgentGroup, 'delete', {id: 'group-1'}],
-  ])('should %s an agent group', async (_name, useMutation, method, input) => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    const TestComponent = () => {
-      const mutation = useMutation({});
-      return (
-        <button onClick={() => mutation.mutate(input as never)}>Run</button>
-      );
-    };
-
-    render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
-
-    await waitFor(() => {
-      expect(gmp.agentgroup[method].mock.calls[0][0]).toEqual(input);
-    });
-  });
 });
diff --git a/src/web/hooks/use-query/agent-group.ts b/src/web/hooks/use-query/agent-group.ts
new file mode 100644
index 0000000000..b36593d511
--- /dev/null
+++ b/src/web/hooks/use-query/agent-group.ts
@@ -0,0 +1,87 @@
+/* SPDX-FileCopyrightText: 2025 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {
+  type AgentGroupCreateParams,
+  type AgentGroupSaveParams,
+} from 'gmp/commands/agent-group';
+import {type EntityActionResponse} from 'gmp/commands/entity';
+import type Rejection from 'gmp/http/rejection';
+import AgentGroup from 'gmp/models/agent-group';
+import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
+import useSaveMutation from 'web/queries/useSaveMutation';
+
+interface UseCreateAgentGroupParams {
+  onSuccess?: (data: EntityActionResponse) => void;
+  onError?: (error: Rejection) => void;
+}
+
+interface UseModifyAgentGroupParams {
+  onSuccess?: () => void;
+  onError?: (error: Rejection) => void;
+}
+
+export const useCreateAgentGroup = ({
+  onSuccess,
+  onError,
+}: UseCreateAgentGroupParams) => {
+  const gmp = useGmp();
+  return useCreateMutation<
+    AgentGroupCreateParams,
+    EntityActionResponse,
+    Rejection
+  >({
+    gmpMethod: gmp.agentgroup.create.bind(gmp.agentgroup),
+    entityType: AgentGroup.entityType,
+    invalidateQueryIds: ['get_agent_groups'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useCloneAgentGroup = ({
+  onError,
+  onSuccess,
+}: UseCreateAgentGroupParams) => {
+  const gmp = useGmp();
+  return useCloneMutation<EntityActionResponse, Rejection>({
+    gmpMethod: gmp.agentgroup.clone.bind(gmp.agentgroup),
+    entityType: AgentGroup.entityType,
+    invalidateQueryIds: ['get_agent_groups'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useSaveAgentGroup = ({
+  onError,
+  onSuccess,
+}: UseModifyAgentGroupParams) => {
+  const gmp = useGmp();
+  return useSaveMutation<AgentGroupSaveParams, void, Rejection>({
+    gmpMethod: gmp.agentgroup.save.bind(gmp.agentgroup),
+    entityType: AgentGroup.entityType,
+    invalidateQueryIds: ['get_agent_groups'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useDeleteAgentGroup = ({
+  onError,
+  onSuccess,
+}: UseModifyAgentGroupParams) => {
+  const gmp = useGmp();
+  return useDeleteMutation({
+    gmpMethod: gmp.agentgroup.delete.bind(gmp.agentgroup),
+    entityType: AgentGroup.entityType,
+    invalidateQueryIds: ['get_agent_groups'],
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/agent-groups.ts b/src/web/hooks/use-query/agent-groups.ts
index 369c82f6b8..4bf31f5c89 100644
--- a/src/web/hooks/use-query/agent-groups.ts
+++ b/src/web/hooks/use-query/agent-groups.ts
@@ -3,30 +3,10 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {
-  type AgentGroupCreateParams,
-  type AgentGroupSaveParams,
-} from 'gmp/commands/agent-group';
-import {type EntityActionResponse} from 'gmp/commands/entity';
-import type Rejection from 'gmp/http/rejection';
-import AgentGroup from 'gmp/models/agent-group';
+import type AgentGroup from 'gmp/models/agent-group';
 import {type FilterType} from 'gmp/models/filter';
 import useGmp from 'web/hooks/useGmp';
-import useCloneMutation from 'web/queries/useCloneMutation';
-import useCreateMutation from 'web/queries/useCreateMutation';
-import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntities from 'web/queries/useGetEntities';
-import useSaveMutation from 'web/queries/useSaveMutation';
-
-interface UseCreateAgentGroupParams {
-  onSuccess?: (data: EntityActionResponse) => void;
-  onError?: (error: Rejection) => void;
-}
-
-interface UseModifyAgentGroupParams {
-  onSuccess?: () => void;
-  onError?: (error: Rejection) => void;
-}
 
 export const useGetAgentGroups = ({filter}: {filter?: FilterType}) => {
   const gmp = useGmp();
@@ -36,63 +16,3 @@ export const useGetAgentGroups = ({filter}: {filter?: FilterType}) => {
     gmpMethod: gmp.agentgroups.get.bind(gmp.agentgroups),
   });
 };
-
-export const useCreateAgentGroup = ({
-  onSuccess,
-  onError,
-}: UseCreateAgentGroupParams) => {
-  const gmp = useGmp();
-  return useCreateMutation<
-    AgentGroupCreateParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.agentgroup.create.bind(gmp.agentgroup),
-    entityType: AgentGroup.entityType,
-    invalidateQueryIds: ['get_agent_groups'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useCloneAgentGroup = ({
-  onError,
-  onSuccess,
-}: UseCreateAgentGroupParams) => {
-  const gmp = useGmp();
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    gmpMethod: gmp.agentgroup.clone.bind(gmp.agentgroup),
-    entityType: AgentGroup.entityType,
-    invalidateQueryIds: ['get_agent_groups'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useSaveAgentGroup = ({
-  onError,
-  onSuccess,
-}: UseModifyAgentGroupParams) => {
-  const gmp = useGmp();
-  return useSaveMutation<AgentGroupSaveParams, void, Rejection>({
-    gmpMethod: gmp.agentgroup.save.bind(gmp.agentgroup),
-    entityType: AgentGroup.entityType,
-    invalidateQueryIds: ['get_agent_groups'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useDeleteAgentGroup = ({
-  onError,
-  onSuccess,
-}: UseModifyAgentGroupParams) => {
-  const gmp = useGmp();
-  return useDeleteMutation({
-    gmpMethod: gmp.agentgroup.delete.bind(gmp.agentgroup),
-    entityType: AgentGroup.entityType,
-    invalidateQueryIds: ['get_agent_groups'],
-    onSuccess,
-    onError,
-  });
-};
diff --git a/src/web/pages/agent-groups/AgentGroupsComponent.tsx b/src/web/pages/agent-groups/AgentGroupsComponent.tsx
index 5506604cea..1db38bf5d0 100644
--- a/src/web/pages/agent-groups/AgentGroupsComponent.tsx
+++ b/src/web/pages/agent-groups/AgentGroupsComponent.tsx
@@ -14,7 +14,7 @@ import {
   useCreateAgentGroup,
   useDeleteAgentGroup,
   useSaveAgentGroup,
-} from 'web/hooks/use-query/agent-groups';
+} from 'web/hooks/use-query/agent-group';
 import useTranslation from 'web/hooks/useTranslation';
 import AgentGroupsDialog, {
   type AgentGroupDialogData,

From 5bb872686b96ec4ebcbd005efc58be7199dea4e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 12:10:09 +0200
Subject: [PATCH 17/36] Change: Use useCloneMutation for all useClone*
 mutations

---
 src/web/hooks/use-query/__tests__/Target.test.tsx |  4 +---
 src/web/hooks/use-query/__tests__/Ticket.test.tsx |  3 +--
 src/web/hooks/use-query/__tests__/User.test.tsx   |  2 +-
 src/web/hooks/use-query/port-list.ts              |  8 +++-----
 src/web/hooks/use-query/target.ts                 | 10 ++++------
 src/web/hooks/use-query/ticket.ts                 |  8 +++-----
 src/web/hooks/use-query/user.ts                   | 10 ++++------
 7 files changed, 17 insertions(+), 28 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/Target.test.tsx b/src/web/hooks/use-query/__tests__/Target.test.tsx
index 668b9ae249..58626a7a4d 100644
--- a/src/web/hooks/use-query/__tests__/Target.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Target.test.tsx
@@ -115,11 +115,10 @@ describe('target mutation hooks', () => {
     await waitFor(() => {
       expect(gmp.target.clone).toHaveBeenCalledWith({
         id: 'target-1',
-        name: 'Cloned Target',
       });
       expect(onSuccess).toHaveBeenCalledWith({id: 'target-2'});
       expect(
-        screen.getByText('Cloned Target cloned successfully.'),
+        screen.getByText('Target Cloned Target cloned successfully'),
       ).toBeInTheDocument();
     });
   });
@@ -168,7 +167,6 @@ describe('target mutation hooks', () => {
     await waitFor(() => {
       expect(gmp.target.delete).toHaveBeenCalledWith({
         id: 'target-1',
-        name: 'Deleted Target',
       });
       expect(onSuccess).toHaveBeenCalledWith(undefined);
       expect(
diff --git a/src/web/hooks/use-query/__tests__/Ticket.test.tsx b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
index bec30ab764..d482b92c1c 100644
--- a/src/web/hooks/use-query/__tests__/Ticket.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
@@ -175,11 +175,10 @@ describe('ticket mutation hooks', () => {
     await waitFor(() => {
       expect(gmp.ticket.clone).toHaveBeenCalledWith({
         id: 'ticket-1',
-        name: 'Cloned Ticket',
       });
       expect(onSuccess).toHaveBeenCalledWith({id: 'ticket-3'});
       expect(
-        screen.getByText('Cloned Ticket cloned successfully.'),
+        screen.getByText('Ticket Cloned Ticket cloned successfully'),
       ).toBeInTheDocument();
     });
   });
diff --git a/src/web/hooks/use-query/__tests__/User.test.tsx b/src/web/hooks/use-query/__tests__/User.test.tsx
index 15c3837242..0378c85069 100644
--- a/src/web/hooks/use-query/__tests__/User.test.tsx
+++ b/src/web/hooks/use-query/__tests__/User.test.tsx
@@ -235,7 +235,7 @@ describe('remaining user mutation hooks', () => {
       expect(gmp.user.clone).toHaveBeenCalledWith({id: 'user-id'});
       expect(onSuccess).toHaveBeenCalledWith({id: 'cloned'});
       expect(
-        screen.getByText('Cloned User cloned successfully.'),
+        screen.getByText('User Cloned User cloned successfully'),
       ).toBeInTheDocument();
     });
   });
diff --git a/src/web/hooks/use-query/port-list.ts b/src/web/hooks/use-query/port-list.ts
index 43ae48b116..cf4cbc925e 100644
--- a/src/web/hooks/use-query/port-list.ts
+++ b/src/web/hooks/use-query/port-list.ts
@@ -13,6 +13,7 @@ import {
 } from 'gmp/commands/port-list';
 import _ from 'gmp/locale';
 import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UsePortListMutationCallbacks<TResponse> {
@@ -65,16 +66,13 @@ export const useClonePortList = ({
   onError,
 }: UsePortListMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyPortListParams, EntityActionData>({
+  return useCloneMutation<EntityActionData, Error>({
     gmpMethod: async ({id}: UseModifyPortListParams) => {
       const response = await gmp.portlist.clone({id});
       return response.data;
     },
+    entityType: 'portlist',
     invalidateQueryIds: ['get_port_lists'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} cloned successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/target.ts b/src/web/hooks/use-query/target.ts
index 428c0a81e1..9ad65b140d 100644
--- a/src/web/hooks/use-query/target.ts
+++ b/src/web/hooks/use-query/target.ts
@@ -11,6 +11,7 @@ import {
 import _ from 'gmp/locale';
 import type Target from 'gmp/models/target';
 import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -73,16 +74,13 @@ export const useCloneTarget = ({
   onError,
 }: UseTargetMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyTargetParams, EntityActionData>({
-    gmpMethod: async ({id}: UseModifyTargetParams) => {
+  return useCloneMutation<EntityActionData, Error>({
+    gmpMethod: async ({id}) => {
       const response = await gmp.target.clone({id});
       return response.data;
     },
+    entityType: 'target',
     invalidateQueryIds: ['get_targets'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} cloned successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/ticket.ts b/src/web/hooks/use-query/ticket.ts
index de7b94069a..164bcca110 100644
--- a/src/web/hooks/use-query/ticket.ts
+++ b/src/web/hooks/use-query/ticket.ts
@@ -11,6 +11,7 @@ import {
   type TicketStatusValue,
 } from 'gmp/models/ticket';
 import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -88,16 +89,13 @@ export const useCloneTicket = ({
   onError,
 }: UseTicketMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyTicketParams, EntityActionData>({
+  return useCloneMutation<EntityActionData, Error>({
     gmpMethod: async data => {
       const response = await gmp.ticket.clone(data);
       return response.data;
     },
+    entityType: 'ticket',
     invalidateQueryIds: ['get_tickets'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} cloned successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
index ce827cb37c..6feea546f9 100644
--- a/src/web/hooks/use-query/user.ts
+++ b/src/web/hooks/use-query/user.ts
@@ -9,6 +9,7 @@ import _ from 'gmp/locale';
 import type User from 'gmp/models/user';
 import useGmp from 'web/hooks/useGmp';
 import {type RefetchIntervalFn} from 'web/queries/helpers';
+import useCloneMutation from 'web/queries/useCloneMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -97,16 +98,13 @@ export const useCloneUser = ({
   onError,
 }: UseUserMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyUserParams, EntityActionData>({
-    gmpMethod: async ({id}: UseModifyUserParams) => {
+  return useCloneMutation<EntityActionData, Error>({
+    gmpMethod: async ({id}) => {
       const response = await gmp.user.clone({id});
       return response.data;
     },
+    entityType: 'user',
     invalidateQueryIds: ['get_users'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} cloned successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });

From a3a116a7ea889db71629f84a762cff7cab9b43cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 13:17:20 +0200
Subject: [PATCH 18/36] Change: Use useCreateMutation for all useCreate*
 mutations

---
 src/web/hooks/use-query/credential.ts | 9 +++++++--
 src/web/hooks/use-query/port-list.ts  | 8 +++++++-
 src/web/hooks/use-query/target.ts     | 4 +++-
 src/web/hooks/use-query/ticket.ts     | 4 +++-
 src/web/hooks/use-query/user.ts       | 4 +++-
 5 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/src/web/hooks/use-query/credential.ts b/src/web/hooks/use-query/credential.ts
index 0324b551ae..fc0ff626ac 100644
--- a/src/web/hooks/use-query/credential.ts
+++ b/src/web/hooks/use-query/credential.ts
@@ -6,7 +6,7 @@
 import {type CredentialCommandCreateParams} from 'gmp/commands/credential';
 import {type EntityActionData} from 'gmp/commands/entity';
 import useGmp from 'web/hooks/useGmp';
-import useGmpMutation from 'web/queries/useGmpMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
 
 interface UseCredentialMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
@@ -18,11 +18,16 @@ export const useCreateCredential = ({
   onError,
 }: UseCredentialMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<CredentialCommandCreateParams, EntityActionData>({
+  return useCreateMutation<
+    CredentialCommandCreateParams,
+    EntityActionData,
+    Error
+  >({
     gmpMethod: async data => {
       const response = await gmp.credential.create(data);
       return response.data;
     },
+    entityType: 'credential',
     invalidateQueryIds: ['get_credentials'],
     onSuccess,
     onError,
diff --git a/src/web/hooks/use-query/port-list.ts b/src/web/hooks/use-query/port-list.ts
index cf4cbc925e..6f915071da 100644
--- a/src/web/hooks/use-query/port-list.ts
+++ b/src/web/hooks/use-query/port-list.ts
@@ -14,6 +14,7 @@ import {
 import _ from 'gmp/locale';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UsePortListMutationCallbacks<TResponse> {
@@ -34,11 +35,16 @@ export const useCreatePortList = ({
   onError,
 }: UsePortListMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<PortListCommandCreateParams, EntityActionData>({
+  return useCreateMutation<
+    PortListCommandCreateParams,
+    EntityActionData,
+    Error
+  >({
     gmpMethod: async data => {
       const response = await gmp.portlist.create(data);
       return response.data;
     },
+    entityType: 'portlist',
     invalidateQueryIds: ['get_port_lists'],
     onSuccess,
     onError,
diff --git a/src/web/hooks/use-query/target.ts b/src/web/hooks/use-query/target.ts
index 9ad65b140d..8477cd84bd 100644
--- a/src/web/hooks/use-query/target.ts
+++ b/src/web/hooks/use-query/target.ts
@@ -12,6 +12,7 @@ import _ from 'gmp/locale';
 import type Target from 'gmp/models/target';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -42,11 +43,12 @@ export const useCreateTarget = ({
   onError,
 }: UseTargetMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<TargetCommandCreateParams, EntityActionData>({
+  return useCreateMutation<TargetCommandCreateParams, EntityActionData, Error>({
     gmpMethod: async data => {
       const response = await gmp.target.create(data);
       return response.data;
     },
+    entityType: 'target',
     invalidateQueryIds: ['get_targets'],
     onSuccess,
     onError,
diff --git a/src/web/hooks/use-query/ticket.ts b/src/web/hooks/use-query/ticket.ts
index 164bcca110..67a0332d3b 100644
--- a/src/web/hooks/use-query/ticket.ts
+++ b/src/web/hooks/use-query/ticket.ts
@@ -12,6 +12,7 @@ import {
 } from 'gmp/models/ticket';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -57,11 +58,12 @@ export const useCreateTicket = ({
   onError,
 }: UseTicketMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<TicketCreateInput, EntityActionData>({
+  return useCreateMutation<TicketCreateInput, EntityActionData, Error>({
     gmpMethod: async data => {
       const response = await gmp.ticket.create(data);
       return response.data;
     },
+    entityType: 'ticket',
     invalidateQueryIds: ['get_tickets'],
     onSuccess,
     onError,
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
index 6feea546f9..622c5488a8 100644
--- a/src/web/hooks/use-query/user.ts
+++ b/src/web/hooks/use-query/user.ts
@@ -10,6 +10,7 @@ import type User from 'gmp/models/user';
 import useGmp from 'web/hooks/useGmp';
 import {type RefetchIntervalFn} from 'web/queries/helpers';
 import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -63,11 +64,12 @@ export const useCreateUser = ({
   onError,
 }: UseUserMutationCallbacks<EntityActionData> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UserCreateInput, EntityActionData>({
+  return useCreateMutation<UserCreateInput, EntityActionData, Error>({
     gmpMethod: async data => {
       const response = await gmp.user.create(data);
       return response.data;
     },
+    entityType: 'user',
     invalidateQueryIds: ['get_users'],
     onSuccess,
     onError,

From fae6fe604a0f5c501da58ba8eeafe740af5da5b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 13:57:26 +0200
Subject: [PATCH 19/36] Change: Make input type of useDeleteMutation generic

For deleting a user an additional input argument is required.
---
 src/web/queries/useDeleteMutation.ts | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/web/queries/useDeleteMutation.ts b/src/web/queries/useDeleteMutation.ts
index db0ec23d0e..d53d3694c6 100644
--- a/src/web/queries/useDeleteMutation.ts
+++ b/src/web/queries/useDeleteMutation.ts
@@ -9,27 +9,35 @@ import useTranslation from 'web/hooks/useTranslation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 export interface DeleteMutationInput extends EntityCommandParams {
-  name?: string;
+  name: string | undefined;
 }
 
-interface UseDeleteMutationParams<TOutput, TError> {
+interface UseDeleteMutationParams<
+  TOutput,
+  TError,
+  TInput extends DeleteMutationInput,
+> {
   entityType: EntityType;
-  gmpMethod: (input: EntityCommandParams) => Promise<TOutput>;
+  gmpMethod: (input: TInput) => Promise<TOutput>;
   invalidateQueryIds?: string[];
   onSuccess?: (data: TOutput) => void;
   onError?: (error: TError) => void;
 }
 
-const useDeleteMutation = <TOutput = void, TError = Error>({
+const useDeleteMutation = <
+  TOutput = void,
+  TError = Error,
+  TInput extends DeleteMutationInput = DeleteMutationInput,
+>({
   gmpMethod,
   entityType,
   invalidateQueryIds,
   onSuccess,
   onError,
-}: UseDeleteMutationParams<TOutput, TError>) => {
+}: UseDeleteMutationParams<TOutput, TError, TInput>) => {
   const [_] = useTranslation();
-  return useGmpMutation<DeleteMutationInput, TOutput, TError>({
-    gmpMethod: ({id}) => gmpMethod({id}),
+  return useGmpMutation<TInput, TOutput, TError>({
+    gmpMethod: (data: TInput) => gmpMethod(data),
     invalidateQueryIds,
     successMessage: (_data, variables) =>
       variables.name

From 4ddaffae2090564f5a6e04222a6d3c6f4ca7fa13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 13:59:11 +0200
Subject: [PATCH 20/36] Change: Make inheritorId for deleting a user optional

It's not required for GMP.
---
 src/gmp/commands/user.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/gmp/commands/user.ts b/src/gmp/commands/user.ts
index 0e60a145b8..61b28f39fe 100644
--- a/src/gmp/commands/user.ts
+++ b/src/gmp/commands/user.ts
@@ -108,9 +108,9 @@ interface SaveArguments extends CreateArguments {
   oldName: string;
 }
 
-interface DeleteArguments {
+export interface UserCommandDeleteParams {
   id: string;
-  inheritorId: string;
+  inheritorId?: string;
 }
 
 const log = logger.getLogger('gmp.commands.users');
@@ -367,7 +367,7 @@ class UserCommand extends EntityCommand<User, PortListElement> {
     return this.action(data);
   }
 
-  async delete({id, inheritorId}: DeleteArguments) {
+  async delete({id, inheritorId}: UserCommandDeleteParams) {
     const data = {
       cmd: 'delete_user',
       id,

From acc7bbfc768284487da113e7a8033ea9e5405cdd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 14:27:27 +0200
Subject: [PATCH 21/36] Change: Improve types for generic query hooks which
 have a success message

Ensure that the name argument is passed by default and the type checker
complains about it. This ensure the success message is displayed
correctly.
---
 src/web/queries/useCloneMutation.ts  |  2 +-
 src/web/queries/useCreateMutation.ts | 11 +++++++----
 src/web/queries/useDeleteMutation.ts | 14 +++++---------
 3 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/web/queries/useCloneMutation.ts b/src/web/queries/useCloneMutation.ts
index 99e4be346b..9fc689d1c6 100644
--- a/src/web/queries/useCloneMutation.ts
+++ b/src/web/queries/useCloneMutation.ts
@@ -9,7 +9,7 @@ import useTranslation from 'web/hooks/useTranslation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 export interface CloneMutationInput extends EntityCommandParams {
-  name?: string;
+  name: string | undefined;
 }
 
 interface UseCloneMutationParams<TOutput, TError> {
diff --git a/src/web/queries/useCreateMutation.ts b/src/web/queries/useCreateMutation.ts
index bc61edb521..ba807ecf9f 100644
--- a/src/web/queries/useCreateMutation.ts
+++ b/src/web/queries/useCreateMutation.ts
@@ -7,6 +7,10 @@ import {type EntityType, typeName} from 'gmp/utils/entity-type';
 import useTranslation from 'web/hooks/useTranslation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
+export interface CreateMutationInput {
+  name: string | undefined;
+}
+
 interface UseCreateMutationParams<TInput, TOutput, TError> {
   gmpMethod: (input: TInput) => Promise<TOutput>;
   entityType: EntityType;
@@ -16,7 +20,7 @@ interface UseCreateMutationParams<TInput, TOutput, TError> {
 }
 
 const useCreateMutation = <
-  TInput = unknown,
+  TInput extends object = CreateMutationInput,
   TOutput = unknown,
   TError = Error,
 >({
@@ -31,11 +35,10 @@ const useCreateMutation = <
     gmpMethod,
     invalidateQueryIds,
     successMessage: (_data, variables) => {
-      const name = (variables as Record<string, unknown>)?.name;
-      return typeof name === 'string' && name
+      return 'name' in variables && variables.name
         ? _('{{entity}} {{- name}} successfully created', {
             entity: typeName(entityType),
-            name,
+            name: variables.name as string,
           })
         : _('{{entity}} successfully created', {
             entity: typeName(entityType),
diff --git a/src/web/queries/useDeleteMutation.ts b/src/web/queries/useDeleteMutation.ts
index d53d3694c6..4fefadee14 100644
--- a/src/web/queries/useDeleteMutation.ts
+++ b/src/web/queries/useDeleteMutation.ts
@@ -12,11 +12,7 @@ export interface DeleteMutationInput extends EntityCommandParams {
   name: string | undefined;
 }
 
-interface UseDeleteMutationParams<
-  TOutput,
-  TError,
-  TInput extends DeleteMutationInput,
-> {
+interface UseDeleteMutationParams<TInput, TOutput, TError> {
   entityType: EntityType;
   gmpMethod: (input: TInput) => Promise<TOutput>;
   invalidateQueryIds?: string[];
@@ -25,25 +21,25 @@ interface UseDeleteMutationParams<
 }
 
 const useDeleteMutation = <
+  TInput extends object = DeleteMutationInput,
   TOutput = void,
   TError = Error,
-  TInput extends DeleteMutationInput = DeleteMutationInput,
 >({
   gmpMethod,
   entityType,
   invalidateQueryIds,
   onSuccess,
   onError,
-}: UseDeleteMutationParams<TOutput, TError, TInput>) => {
+}: UseDeleteMutationParams<TInput, TOutput, TError>) => {
   const [_] = useTranslation();
   return useGmpMutation<TInput, TOutput, TError>({
     gmpMethod: (data: TInput) => gmpMethod(data),
     invalidateQueryIds,
     successMessage: (_data, variables) =>
-      variables.name
+      'name' in variables && variables.name
         ? _('{{entity}} {{- name}} successfully deleted', {
             entity: typeName(entityType),
-            name: variables.name,
+            name: variables.name as string,
           })
         : _('{{entity}} successfully deleted', {
             entity: typeName(entityType),

From 573c5fd69e22014b013742395bfbf1dc283c77f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 14:30:59 +0200
Subject: [PATCH 22/36] Change: Update and improve existing query hooks

Use useDeleteMutation and adapt arguments to recent changes.
---
 .../use-query/__tests__/AgentGroup.test.tsx   |  8 +++---
 .../hooks/use-query/__tests__/Agents.test.tsx | 24 ++++++++++++++---
 .../__tests__/OciImageTargets.test.tsx        |  8 +++++-
 .../use-query/__tests__/PortList.test.tsx     |  4 ++-
 .../hooks/use-query/__tests__/Target.test.tsx | 20 +++++++++++---
 .../hooks/use-query/__tests__/Ticket.test.tsx | 27 +++++++++++++++----
 .../hooks/use-query/__tests__/User.test.tsx   | 20 +++++++++++---
 .../__tests__/WebApplicationTargets.test.tsx  | 12 +++++++--
 src/web/hooks/use-query/agent-group.ts        |  6 ++---
 src/web/hooks/use-query/agents.ts             | 10 +++----
 src/web/hooks/use-query/port-list.ts          | 11 +++-----
 src/web/hooks/use-query/tags.ts               |  2 +-
 src/web/hooks/use-query/target.ts             | 15 +++--------
 src/web/hooks/use-query/ticket.ts             | 15 +++--------
 src/web/hooks/use-query/user.ts               | 27 +++++++------------
 15 files changed, 130 insertions(+), 79 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx b/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
index 54e2785ec3..2e2b19f0bb 100644
--- a/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
+++ b/src/web/hooks/use-query/__tests__/AgentGroup.test.tsx
@@ -48,7 +48,7 @@ describe('useCloneAgentGroup', () => {
   test('should clone an agent group', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-    const input = {id: 'group-1'};
+    const input = {id: 'group-1', name: 'Cloned Group'};
 
     const TestComponent = () => {
       const mutation = useCloneAgentGroup({});
@@ -59,7 +59,7 @@ describe('useCloneAgentGroup', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Run'}));
 
     await waitFor(() => {
-      expect(gmp.agentgroup.clone).toHaveBeenCalledWith(input);
+      expect(gmp.agentgroup.clone).toHaveBeenCalledWith({id: 'group-1'});
     });
   });
 });
@@ -88,7 +88,7 @@ describe('useDeleteAgentGroup', () => {
   test('should delete an agent group', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-    const input = {id: 'group-1'};
+    const input = {id: 'group-1', name: 'Deleted Group'};
 
     const TestComponent = () => {
       const mutation = useDeleteAgentGroup({});
@@ -99,7 +99,7 @@ describe('useDeleteAgentGroup', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Run'}));
 
     await waitFor(() => {
-      expect(gmp.agentgroup.delete).toHaveBeenCalledWith(input);
+      expect(gmp.agentgroup.delete).toHaveBeenCalledWith({id: 'group-1'});
     });
   });
 });
diff --git a/src/web/hooks/use-query/__tests__/Agents.test.tsx b/src/web/hooks/use-query/__tests__/Agents.test.tsx
index 36d265dfc3..eb2eeeec71 100644
--- a/src/web/hooks/use-query/__tests__/Agents.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Agents.test.tsx
@@ -96,7 +96,7 @@ describe('useGetAgents', () => {
   });
 });
 
-describe('agent mutation hooks', () => {
+describe('useModifyAgent', () => {
   test('should save an agent', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -127,7 +127,9 @@ describe('agent mutation hooks', () => {
       });
     });
   });
+});
 
+describe('useDeleteAgent', () => {
   test('should delete an agent', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -135,7 +137,13 @@ describe('agent mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useDeleteAgent({});
       return (
-        <button onClick={() => mutation.mutate({id: 'agent-1'})}>Delete</button>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'agent-1', name: 'Deleted Agent'})
+          }
+        >
+          Delete
+        </button>
       );
     };
 
@@ -143,10 +151,14 @@ describe('agent mutation hooks', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
 
     await waitFor(() => {
-      expect(gmp.agent.delete).toHaveBeenCalledWith({id: 'agent-1'});
+      expect(gmp.agent.delete).toHaveBeenCalledWith({
+        id: 'agent-1',
+      });
     });
   });
+});
 
+describe('useBulkDeleteAgents', () => {
   test('should delete agents by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -172,7 +184,9 @@ describe('agent mutation hooks', () => {
       expect(gmp.agents.deleteByFilter).toHaveBeenCalledWith(filter);
     });
   });
+});
 
+describe('bulk agent mutation hooks', () => {
   test.each([
     ['authorize', useBulkAuthorizeAgents, 'authorize', 'authorizeByFilter'],
     ['revoke', useBulkRevokeAgents, 'revoke', 'revokeByFilter'],
@@ -214,7 +228,9 @@ describe('agent mutation hooks', () => {
       });
     },
   );
+});
 
+describe('useSyncAgents', () => {
   test('should sync agents', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -231,7 +247,9 @@ describe('agent mutation hooks', () => {
       expect(gmp.agents.sync).toHaveBeenCalledWith();
     });
   });
+});
 
+describe('useDownloadAgentSupportBundle', () => {
   test('should download an agent support bundle', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
diff --git a/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx b/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
index 315e4de444..a71a6b734b 100644
--- a/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
+++ b/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
@@ -85,7 +85,13 @@ describe('OCI image target query hooks', () => {
           <button onClick={() => remove.mutate({id: 'target-1'})}>
             Delete
           </button>
-          <button onClick={() => clone.mutate({id: 'target-1'})}>Clone</button>
+          <button
+            onClick={() =>
+              clone.mutate({id: 'target-1', name: 'Cloned Target'})
+            }
+          >
+            Clone
+          </button>
           <button onClick={() => bulkDelete.mutate([target] as never)}>
             Bulk delete
           </button>
diff --git a/src/web/hooks/use-query/__tests__/PortList.test.tsx b/src/web/hooks/use-query/__tests__/PortList.test.tsx
index bbded3475d..cbc2ecdad9 100644
--- a/src/web/hooks/use-query/__tests__/PortList.test.tsx
+++ b/src/web/hooks/use-query/__tests__/PortList.test.tsx
@@ -173,7 +173,9 @@ describe('useDeletePortList', () => {
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
 
     await waitFor(() => {
-      expect(gmp.portlist.delete).toHaveBeenCalledWith({id: 'port-list-1'});
+      expect(gmp.portlist.delete).toHaveBeenCalledWith({
+        id: 'port-list-1',
+      });
     });
   });
 });
diff --git a/src/web/hooks/use-query/__tests__/Target.test.tsx b/src/web/hooks/use-query/__tests__/Target.test.tsx
index 58626a7a4d..7a9162d845 100644
--- a/src/web/hooks/use-query/__tests__/Target.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Target.test.tsx
@@ -90,7 +90,7 @@ describe('useGetTarget', () => {
   });
 });
 
-describe('target mutation hooks', () => {
+describe('useCloneTarget', () => {
   test('should clone a target with its name and call onSuccess', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -133,7 +133,13 @@ describe('target mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useCloneTarget({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'target-1'})}>Clone</button>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'target-1', name: 'Cloned Target'})
+          }
+        >
+          Clone
+        </button>
       );
     };
 
@@ -142,7 +148,9 @@ describe('target mutation hooks', () => {
 
     await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
+});
 
+describe('useDeleteTarget', () => {
   test('should delete a target with its name and call onSuccess', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -170,7 +178,7 @@ describe('target mutation hooks', () => {
       });
       expect(onSuccess).toHaveBeenCalledWith(undefined);
       expect(
-        screen.getByText('Deleted Target deleted successfully.'),
+        screen.getByText('Target Deleted Target successfully deleted'),
       ).toBeInTheDocument();
     });
   });
@@ -185,7 +193,11 @@ describe('target mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useDeleteTarget({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'target-1'})}>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'target-1', name: 'Deleted Target'})
+          }
+        >
           Delete
         </button>
       );
diff --git a/src/web/hooks/use-query/__tests__/Ticket.test.tsx b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
index d482b92c1c..d26f546af4 100644
--- a/src/web/hooks/use-query/__tests__/Ticket.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Ticket.test.tsx
@@ -109,7 +109,7 @@ describe('useGetTicket', () => {
   });
 });
 
-describe('ticket mutation hooks', () => {
+describe('useCreateTicket', () => {
   test('should create a ticket', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -127,7 +127,9 @@ describe('ticket mutation hooks', () => {
       expect(gmp.ticket.create).toHaveBeenCalledWith(input);
     });
   });
+});
 
+describe('useSaveTicket', () => {
   test('should save a ticket', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -150,7 +152,9 @@ describe('ticket mutation hooks', () => {
       expect(gmp.ticket.save).toHaveBeenCalledWith(input);
     });
   });
+});
 
+describe('useCloneTicket', () => {
   test('should clone a ticket with its name and call onSuccess', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -193,7 +197,13 @@ describe('ticket mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useCloneTicket({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>Clone</button>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'ticket-1', name: 'Cloned Ticket'})
+          }
+        >
+          Clone
+        </button>
       );
     };
 
@@ -202,7 +212,9 @@ describe('ticket mutation hooks', () => {
 
     await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
+});
 
+describe('useDeleteTicket', () => {
   test('should delete a ticket with its name and call onSuccess', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -227,11 +239,10 @@ describe('ticket mutation hooks', () => {
     await waitFor(() => {
       expect(gmp.ticket.delete).toHaveBeenCalledWith({
         id: 'ticket-1',
-        name: 'Deleted Ticket',
       });
       expect(onSuccess).toHaveBeenCalledWith(undefined);
       expect(
-        screen.getByText('Deleted Ticket deleted successfully.'),
+        screen.getByText('Ticket Deleted Ticket successfully deleted'),
       ).toBeInTheDocument();
     });
   });
@@ -246,7 +257,11 @@ describe('ticket mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useDeleteTicket({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'ticket-1'})}>
+        <button
+          onClick={() =>
+            mutation.mutate({id: 'ticket-1', name: 'Deleted Ticket'})
+          }
+        >
           Delete
         </button>
       );
@@ -257,7 +272,9 @@ describe('ticket mutation hooks', () => {
 
     await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
+});
 
+describe('useDownloadTicket', () => {
   test('should download a ticket', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
diff --git a/src/web/hooks/use-query/__tests__/User.test.tsx b/src/web/hooks/use-query/__tests__/User.test.tsx
index 0378c85069..f7202c9951 100644
--- a/src/web/hooks/use-query/__tests__/User.test.tsx
+++ b/src/web/hooks/use-query/__tests__/User.test.tsx
@@ -207,7 +207,7 @@ describe('useSaveUser', () => {
   });
 });
 
-describe('remaining user mutation hooks', () => {
+describe('useCloneUser', () => {
   test('should clone a user with its name and call onSuccess', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -248,7 +248,11 @@ describe('remaining user mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useCloneUser({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'user-id'})}>Clone</button>
+        <button
+          onClick={() => mutation.mutate({id: 'user-id', name: 'Cloned User'})}
+        >
+          Clone
+        </button>
       );
     };
 
@@ -257,7 +261,9 @@ describe('remaining user mutation hooks', () => {
 
     await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
+});
 
+describe('useDeleteUser', () => {
   test('should delete a user with its name and forward the inheritor ID', async () => {
     const gmp = createGmp();
     const onSuccess = testing.fn();
@@ -282,7 +288,7 @@ describe('remaining user mutation hooks', () => {
       });
       expect(onSuccess).toHaveBeenCalledWith(undefined);
       expect(
-        screen.getByText('Deleted User deleted successfully.'),
+        screen.getByText('User Deleted User successfully deleted'),
       ).toBeInTheDocument();
     });
   });
@@ -297,7 +303,11 @@ describe('remaining user mutation hooks', () => {
     const TestComponent = () => {
       const mutation = useDeleteUser({onError});
       return (
-        <button onClick={() => mutation.mutate({id: 'user-id'})}>Delete</button>
+        <button
+          onClick={() => mutation.mutate({id: 'user-id', name: 'Deleted User'})}
+        >
+          Delete
+        </button>
       );
     };
 
@@ -306,7 +316,9 @@ describe('remaining user mutation hooks', () => {
 
     await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
   });
+});
 
+describe('useDownloadUser', () => {
   test('should download a user', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
diff --git a/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx b/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
index 41cebe61c7..cec43e70ed 100644
--- a/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
+++ b/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
@@ -82,10 +82,18 @@ describe('web application target query hooks', () => {
           <button onClick={() => save.mutate({id: 'target-1', name: 'Saved'})}>
             Save
           </button>
-          <button onClick={() => remove.mutate({id: 'target-1'})}>
+          <button
+            onClick={() => remove.mutate({id: 'target-1', name: 'Target 1'})}
+          >
             Delete
           </button>
-          <button onClick={() => clone.mutate({id: 'target-1'})}>Clone</button>
+          <button
+            onClick={() =>
+              clone.mutate({id: 'target-1', name: 'Cloned Target'})
+            }
+          >
+            Clone
+          </button>
           <button onClick={() => bulkDelete.mutate(filter as never)}>
             Bulk delete
           </button>
diff --git a/src/web/hooks/use-query/agent-group.ts b/src/web/hooks/use-query/agent-group.ts
index b36593d511..78a45a0393 100644
--- a/src/web/hooks/use-query/agent-group.ts
+++ b/src/web/hooks/use-query/agent-group.ts
@@ -18,12 +18,12 @@ import useSaveMutation from 'web/queries/useSaveMutation';
 
 interface UseCreateAgentGroupParams {
   onSuccess?: (data: EntityActionResponse) => void;
-  onError?: (error: Rejection) => void;
+  onError?: (error: Error) => void;
 }
 
 interface UseModifyAgentGroupParams {
   onSuccess?: () => void;
-  onError?: (error: Rejection) => void;
+  onError?: (error: Error) => void;
 }
 
 export const useCreateAgentGroup = ({
@@ -78,7 +78,7 @@ export const useDeleteAgentGroup = ({
 }: UseModifyAgentGroupParams) => {
   const gmp = useGmp();
   return useDeleteMutation({
-    gmpMethod: gmp.agentgroup.delete.bind(gmp.agentgroup),
+    gmpMethod: ({id}) => gmp.agentgroup.delete({id}),
     entityType: AgentGroup.entityType,
     invalidateQueryIds: ['get_agent_groups'],
     onSuccess,
diff --git a/src/web/hooks/use-query/agents.ts b/src/web/hooks/use-query/agents.ts
index f9e1e97099..40abab4dd3 100644
--- a/src/web/hooks/use-query/agents.ts
+++ b/src/web/hooks/use-query/agents.ts
@@ -30,14 +30,14 @@ interface UseGetAgentsParams {
 
 interface UseModifyAgentParams {
   onSuccess?: () => void;
-  onError?: (error: Rejection) => void;
+  onError?: (error: Error) => void;
 }
 
 type AgentBulkInput = Agent[] | FilterType;
 
 interface UseDownloadAgentSupportBundleParams {
   onSuccess?: (response: Response<ArrayBuffer>) => void;
-  onError?: (error: Rejection) => void;
+  onError?: (error: Error) => void;
 }
 
 export interface DownloadAgentSupportBundleInput {
@@ -108,8 +108,8 @@ export const useModifyAgent = ({
 export const useDeleteAgent = ({onError, onSuccess}: UseModifyAgentParams) => {
   const gmp = useGmp();
   return useDeleteMutation({
-    gmpMethod: gmp.agent.delete.bind(gmp.agentgroup),
-    entityType: 'agentgroup',
+    gmpMethod: ({id}) => gmp.agent.delete({id}),
+    entityType: 'agent',
     invalidateQueryIds: ['get_agents'],
     onSuccess,
     onError,
@@ -179,7 +179,7 @@ export const useSyncAgents = ({
 }: UseModifyAgentParams = {}) => {
   const [_] = useTranslation();
   const gmp = useGmp();
-  return useGmpMutation<void, void, Rejection>({
+  return useGmpMutation<void, void, Error>({
     gmpMethod: () => gmp.agents.sync(),
     invalidateQueryIds: ['get_agents'],
     successMessage: _('Agents successfully synced'),
diff --git a/src/web/hooks/use-query/port-list.ts b/src/web/hooks/use-query/port-list.ts
index 6f915071da..3c0efe2bc5 100644
--- a/src/web/hooks/use-query/port-list.ts
+++ b/src/web/hooks/use-query/port-list.ts
@@ -11,10 +11,10 @@ import {
   type PortListCommandCreatePortRangeParams,
   type PortListCommandDeletePortRangeParams,
 } from 'gmp/commands/port-list';
-import _ from 'gmp/locale';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UsePortListMutationCallbacks<TResponse> {
@@ -89,13 +89,10 @@ export const useDeletePortList = ({
   onError,
 }: UsePortListMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyPortListParams, void>({
-    gmpMethod: ({id}: UseModifyPortListParams) => gmp.portlist.delete({id}),
+  return useDeleteMutation({
+    gmpMethod: ({id}) => gmp.portlist.delete({id}),
+    entityType: 'portlist',
     invalidateQueryIds: ['get_port_lists', 'get_port_list'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} deleted successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/tags.ts b/src/web/hooks/use-query/tags.ts
index 537435c98a..aae64e8be8 100644
--- a/src/web/hooks/use-query/tags.ts
+++ b/src/web/hooks/use-query/tags.ts
@@ -67,7 +67,7 @@ export const useGetTag = ({id, refetchInterval}: UseGetTagParams) => {
 
 export const useDeleteTag = ({onError, onSuccess}: UseMutationCallbacks) => {
   const gmp = useGmp();
-  return useDeleteMutation<void, Rejection>({
+  return useDeleteMutation({
     entityType: 'tag',
     gmpMethod: ({id}) => gmp.tag.delete({id}),
     invalidateQueryIds: ['get_tags'],
diff --git a/src/web/hooks/use-query/target.ts b/src/web/hooks/use-query/target.ts
index 8477cd84bd..a5415a743a 100644
--- a/src/web/hooks/use-query/target.ts
+++ b/src/web/hooks/use-query/target.ts
@@ -8,11 +8,11 @@ import {
   type TargetCommandCreateParams,
   type TargetCommandSaveParams,
 } from 'gmp/commands/target';
-import _ from 'gmp/locale';
 import type Target from 'gmp/models/target';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -25,10 +25,6 @@ interface UseGetTargetParams {
   id: string;
 }
 
-interface UseModifyTargetParams extends UseGetTargetParams {
-  name?: string;
-}
-
 export const useGetTarget = ({id}: UseGetTargetParams) => {
   const gmp = useGmp();
   return useGetEntity<Target>({
@@ -93,13 +89,10 @@ export const useDeleteTarget = ({
   onError,
 }: UseTargetMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyTargetParams, void>({
-    gmpMethod: ({id}: UseModifyTargetParams) => gmp.target.delete({id}),
+  return useDeleteMutation({
+    gmpMethod: ({id}) => gmp.target.delete({id}),
+    entityType: 'target',
     invalidateQueryIds: ['get_targets', 'get_target'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} deleted successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/ticket.ts b/src/web/hooks/use-query/ticket.ts
index 67a0332d3b..e2506140ce 100644
--- a/src/web/hooks/use-query/ticket.ts
+++ b/src/web/hooks/use-query/ticket.ts
@@ -5,7 +5,6 @@
 
 import {type EntityActionData} from 'gmp/commands/entity';
 import type Response from 'gmp/http/response';
-import _ from 'gmp/locale';
 import {
   type default as Ticket,
   type TicketStatusValue,
@@ -13,6 +12,7 @@ import {
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -20,10 +20,6 @@ interface UseGetTicketParams {
   id: string;
 }
 
-interface UseModifyTicketParams extends UseGetTicketParams {
-  name?: string;
-}
-
 interface UseTicketMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
   onError?: (error: Error) => void;
@@ -108,13 +104,10 @@ export const useDeleteTicket = ({
   onError,
 }: UseTicketMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseModifyTicketParams, void>({
-    gmpMethod: data => gmp.ticket.delete(data),
+  return useDeleteMutation({
+    gmpMethod: ({id}) => gmp.ticket.delete({id}),
+    entityType: 'ticket',
     invalidateQueryIds: ['get_tickets', 'get_ticket'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} deleted successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
index 622c5488a8..eb620a2b42 100644
--- a/src/web/hooks/use-query/user.ts
+++ b/src/web/hooks/use-query/user.ts
@@ -4,13 +4,14 @@
  */
 
 import {type EntityActionData} from 'gmp/commands/entity';
+import {type UserCommandDeleteParams} from 'gmp/commands/user';
 import type Response from 'gmp/http/response';
-import _ from 'gmp/locale';
 import type User from 'gmp/models/user';
 import useGmp from 'web/hooks/useGmp';
 import {type RefetchIntervalFn} from 'web/queries/helpers';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -19,15 +20,6 @@ interface UseGetUserParams {
   refetchInterval?: RefetchIntervalFn<User>;
 }
 
-interface UseModifyUserParams {
-  id: string;
-  name?: string;
-}
-
-interface UseDeleteUserParams extends UseModifyUserParams {
-  inheritorId?: string;
-}
-
 interface UseUserMutationCallbacks<TResponse> {
   onSuccess?: (response: TResponse) => void;
   onError?: (error: Error) => void;
@@ -49,6 +41,10 @@ interface UserSaveInput extends UserCreateInput {
   oldName?: string;
 }
 
+interface UserDeleteInput extends UserCommandDeleteParams {
+  name: string | undefined;
+}
+
 export const useGetUser = ({id, refetchInterval}: UseGetUserParams) => {
   const gmp = useGmp();
   return useGetEntity<User>({
@@ -117,14 +113,11 @@ export const useDeleteUser = ({
   onError,
 }: UseUserMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UseDeleteUserParams, void>({
-    gmpMethod: ({id, inheritorId}: UseDeleteUserParams) =>
-      gmp.user.delete({id, inheritorId: inheritorId ?? ''}),
+  return useDeleteMutation<UserDeleteInput>({
+    gmpMethod: ({id, inheritorId}: UserDeleteInput) =>
+      gmp.user.delete({id, inheritorId}),
+    entityType: 'user',
     invalidateQueryIds: ['get_users', 'get_user'],
-    successMessage: (_data, entity) =>
-      _('{{- name}} deleted successfully.', {
-        name: entity.name as string,
-      }),
     onSuccess,
     onError,
   });

From b80ca2af2bffe3acaa9e1a2dde4b90675939d4b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Tue, 6 Oct 2026 14:32:08 +0200
Subject: [PATCH 23/36] Adapt components to query hook changes

---
 src/web/pages/agents/AgentComponent.tsx                  | 5 ++---
 src/web/pages/agents/AgentListPageToolBarIcons.tsx       | 3 +--
 src/web/pages/portlists/PortListComponent.tsx            | 4 ++--
 src/web/pages/targets/TargetComponent.tsx                | 4 ++--
 src/web/pages/targets/__tests__/TargetComponent.test.tsx | 4 +++-
 src/web/pages/targets/__tests__/TargetListPage.test.tsx  | 3 +++
 src/web/pages/tickets/TicketComponent.tsx                | 4 ++--
 src/web/pages/users/UserComponent.tsx                    | 4 ++--
 8 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/web/pages/agents/AgentComponent.tsx b/src/web/pages/agents/AgentComponent.tsx
index d5a7fab2dd..c0a642440a 100644
--- a/src/web/pages/agents/AgentComponent.tsx
+++ b/src/web/pages/agents/AgentComponent.tsx
@@ -4,7 +4,6 @@
  */
 
 import React, {useState} from 'react';
-import type Rejection from 'gmp/http/rejection';
 import type Agent from 'gmp/models/agent';
 import {useDeleteAgent, useModifyAgent} from 'web/hooks/use-query/agents';
 import useTranslation from 'web/hooks/useTranslation';
@@ -19,9 +18,9 @@ interface AgentComponentRenderProps {
 interface AgentComponentProps {
   children: (actions: AgentComponentRenderProps) => React.ReactNode;
   onDeleted?: () => void;
-  onDeleteError?: (error: Rejection) => void;
+  onDeleteError?: (error: Error) => void;
   onSaved?: () => void;
-  onSaveError?: (error: Rejection) => void;
+  onSaveError?: (error: Error) => void;
 }
 
 const AgentComponent = ({
diff --git a/src/web/pages/agents/AgentListPageToolBarIcons.tsx b/src/web/pages/agents/AgentListPageToolBarIcons.tsx
index 2a0f033bae..c0e8d032c9 100644
--- a/src/web/pages/agents/AgentListPageToolBarIcons.tsx
+++ b/src/web/pages/agents/AgentListPageToolBarIcons.tsx
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import type Rejection from 'gmp/http/rejection';
 import type Agent from 'gmp/models/agent';
 import {isDefined} from 'gmp/utils/identity';
 import DateTime from 'web/components/date/DateTime';
@@ -15,7 +14,7 @@ import useTranslation from 'web/hooks/useTranslation';
 
 interface AgentsListPageToolBarIconsProps {
   agents?: Agent[];
-  onError: (error: Rejection) => void;
+  onError: (error: Error) => void;
 }
 
 const AgentsListPageToolBarIcons = ({
diff --git a/src/web/pages/portlists/PortListComponent.tsx b/src/web/pages/portlists/PortListComponent.tsx
index 1c5a4a36eb..8eee97e995 100644
--- a/src/web/pages/portlists/PortListComponent.tsx
+++ b/src/web/pages/portlists/PortListComponent.tsx
@@ -124,14 +124,14 @@ const PortListComponent = ({
     onError: onCloneError,
   });
   const clonePortList = async (data: PortList) =>
-    await clonePortListMutation.mutateAsync(data);
+    await clonePortListMutation.mutateAsync({id: data.id, name: data.name});
 
   const deletePortListMutation = useDeletePortList({
     onSuccess: onDeleted,
     onError: onDeleteError,
   });
   const deletePortList = async (data: PortList) =>
-    await deletePortListMutation.mutateAsync(data);
+    await deletePortListMutation.mutateAsync({id: data.id, name: data.name});
 
   const importPortListMutation = useImportPortList({
     onSuccess: onImported,
diff --git a/src/web/pages/targets/TargetComponent.tsx b/src/web/pages/targets/TargetComponent.tsx
index 5002af6604..de089335e2 100644
--- a/src/web/pages/targets/TargetComponent.tsx
+++ b/src/web/pages/targets/TargetComponent.tsx
@@ -329,7 +329,7 @@ const TargetComponent = ({
   });
 
   const cloneTarget = async (entity: Target) => {
-    await cloneTargetMutation.mutateAsync(entity);
+    await cloneTargetMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const saveTargetMutation = useSaveTarget({
@@ -354,7 +354,7 @@ const TargetComponent = ({
   });
 
   const deleteTarget = async (entity: Target) => {
-    await deleteTargetMutation.mutateAsync(entity);
+    await deleteTargetMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const handleSaveClick = async (data: TargetDialogData) => {
diff --git a/src/web/pages/targets/__tests__/TargetComponent.test.tsx b/src/web/pages/targets/__tests__/TargetComponent.test.tsx
index 964016977e..a4aca720a6 100644
--- a/src/web/pages/targets/__tests__/TargetComponent.test.tsx
+++ b/src/web/pages/targets/__tests__/TargetComponent.test.tsx
@@ -385,7 +385,9 @@ describe('TargetComponent tests', () => {
 
     await actions?.delete(new Target({id: 'target-id', name: 'Target'}));
 
-    expect(gmp.target.delete).toHaveBeenCalledWith({id: 'target-id'});
+    expect(gmp.target.delete).toHaveBeenCalledWith({
+      id: 'target-id',
+    });
     expect(onDeleted).toHaveBeenCalled();
   });
 
diff --git a/src/web/pages/targets/__tests__/TargetListPage.test.tsx b/src/web/pages/targets/__tests__/TargetListPage.test.tsx
index 9b63d0d463..9356f55831 100644
--- a/src/web/pages/targets/__tests__/TargetListPage.test.tsx
+++ b/src/web/pages/targets/__tests__/TargetListPage.test.tsx
@@ -105,6 +105,9 @@ const createGmp = ({
     delete: deleteByIds,
     export: exportByIds,
   },
+  target: {
+    delete: testing.fn().mockResolvedValue(undefined),
+  },
   filters: {
     get: getFilters,
   },
diff --git a/src/web/pages/tickets/TicketComponent.tsx b/src/web/pages/tickets/TicketComponent.tsx
index 7c10d27678..4107acdb12 100644
--- a/src/web/pages/tickets/TicketComponent.tsx
+++ b/src/web/pages/tickets/TicketComponent.tsx
@@ -167,11 +167,11 @@ const TicketComponent = ({
   };
 
   const cloneTicket = async (entity: Ticket) => {
-    await cloneMutation.mutateAsync({id: entity.id});
+    await cloneMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const deleteTicket = async (entity: Ticket) => {
-    await deleteMutation.mutateAsync({id: entity.id});
+    await deleteMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const downloadTicketEntity = async (entity: Ticket) => {
diff --git a/src/web/pages/users/UserComponent.tsx b/src/web/pages/users/UserComponent.tsx
index bcfd94300d..470ed8bb1f 100644
--- a/src/web/pages/users/UserComponent.tsx
+++ b/src/web/pages/users/UserComponent.tsx
@@ -153,11 +153,11 @@ const UserComponent = ({
   };
 
   const cloneUser = async (entity: User) => {
-    await cloneMutation.mutateAsync({id: entity.id});
+    await cloneMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const deleteUser = async (entity: User) => {
-    await deleteMutation.mutateAsync({id: entity.id});
+    await deleteMutation.mutateAsync({id: entity.id, name: entity.name});
   };
 
   const downloadUserEntity = async (entity: User) => {

From 483be7538a36b6f6582bf1852e5d69ba6234b01a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 07:56:47 +0200
Subject: [PATCH 24/36] Change: Split tag query hooks into two modules

One for tag and one for tags queries.
---
 .../hooks/use-query/__tests__/Tag.test.tsx    | 179 ++++++++++++++++++
 .../hooks/use-query/__tests__/Tags.test.tsx   |  84 +++-----
 src/web/hooks/use-query/tag.ts                | 134 +++++++++++++
 src/web/hooks/use-query/tags.ts               | 120 +-----------
 src/web/pages/tags/TagComponent.tsx           |   2 +-
 src/web/pages/tags/TagDetailsPage.tsx         |   2 +-
 6 files changed, 339 insertions(+), 182 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Tag.test.tsx
 create mode 100644 src/web/hooks/use-query/tag.ts

diff --git a/src/web/hooks/use-query/__tests__/Tag.test.tsx b/src/web/hooks/use-query/__tests__/Tag.test.tsx
new file mode 100644
index 0000000000..3e5805fe60
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Tag.test.tsx
@@ -0,0 +1,179 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import Tag from 'gmp/models/tag';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneTag,
+  useCreateTag,
+  useDeleteTag,
+  useDisableTag,
+  useEnableTag,
+  useGetTag,
+  useSaveTag,
+} from 'web/hooks/use-query/tag';
+
+const tag = new Tag({id: 'tag-1', name: 'Tag 1', value: 'value'});
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  tag: {
+    get: testing.fn().mockResolvedValue({data: tag}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    enable: testing.fn().mockResolvedValue({data: {}}),
+    disable: testing.fn().mockResolvedValue({data: {}}),
+    create: testing.fn().mockResolvedValue({data: {id: 'tag-2'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'tag-1'}}),
+    clone: testing.fn().mockResolvedValue({data: {id: 'tag-2'}}),
+  },
+});
+
+describe('useGetTag', () => {
+  test('should fetch a tag by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const {data} = useGetTag({id: 'tag-1'});
+      return <div data-testid="tag">{data?.name}</div>;
+    };
+
+    render(<TestComponent />);
+    await waitFor(() => {
+      expect(screen.getByTestId('tag')).toHaveTextContent('Tag 1');
+    });
+    expect(gmp.tag.get).toHaveBeenCalledWith({id: 'tag-1'});
+  });
+});
+
+describe('useDeleteTag', () => {
+  test('should delete a tag', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDeleteTag({});
+      return (
+        <button onClick={() => mutation.mutate({id: 'tag-1', name: 'tag-1'})}>
+          Run
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.delete).toHaveBeenCalledWith({id: 'tag-1'});
+    });
+  });
+});
+
+describe('useEnableTag', () => {
+  test('should enable a tag', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useEnableTag({});
+      return (
+        <button onClick={() => mutation.mutate({id: 'tag-1'})}>Run</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.enable).toHaveBeenCalledWith({id: 'tag-1'});
+    });
+  });
+});
+
+describe('useDisableTag', () => {
+  test('should disable a tag', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDisableTag({});
+      return (
+        <button onClick={() => mutation.mutate({id: 'tag-1'})}>Run</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.disable).toHaveBeenCalledWith({id: 'tag-1'});
+    });
+  });
+});
+
+describe('useCreateTag', () => {
+  test('should create a tag', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {
+      active: true,
+      name: 'New Tag',
+      resourceType: 'tag' as const,
+      value: 'value',
+    };
+    const TestComponent = () => {
+      const mutation = useCreateTag({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.create).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useSaveTag', () => {
+  test('should save a tag', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {
+      active: true,
+      id: 'tag-1',
+      name: 'Saved Tag',
+      resourceType: 'tag' as const,
+    };
+    const TestComponent = () => {
+      const mutation = useSaveTag({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.save).toHaveBeenCalledWith(input);
+    });
+  });
+});
+
+describe('useCloneTag', () => {
+  test('should clone a tag by ID', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useCloneTag({});
+      return (
+        <button
+          onClick={() => mutation.mutate({id: 'tag-1', name: 'Cloned Tag'})}
+        >
+          Run
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.tag.clone).toHaveBeenCalledWith({id: 'tag-1'});
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Tags.test.tsx b/src/web/hooks/use-query/__tests__/Tags.test.tsx
index 62210e9faf..48e7fb76eb 100644
--- a/src/web/hooks/use-query/__tests__/Tags.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Tags.test.tsx
@@ -12,14 +12,7 @@ import {createSession} from 'gmp/testing';
 import {
   useBulkDeleteTags,
   useBulkExportTags,
-  useCloneTag,
-  useCreateTag,
-  useDeleteTag,
-  useDisableTag,
-  useEnableTag,
-  useGetTag,
   useGetTags,
-  useSaveTag,
 } from 'web/hooks/use-query/tags';
 
 const filter = QueryFilter.fromString('name~tag');
@@ -41,98 +34,67 @@ const createGmp = () => ({
     export: testing.fn().mockResolvedValue({data: 'tags'}),
     exportByFilter: testing.fn().mockResolvedValue({data: 'tags'}),
   },
-  tag: {
-    get: testing.fn().mockResolvedValue({data: tag}),
-    delete: testing.fn().mockResolvedValue(undefined),
-    enable: testing.fn().mockResolvedValue({data: {}}),
-    disable: testing.fn().mockResolvedValue({data: {}}),
-    create: testing.fn().mockResolvedValue({data: {id: 'tag-2'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'tag-1'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'tag-2'}}),
-  },
 });
 
-describe('tag query and mutation hooks', () => {
-  test('should fetch tags and a tag by ID', async () => {
+describe('useGetTags', () => {
+  test('should fetch tags with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const tags = useGetTags({filter});
-      const singleTag = useGetTag({id: 'tag-1'});
-      return (
-        <div data-testid="tags">
-          {tags.data?.entities.length}:{singleTag.data?.name}
-        </div>
-      );
+      const {data} = useGetTags({filter});
+      return <div data-testid="tags">{data?.entities.length}</div>;
     };
 
     render(<TestComponent />);
-
     await waitFor(() => {
-      expect(screen.getByTestId('tags')).toHaveTextContent('1:Tag 1');
+      expect(screen.getByTestId('tags')).toHaveTextContent('1');
     });
-
     expect(gmp.tags.get).toHaveBeenCalledWith({filter});
-    expect(gmp.tag.get).toHaveBeenCalledWith({id: 'tag-1'});
   });
+});
 
-  test.each([
-    ['delete', useDeleteTag, 'delete', {id: 'tag-1'}],
-    ['enable', useEnableTag, 'enable', {id: 'tag-1'}],
-    ['disable', useDisableTag, 'disable', {id: 'tag-1'}],
-    ['create', useCreateTag, 'create', {name: 'New Tag', value: 'value'}],
-    ['save', useSaveTag, 'save', {id: 'tag-1', name: 'Saved Tag'}],
-    ['clone', useCloneTag, 'clone', {id: 'tag-1'}],
-  ])('should %s a tag', async (_name, useMutation, method, input) => {
+describe('useBulkDeleteTags', () => {
+  test('should bulk delete tags by list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const mutation = useMutation({});
+      const mutation = useBulkDeleteTags({});
       return (
-        <button onClick={() => mutation.mutate(input as never)}>Run</button>
+        <>
+          <button onClick={() => mutation.mutate([tag])}>Delete</button>
+          <button onClick={() => mutation.mutate(filter)}>Delete filter</button>
+        </>
       );
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
-
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Delete filter'}));
     await waitFor(() => {
-      expect(gmp.tag[method]).toHaveBeenCalledWith(input);
+      expect(gmp.tags.delete).toHaveBeenCalledWith([tag]);
+      expect(gmp.tags.deleteByFilter).toHaveBeenCalledWith(filter);
     });
   });
+});
 
-  test('should bulk delete and export tags by list and filter', async () => {
+describe('useBulkExportTags', () => {
+  test('should bulk export tags by list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const deleteMutation = useBulkDeleteTags({});
-      const exportMutation = useBulkExportTags({});
+      const mutation = useBulkExportTags({});
       return (
         <>
-          <button onClick={() => deleteMutation.mutate([tag])}>Delete</button>
-          <button onClick={() => deleteMutation.mutate(filter)}>
-            Delete filter
-          </button>
-          <button onClick={() => exportMutation.mutate([tag])}>Export</button>
-          <button onClick={() => exportMutation.mutate(filter)}>
-            Export filter
-          </button>
+          <button onClick={() => mutation.mutate([tag])}>Export</button>
+          <button onClick={() => mutation.mutate(filter)}>Export filter</button>
         </>
       );
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Delete filter'}));
     fireEvent.click(screen.getByRole('button', {name: 'Export'}));
     fireEvent.click(screen.getByRole('button', {name: 'Export filter'}));
-
     await waitFor(() => {
-      expect(gmp.tags.delete).toHaveBeenCalledWith([tag]);
-      expect(gmp.tags.deleteByFilter).toHaveBeenCalledWith(filter);
       expect(gmp.tags.export).toHaveBeenCalledWith([tag]);
       expect(gmp.tags.exportByFilter).toHaveBeenCalledWith(filter);
     });
diff --git a/src/web/hooks/use-query/tag.ts b/src/web/hooks/use-query/tag.ts
new file mode 100644
index 0000000000..129a76037e
--- /dev/null
+++ b/src/web/hooks/use-query/tag.ts
@@ -0,0 +1,134 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionResponse} from 'gmp/commands/entity';
+import type Rejection from 'gmp/http/rejection';
+import type Response from 'gmp/http/response';
+import {type XmlMeta, type XmlResponseData} from 'gmp/http/transform/fast-xml';
+import type Tag from 'gmp/models/tag';
+import useGmp from 'web/hooks/useGmp';
+import {type RefetchIntervalFn} from 'web/queries/helpers';
+import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
+import useGetEntity from 'web/queries/useGetEntity';
+import useGmpMutation from 'web/queries/useGmpMutation';
+import useSaveMutation from 'web/queries/useSaveMutation';
+
+interface UseGetTagParams {
+  id: string;
+  refetchInterval?: RefetchIntervalFn<Tag>;
+}
+
+interface UseMutationCallbacks {
+  onSuccess?: () => void;
+  onError?: (error: Rejection) => void;
+}
+
+interface UseCreateTagParams {
+  onSuccess?: (data: EntityActionResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseModifyTagParams {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export const useGetTag = ({id, refetchInterval}: UseGetTagParams) => {
+  const gmp = useGmp();
+  return useGetEntity<Tag>({
+    gmpMethod: gmp.tag.get.bind(gmp.tag),
+    queryId: 'get_tag',
+    id,
+    refetchInterval,
+  });
+};
+
+export const useDeleteTag = ({onError, onSuccess}: UseMutationCallbacks) => {
+  const gmp = useGmp();
+  return useDeleteMutation({
+    entityType: 'tag',
+    gmpMethod: ({id}) => gmp.tag.delete({id}),
+    invalidateQueryIds: ['get_tags'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useEnableTag = ({
+  onError,
+  onSuccess,
+}: UseMutationCallbacks = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<
+    {id: string},
+    Response<XmlResponseData, XmlMeta>,
+    Rejection
+  >({
+    gmpMethod: ({id}) => gmp.tag.enable({id}),
+    invalidateQueryIds: ['get_tags'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDisableTag = ({
+  onError,
+  onSuccess,
+}: UseMutationCallbacks = {}) => {
+  const gmp = useGmp();
+  return useGmpMutation<
+    {id: string},
+    Response<XmlResponseData, XmlMeta>,
+    Rejection
+  >({
+    gmpMethod: ({id}) => gmp.tag.disable({id}),
+    invalidateQueryIds: ['get_tags'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCreateTag = ({onSuccess, onError}: UseCreateTagParams) => {
+  const gmp = useGmp();
+  return useCreateMutation<
+    Parameters<typeof gmp.tag.create>[0],
+    EntityActionResponse,
+    Rejection
+  >({
+    entityType: 'tag',
+    gmpMethod: input => gmp.tag.create(input),
+    invalidateQueryIds: ['get_tags'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useSaveTag = ({onError, onSuccess}: UseModifyTagParams) => {
+  const gmp = useGmp();
+  return useSaveMutation<
+    Parameters<typeof gmp.tag.save>[0],
+    EntityActionResponse,
+    Rejection
+  >({
+    entityType: 'tag',
+    gmpMethod: input => gmp.tag.save(input),
+    invalidateQueryIds: ['get_tags'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useCloneTag = ({onSuccess, onError}: UseCreateTagParams) => {
+  const gmp = useGmp();
+  return useCloneMutation<EntityActionResponse, Rejection>({
+    entityType: 'tag',
+    gmpMethod: ({id}) => gmp.tag.clone({id}),
+    invalidateQueryIds: ['get_tags'],
+    onError,
+    onSuccess,
+  });
+};
diff --git a/src/web/hooks/use-query/tags.ts b/src/web/hooks/use-query/tags.ts
index aae64e8be8..5f783247a1 100644
--- a/src/web/hooks/use-query/tags.ts
+++ b/src/web/hooks/use-query/tags.ts
@@ -3,27 +3,15 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionResponse} from 'gmp/commands/entity';
 import type Rejection from 'gmp/http/rejection';
 import type Response from 'gmp/http/response';
-import {type XmlMeta, type XmlResponseData} from 'gmp/http/transform/fast-xml';
+import {type XmlMeta} from 'gmp/http/transform/fast-xml';
 import {type FilterType} from 'gmp/models/filter';
 import {isFilterType} from 'gmp/models/filter/utils';
 import type Tag from 'gmp/models/tag';
 import useGmp from 'web/hooks/useGmp';
-import {type RefetchIntervalFn} from 'web/queries/helpers';
-import useCloneMutation from 'web/queries/useCloneMutation';
-import useCreateMutation from 'web/queries/useCreateMutation';
-import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntities from 'web/queries/useGetEntities';
-import useGetEntity from 'web/queries/useGetEntity';
 import useGmpMutation from 'web/queries/useGmpMutation';
-import useSaveMutation from 'web/queries/useSaveMutation';
-
-interface UseGetTagParams {
-  id: string;
-  refetchInterval?: RefetchIntervalFn<Tag>;
-}
 
 interface UseGetTagsParams {
   filter?: FilterType;
@@ -34,16 +22,6 @@ interface UseMutationCallbacks {
   onError?: (error: Rejection) => void;
 }
 
-interface UseCreateTagParams {
-  onSuccess?: (data: EntityActionResponse) => void;
-  onError?: (error: Error) => void;
-}
-
-interface UseModifyTagParams {
-  onSuccess?: () => void;
-  onError?: (error: Error) => void;
-}
-
 type TagBulkInput = Tag[] | FilterType;
 
 export const useGetTags = ({filter}: UseGetTagsParams) => {
@@ -55,61 +33,6 @@ export const useGetTags = ({filter}: UseGetTagsParams) => {
   });
 };
 
-export const useGetTag = ({id, refetchInterval}: UseGetTagParams) => {
-  const gmp = useGmp();
-  return useGetEntity<Tag>({
-    gmpMethod: gmp.tag.get.bind(gmp.tag),
-    queryId: 'get_tag',
-    id,
-    refetchInterval,
-  });
-};
-
-export const useDeleteTag = ({onError, onSuccess}: UseMutationCallbacks) => {
-  const gmp = useGmp();
-  return useDeleteMutation({
-    entityType: 'tag',
-    gmpMethod: ({id}) => gmp.tag.delete({id}),
-    invalidateQueryIds: ['get_tags'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useEnableTag = ({
-  onError,
-  onSuccess,
-}: UseMutationCallbacks = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<
-    {id: string},
-    Response<XmlResponseData, XmlMeta>,
-    Rejection
-  >({
-    gmpMethod: ({id}) => gmp.tag.enable({id}),
-    invalidateQueryIds: ['get_tags'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useDisableTag = ({
-  onError,
-  onSuccess,
-}: UseMutationCallbacks = {}) => {
-  const gmp = useGmp();
-  return useGmpMutation<
-    {id: string},
-    Response<XmlResponseData, XmlMeta>,
-    Rejection
-  >({
-    gmpMethod: ({id}) => gmp.tag.disable({id}),
-    invalidateQueryIds: ['get_tags'],
-    onSuccess,
-    onError,
-  });
-};
-
 export const useBulkDeleteTags = ({
   onError,
   onSuccess,
@@ -142,44 +65,3 @@ export const useBulkExportTags = ({
     onError,
   });
 };
-
-export const useCreateTag = ({onSuccess, onError}: UseCreateTagParams) => {
-  const gmp = useGmp();
-  return useCreateMutation<
-    Parameters<typeof gmp.tag.create>[0],
-    EntityActionResponse,
-    Rejection
-  >({
-    entityType: 'tag',
-    gmpMethod: input => gmp.tag.create(input),
-    invalidateQueryIds: ['get_tags'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useSaveTag = ({onError, onSuccess}: UseModifyTagParams) => {
-  const gmp = useGmp();
-  return useSaveMutation<
-    Parameters<typeof gmp.tag.save>[0],
-    EntityActionResponse,
-    Rejection
-  >({
-    entityType: 'tag',
-    gmpMethod: input => gmp.tag.save(input),
-    invalidateQueryIds: ['get_tags'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useCloneTag = ({onSuccess, onError}: UseCreateTagParams) => {
-  const gmp = useGmp();
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    entityType: 'tag',
-    gmpMethod: ({id}) => gmp.tag.clone({id}),
-    invalidateQueryIds: ['get_tags'],
-    onError,
-    onSuccess,
-  });
-};
diff --git a/src/web/pages/tags/TagComponent.tsx b/src/web/pages/tags/TagComponent.tsx
index 02bd50fc27..8cde0d55c5 100644
--- a/src/web/pages/tags/TagComponent.tsx
+++ b/src/web/pages/tags/TagComponent.tsx
@@ -29,7 +29,7 @@ import {
   useDisableTag,
   useEnableTag,
   useSaveTag,
-} from 'web/hooks/use-query/tags';
+} from 'web/hooks/use-query/tag';
 import useCapabilities from 'web/hooks/useCapabilities';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
diff --git a/src/web/pages/tags/TagDetailsPage.tsx b/src/web/pages/tags/TagDetailsPage.tsx
index e53d536734..410f1727dc 100644
--- a/src/web/pages/tags/TagDetailsPage.tsx
+++ b/src/web/pages/tags/TagDetailsPage.tsx
@@ -35,7 +35,7 @@ import EditIcon from 'web/entity/icon/EditIcon';
 import TrashIcon from 'web/entity/icon/TrashIcon';
 import {goToDetails, goToList} from 'web/entity/navigation';
 import {useGetPermissions} from 'web/hooks/use-query/permissions';
-import {useGetTag} from 'web/hooks/use-query/tags';
+import {useGetTag} from 'web/hooks/use-query/tag';
 import useCapabilities from 'web/hooks/useCapabilities';
 import useTranslation from 'web/hooks/useTranslation';
 import TagComponent from 'web/pages/tags/TagComponent';

From da6d9ffd074ab3d79a881f0c96c3ce2d151ea32f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 08:05:33 +0200
Subject: [PATCH 25/36] Change: Split agent query hooks into two modules

One for agent and one for agents queries.
---
 .../hooks/use-query/__tests__/Agent.test.tsx  |  97 +++++++++
 .../hooks/use-query/__tests__/Agents.test.tsx | 195 +++++++-----------
 src/web/hooks/use-query/agent.ts              |  88 ++++++++
 src/web/hooks/use-query/agents.ts             |  75 +------
 src/web/pages/agents/AgentComponent.tsx       |   2 +-
 src/web/pages/agents/AgentListPage.tsx        |   2 +-
 6 files changed, 265 insertions(+), 194 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Agent.test.tsx
 create mode 100644 src/web/hooks/use-query/agent.ts

diff --git a/src/web/hooks/use-query/__tests__/Agent.test.tsx b/src/web/hooks/use-query/__tests__/Agent.test.tsx
new file mode 100644
index 0000000000..f291cb5346
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Agent.test.tsx
@@ -0,0 +1,97 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {createSession} from 'gmp/testing';
+import {
+  useDeleteAgent,
+  useDownloadAgentSupportBundle,
+  useModifyAgent,
+} from 'web/hooks/use-query/agent';
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  agent: {
+    save: testing.fn().mockResolvedValue(undefined),
+    delete: testing.fn().mockResolvedValue(undefined),
+    downloadSupportBundle: testing
+      .fn()
+      .mockResolvedValue({data: new ArrayBuffer(0)}),
+  },
+});
+
+describe('useModifyAgent', () => {
+  test('should save an agent', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {agentsIds: ['agent-1'], authorized: true};
+    const TestComponent = () => {
+      const mutation = useModifyAgent();
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+    await waitFor(() => {
+      expect(gmp.agent.save.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useDeleteAgent', () => {
+  test('should delete an agent', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDeleteAgent({});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({
+              id: 'agent-1',
+              name: 'Deleted Agent',
+            })
+          }
+        >
+          Delete
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+    await waitFor(() => {
+      expect(gmp.agent.delete).toHaveBeenCalledWith({id: 'agent-1'});
+    });
+  });
+});
+
+describe('useDownloadAgentSupportBundle', () => {
+  test('should download an agent support bundle', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useDownloadAgentSupportBundle();
+      return (
+        <button
+          onClick={() => mutation.mutate({id: 'agent-1', encryption: false})}
+        >
+          Download
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
+    await waitFor(() => {
+      expect(gmp.agent.downloadSupportBundle).toHaveBeenCalledWith(
+        'agent-1',
+        false,
+      );
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Agents.test.tsx b/src/web/hooks/use-query/__tests__/Agents.test.tsx
index eb2eeeec71..f58c8366a6 100644
--- a/src/web/hooks/use-query/__tests__/Agents.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Agents.test.tsx
@@ -14,10 +14,7 @@ import {
   useBulkDisableUpdateToLatestAgents,
   useBulkEnableUpdateToLatestAgents,
   useBulkRevokeAgents,
-  useDeleteAgent,
-  useDownloadAgentSupportBundle,
   useGetAgents,
-  useModifyAgent,
   useSyncAgents,
 } from 'web/hooks/use-query/agents';
 
@@ -96,183 +93,145 @@ describe('useGetAgents', () => {
   });
 });
 
-describe('useModifyAgent', () => {
-  test('should save an agent', async () => {
+describe('useBulkDeleteAgents', () => {
+  test('should delete agents by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      const mutation = useModifyAgent();
+      const mutation = useBulkDeleteAgents({});
       return (
-        <button
-          onClick={() =>
-            mutation.mutate({
-              agentsIds: ['agent-1'],
-              authorized: true,
-            })
-          }
-        >
-          Save
-        </button>
+        <>
+          <button onClick={() => mutation.mutate([agent])}>
+            Delete agents
+          </button>
+          <button onClick={() => mutation.mutate(filter)}>Delete filter</button>
+        </>
       );
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Delete agents'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Delete filter'}));
 
     await waitFor(() => {
-      expect(gmp.agent.save.mock.calls[0][0]).toEqual({
-        agentsIds: ['agent-1'],
-        authorized: true,
-      });
+      expect(gmp.agents.delete).toHaveBeenCalledWith([agent]);
+      expect(gmp.agents.deleteByFilter).toHaveBeenCalledWith(filter);
     });
   });
 });
 
-describe('useDeleteAgent', () => {
-  test('should delete an agent', async () => {
+describe('useBulkAuthorizeAgents', () => {
+  test('should authorize agents by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const mutation = useDeleteAgent({});
+      const mutation = useBulkAuthorizeAgents({});
       return (
-        <button
-          onClick={() =>
-            mutation.mutate({id: 'agent-1', name: 'Deleted Agent'})
-          }
-        >
-          Delete
-        </button>
+        <>
+          <button onClick={() => mutation.mutate([agent])}>Entities</button>
+          <button onClick={() => mutation.mutate(filter)}>Filter</button>
+        </>
       );
     };
-
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-
+    fireEvent.click(screen.getByRole('button', {name: 'Entities'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Filter'}));
     await waitFor(() => {
-      expect(gmp.agent.delete).toHaveBeenCalledWith({
-        id: 'agent-1',
-      });
+      expect(gmp.agents.authorize).toHaveBeenCalledWith([agent]);
+      expect(gmp.agents.authorizeByFilter).toHaveBeenCalledWith(filter);
     });
   });
 });
 
-describe('useBulkDeleteAgents', () => {
-  test('should delete agents by entity list and filter', async () => {
+describe('useBulkRevokeAgents', () => {
+  test('should revoke agents by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const mutation = useBulkDeleteAgents({});
+      const mutation = useBulkRevokeAgents({});
       return (
         <>
-          <button onClick={() => mutation.mutate([agent])}>
-            Delete agents
-          </button>
-          <button onClick={() => mutation.mutate(filter)}>Delete filter</button>
+          <button onClick={() => mutation.mutate([agent])}>Entities</button>
+          <button onClick={() => mutation.mutate(filter)}>Filter</button>
         </>
       );
     };
-
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Delete agents'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Delete filter'}));
-
+    fireEvent.click(screen.getByRole('button', {name: 'Entities'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Filter'}));
     await waitFor(() => {
-      expect(gmp.agents.delete).toHaveBeenCalledWith([agent]);
-      expect(gmp.agents.deleteByFilter).toHaveBeenCalledWith(filter);
+      expect(gmp.agents.revoke).toHaveBeenCalledWith([agent]);
+      expect(gmp.agents.revokeByFilter).toHaveBeenCalledWith(filter);
     });
   });
 });
 
-describe('bulk agent mutation hooks', () => {
-  test.each([
-    ['authorize', useBulkAuthorizeAgents, 'authorize', 'authorizeByFilter'],
-    ['revoke', useBulkRevokeAgents, 'revoke', 'revokeByFilter'],
-    [
-      'enable update to latest',
-      useBulkEnableUpdateToLatestAgents,
-      'enableUpdateToLatest',
-      'enableUpdateToLatestByFilter',
-    ],
-    [
-      'disable update to latest',
-      useBulkDisableUpdateToLatestAgents,
-      'disableUpdateToLatest',
-      'disableUpdateToLatestByFilter',
-    ],
-  ])(
-    'should %s agents by entity list and filter',
-    async (_name, useMutation, entityMethod, filterMethod) => {
-      const gmp = createGmp();
-      const {render} = rendererWith({gmp, router: true});
-
-      const TestComponent = () => {
-        const mutation = useMutation({});
-        return (
-          <>
-            <button onClick={() => mutation.mutate([agent])}>Entities</button>
-            <button onClick={() => mutation.mutate(filter)}>Filter</button>
-          </>
-        );
-      };
-
-      render(<TestComponent />);
-      fireEvent.click(screen.getByRole('button', {name: 'Entities'}));
-      fireEvent.click(screen.getByRole('button', {name: 'Filter'}));
-
-      await waitFor(() => {
-        expect(gmp.agents[entityMethod]).toHaveBeenCalledWith([agent]);
-        expect(gmp.agents[filterMethod]).toHaveBeenCalledWith(filter);
-      });
-    },
-  );
+describe('useBulkEnableUpdateToLatestAgents', () => {
+  test('should enable automatic updates by entity list and filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const mutation = useBulkEnableUpdateToLatestAgents({});
+      return (
+        <>
+          <button onClick={() => mutation.mutate([agent])}>Entities</button>
+          <button onClick={() => mutation.mutate(filter)}>Filter</button>
+        </>
+      );
+    };
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Entities'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Filter'}));
+    await waitFor(() => {
+      expect(gmp.agents.enableUpdateToLatest).toHaveBeenCalledWith([agent]);
+      expect(gmp.agents.enableUpdateToLatestByFilter).toHaveBeenCalledWith(
+        filter,
+      );
+    });
+  });
 });
 
-describe('useSyncAgents', () => {
-  test('should sync agents', async () => {
+describe('useBulkDisableUpdateToLatestAgents', () => {
+  test('should disable automatic updates by entity list and filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
     const TestComponent = () => {
-      const mutation = useSyncAgents();
-      return <button onClick={() => mutation.mutate()}>Sync</button>;
+      const mutation = useBulkDisableUpdateToLatestAgents({});
+      return (
+        <>
+          <button onClick={() => mutation.mutate([agent])}>Entities</button>
+          <button onClick={() => mutation.mutate(filter)}>Filter</button>
+        </>
+      );
     };
-
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Sync'}));
-
+    fireEvent.click(screen.getByRole('button', {name: 'Entities'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Filter'}));
     await waitFor(() => {
-      expect(gmp.agents.sync).toHaveBeenCalledWith();
+      expect(gmp.agents.disableUpdateToLatest).toHaveBeenCalledWith([agent]);
+      expect(gmp.agents.disableUpdateToLatestByFilter).toHaveBeenCalledWith(
+        filter,
+      );
     });
   });
 });
 
-describe('useDownloadAgentSupportBundle', () => {
-  test('should download an agent support bundle', async () => {
+describe('useSyncAgents', () => {
+  test('should sync agents', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
 
     const TestComponent = () => {
-      const mutation = useDownloadAgentSupportBundle();
-      return (
-        <button
-          onClick={() => mutation.mutate({id: 'agent-1', encryption: false})}
-        >
-          Download
-        </button>
-      );
+      const mutation = useSyncAgents();
+      return <button onClick={() => mutation.mutate()}>Sync</button>;
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Download'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Sync'}));
 
     await waitFor(() => {
-      expect(gmp.agent.downloadSupportBundle).toHaveBeenCalledWith(
-        'agent-1',
-        false,
-      );
+      expect(gmp.agents.sync).toHaveBeenCalledWith();
     });
   });
 });
diff --git a/src/web/hooks/use-query/agent.ts b/src/web/hooks/use-query/agent.ts
new file mode 100644
index 0000000000..c08dcd62d7
--- /dev/null
+++ b/src/web/hooks/use-query/agent.ts
@@ -0,0 +1,88 @@
+/* SPDX-FileCopyrightText: 2025 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {useQueryClient} from '@tanstack/react-query';
+import {type AgentModifyParams} from 'gmp/commands/agent';
+import type Rejection from 'gmp/http/rejection';
+import type Response from 'gmp/http/response';
+import {isArray} from 'gmp/utils/identity';
+import useGmp from 'web/hooks/useGmp';
+import useDeleteMutation from 'web/queries/useDeleteMutation';
+import useGmpMutation from 'web/queries/useGmpMutation';
+import useSaveMutation from 'web/queries/useSaveMutation';
+
+interface UseModifyAgentParams {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseDownloadAgentSupportBundleParams {
+  onSuccess?: (response: Response<ArrayBuffer>) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface DownloadAgentSupportBundleInput {
+  id: string;
+  encryption?: boolean;
+}
+
+export const useModifyAgent = ({
+  onError,
+  onSuccess,
+}: UseModifyAgentParams = {}) => {
+  const queryClient = useQueryClient();
+  const gmp = useGmp();
+
+  const invalidateAgents = () =>
+    queryClient.invalidateQueries({
+      predicate: q => {
+        const key = q.queryKey as unknown as string[];
+        return (
+          key?.includes?.('get_agents') ||
+          (isArray(key) && key[0] === 'get_entities' && key.includes('agent'))
+        );
+      },
+    });
+
+  return useSaveMutation<AgentModifyParams, void, Rejection>({
+    entityType: 'agent',
+    gmpMethod: gmp.agent.save.bind(gmp.agent),
+    invalidateQueryIds: ['get_agents'],
+    onSuccess: async () => {
+      await invalidateAgents();
+      onSuccess?.();
+    },
+    onError,
+  });
+};
+
+export const useDeleteAgent = ({onError, onSuccess}: UseModifyAgentParams) => {
+  const gmp = useGmp();
+  return useDeleteMutation({
+    gmpMethod: ({id}) => gmp.agent.delete({id}),
+    entityType: 'agent',
+    invalidateQueryIds: ['get_agents'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useDownloadAgentSupportBundle = ({
+  onSuccess,
+  onError,
+}: UseDownloadAgentSupportBundleParams = {}) => {
+  const gmp = useGmp();
+
+  return useGmpMutation<
+    DownloadAgentSupportBundleInput,
+    Response<ArrayBuffer>,
+    Rejection
+  >({
+    gmpMethod: ({id, encryption}) =>
+      gmp.agent.downloadSupportBundle(id, encryption),
+    onSuccess,
+    onError,
+  });
+};
diff --git a/src/web/hooks/use-query/agents.ts b/src/web/hooks/use-query/agents.ts
index 40abab4dd3..0365ecc09e 100644
--- a/src/web/hooks/use-query/agents.ts
+++ b/src/web/hooks/use-query/agents.ts
@@ -3,8 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {useQueryClient} from '@tanstack/react-query';
-import {type AgentModifyParams} from 'gmp/commands/agent';
 import type Rejection from 'gmp/http/rejection';
 import type Response from 'gmp/http/response';
 import {type XmlMeta} from 'gmp/http/transform/fast-xml';
@@ -13,13 +11,11 @@ import type FilterType from 'gmp/models/filter/filter-type';
 import QueryFilter from 'gmp/models/filter/query-filter';
 import {isFilterType} from 'gmp/models/filter/utils';
 import {parseYesNo} from 'gmp/parser';
-import {isArray, isDefined} from 'gmp/utils/identity';
+import {isDefined} from 'gmp/utils/identity';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
-import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useGetEntities from 'web/queries/useGetEntities';
 import useGmpMutation from 'web/queries/useGmpMutation';
-import useSaveMutation from 'web/queries/useSaveMutation';
 
 interface UseGetAgentsParams {
   filter?: FilterType;
@@ -35,16 +31,6 @@ interface UseModifyAgentParams {
 
 type AgentBulkInput = Agent[] | FilterType;
 
-interface UseDownloadAgentSupportBundleParams {
-  onSuccess?: (response: Response<ArrayBuffer>) => void;
-  onError?: (error: Error) => void;
-}
-
-export interface DownloadAgentSupportBundleInput {
-  id: string;
-  encryption?: boolean;
-}
-
 export const useGetAgents = ({
   filter,
   scannerId,
@@ -75,47 +61,6 @@ export const useGetAgents = ({
   });
 };
 
-export const useModifyAgent = ({
-  onError,
-  onSuccess,
-}: UseModifyAgentParams = {}) => {
-  const queryClient = useQueryClient();
-  const gmp = useGmp();
-
-  const invalidateAgents = () =>
-    queryClient.invalidateQueries({
-      predicate: q => {
-        const key = q.queryKey as unknown as string[];
-        return (
-          key?.includes?.('get_agents') ||
-          (isArray(key) && key[0] === 'get_entities' && key.includes('agent'))
-        );
-      },
-    });
-
-  return useSaveMutation<AgentModifyParams, void, Rejection>({
-    entityType: 'agent',
-    gmpMethod: gmp.agent.save.bind(gmp.agent),
-    invalidateQueryIds: ['get_agents'],
-    onSuccess: async () => {
-      await invalidateAgents();
-      onSuccess?.();
-    },
-    onError,
-  });
-};
-
-export const useDeleteAgent = ({onError, onSuccess}: UseModifyAgentParams) => {
-  const gmp = useGmp();
-  return useDeleteMutation({
-    gmpMethod: ({id}) => gmp.agent.delete({id}),
-    entityType: 'agent',
-    invalidateQueryIds: ['get_agents'],
-    onSuccess,
-    onError,
-  });
-};
-
 export const useBulkDeleteAgents = ({
   onError,
   onSuccess,
@@ -229,21 +174,3 @@ export const useBulkDisableUpdateToLatestAgents = ({
     onError,
   });
 };
-
-export const useDownloadAgentSupportBundle = ({
-  onSuccess,
-  onError,
-}: UseDownloadAgentSupportBundleParams = {}) => {
-  const gmp = useGmp();
-
-  return useGmpMutation<
-    DownloadAgentSupportBundleInput,
-    Response<ArrayBuffer>,
-    Rejection
-  >({
-    gmpMethod: ({id, encryption}) =>
-      gmp.agent.downloadSupportBundle(id, encryption),
-    onSuccess,
-    onError,
-  });
-};
diff --git a/src/web/pages/agents/AgentComponent.tsx b/src/web/pages/agents/AgentComponent.tsx
index c0a642440a..55b780df42 100644
--- a/src/web/pages/agents/AgentComponent.tsx
+++ b/src/web/pages/agents/AgentComponent.tsx
@@ -5,7 +5,7 @@
 
 import React, {useState} from 'react';
 import type Agent from 'gmp/models/agent';
-import {useDeleteAgent, useModifyAgent} from 'web/hooks/use-query/agents';
+import {useDeleteAgent, useModifyAgent} from 'web/hooks/use-query/agent';
 import useTranslation from 'web/hooks/useTranslation';
 import AgentDialog, {type AgentDialogState} from 'web/pages/agents/AgentDialog';
 
diff --git a/src/web/pages/agents/AgentListPage.tsx b/src/web/pages/agents/AgentListPage.tsx
index 1b08d19aec..a2f0abc892 100644
--- a/src/web/pages/agents/AgentListPage.tsx
+++ b/src/web/pages/agents/AgentListPage.tsx
@@ -21,10 +21,10 @@ import DialogNotification from 'web/components/notification/DialogNotification';
 import useDialogNotification from 'web/components/notification/useDialogNotification';
 import BulkTags from 'web/entities/BulkTags';
 import EntitiesPage from 'web/entities/EntitiesPage';
+import {useDownloadAgentSupportBundle} from 'web/hooks/use-query/agent';
 import {
   useBulkAuthorizeAgents,
   useBulkDeleteAgents,
-  useDownloadAgentSupportBundle,
   useBulkDisableUpdateToLatestAgents,
   useBulkEnableUpdateToLatestAgents,
   useBulkRevokeAgents,

From 1fb4be5d73a8399cde88f419a31ca55d92449060 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 08:08:25 +0200
Subject: [PATCH 26/36] Change: Split audit query hooks into two modules

---
 .../hooks/use-query/__tests__/Audit.test.tsx  | 87 +++++++++++++++++++
 .../hooks/use-query/__tests__/Audits.test.tsx | 77 +---------------
 src/web/hooks/use-query/audit.ts              | 24 +++++
 src/web/hooks/use-query/audits.ts             | 17 ----
 src/web/pages/audits/DetailsPage.tsx          |  2 +-
 5 files changed, 113 insertions(+), 94 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Audit.test.tsx
 create mode 100644 src/web/hooks/use-query/audit.ts

diff --git a/src/web/hooks/use-query/__tests__/Audit.test.tsx b/src/web/hooks/use-query/__tests__/Audit.test.tsx
new file mode 100644
index 0000000000..d7a3cd6130
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Audit.test.tsx
@@ -0,0 +1,87 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, test, expect, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import Audit, {AUDIT_STATUS} from 'gmp/models/audit';
+import {createSession} from 'gmp/testing';
+import {useGetAudit} from 'web/hooks/use-query/audit';
+
+const audit = Audit.fromElement({
+  _id: 'audit-1',
+  name: 'Test Audit',
+  status: AUDIT_STATUS.done,
+  usage_type: 'audit',
+  permissions: {permission: [{name: 'everything'}]},
+});
+
+const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
+  audit: {
+    get: testing.fn().mockResolvedValue({data: audit}),
+  },
+  session: createSession({token}),
+  settings: {},
+});
+
+const SingleAuditComponent = ({id}: {id: string}) => {
+  const {data, isLoading, isError} = useGetAudit({id});
+
+  if (isLoading) return <div data-testid="loading">Loading...</div>;
+  if (isError) return <div data-testid="error">Error</div>;
+  if (!data) return <div data-testid="no-data">No data</div>;
+
+  return (
+    <div data-testid="audit">
+      <span data-testid="audit-name">{data.name}</span>
+      <span data-testid="audit-id">{data.id}</span>
+    </div>
+  );
+};
+
+describe('useGetAudit', () => {
+  test('should fetch a single audit', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleAuditComponent id="audit-1" />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('audit-name')).toHaveTextContent('Test Audit');
+    });
+    expect(gmp.audit.get).toHaveBeenCalledWith({id: 'audit-1'});
+    expect(screen.getByTestId('audit-id')).toHaveTextContent('audit-1');
+  });
+
+  test('should show loading state initially', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleAuditComponent id="audit-1" />);
+    expect(screen.getByTestId('loading')).toBeInTheDocument();
+  });
+
+  test('should not fetch an audit when the ID is empty', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleAuditComponent id="" />);
+    expect(screen.getByTestId('no-data')).toBeInTheDocument();
+    expect(gmp.audit.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch an audit without a session token', () => {
+    const gmp = createGmp({token: undefined});
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleAuditComponent id="audit-1" />);
+    expect(gmp.audit.get).not.toHaveBeenCalled();
+  });
+
+  test('should show an error when fetching an audit fails', async () => {
+    const gmp = createGmp();
+    gmp.audit.get.mockRejectedValue(new Error('Request failed'));
+    const {render} = rendererWith({gmp, router: true});
+    render(<SingleAuditComponent id="audit-1" />);
+    await waitFor(() => {
+      expect(screen.getByTestId('error')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/Audits.test.tsx b/src/web/hooks/use-query/__tests__/Audits.test.tsx
index 0b1d5c0615..2cb1556731 100644
--- a/src/web/hooks/use-query/__tests__/Audits.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Audits.test.tsx
@@ -10,7 +10,7 @@ import Audit, {AUDIT_STATUS} from 'gmp/models/audit';
 import type FilterType from 'gmp/models/filter/filter-type';
 import QueryFilter from 'gmp/models/filter/query-filter';
 import {createSession} from 'gmp/testing';
-import {useGetAudit, useGetAudits} from 'web/hooks/use-query/audits';
+import {useGetAudits} from 'web/hooks/use-query/audits';
 
 const audit = Audit.fromElement({
   _id: 'audit-1',
@@ -30,27 +30,6 @@ const audit2 = Audit.fromElement({
 
 const filter = QueryFilter.fromString('name~test');
 
-const SingleAuditComponent = ({id}: {id: string}) => {
-  const {data, isLoading, isError} = useGetAudit({id});
-
-  if (isLoading) {
-    return <div data-testid="loading">Loading...</div>;
-  }
-  if (isError) {
-    return <div data-testid="error">Error</div>;
-  }
-  if (!data) {
-    return <div data-testid="no-data">No data</div>;
-  }
-
-  return (
-    <div data-testid="audit">
-      <span data-testid="audit-name">{data.name}</span>
-      <span data-testid="audit-id">{data.id}</span>
-    </div>
-  );
-};
-
 const AuditListComponent = ({filter}: {filter?: FilterType}) => {
   const {data, isLoading, isError} = useGetAudits(
     filter ? {filter} : undefined,
@@ -95,60 +74,6 @@ const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
   settings: {},
 });
 
-describe('useGetAudit', () => {
-  test('should fetch a single audit', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SingleAuditComponent id="audit-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('audit-name')).toHaveTextContent('Test Audit');
-    });
-
-    expect(gmp.audit.get).toHaveBeenCalledWith({id: 'audit-1'});
-    expect(screen.getByTestId('audit-id')).toHaveTextContent('audit-1');
-  });
-
-  test('should show loading state initially', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SingleAuditComponent id="audit-1" />);
-
-    expect(screen.getByTestId('loading')).toBeInTheDocument();
-  });
-
-  test('should not fetch an audit when the ID is empty', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleAuditComponent id="" />);
-
-    expect(screen.getByTestId('no-data')).toBeInTheDocument();
-    expect(gmp.audit.get).not.toHaveBeenCalled();
-  });
-
-  test('should not fetch an audit without a session token', () => {
-    const gmp = createGmp({token: undefined});
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleAuditComponent id="audit-1" />);
-
-    expect(gmp.audit.get).not.toHaveBeenCalled();
-  });
-
-  test('should show an error when fetching an audit fails', async () => {
-    const gmp = createGmp();
-    gmp.audit.get.mockRejectedValue(new Error('Request failed'));
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SingleAuditComponent id="audit-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('error')).toBeInTheDocument();
-    });
-  });
-});
-
 describe('useGetAudits', () => {
   test('should fetch a list of audits', async () => {
     const gmp = createGmp();
diff --git a/src/web/hooks/use-query/audit.ts b/src/web/hooks/use-query/audit.ts
new file mode 100644
index 0000000000..e190402d06
--- /dev/null
+++ b/src/web/hooks/use-query/audit.ts
@@ -0,0 +1,24 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type Audit from 'gmp/models/audit';
+import useGmp from 'web/hooks/useGmp';
+import {type RefetchIntervalFn} from 'web/queries/helpers';
+import useGetEntity from 'web/queries/useGetEntity';
+
+interface UseGetAuditParams {
+  id: string;
+  refetchInterval?: RefetchIntervalFn<Audit>;
+}
+
+export const useGetAudit = ({id, refetchInterval}: UseGetAuditParams) => {
+  const gmp = useGmp();
+  return useGetEntity<Audit>({
+    gmpMethod: gmp.audit.get.bind(gmp.audit),
+    queryId: 'get_audit',
+    id,
+    refetchInterval,
+  });
+};
diff --git a/src/web/hooks/use-query/audits.ts b/src/web/hooks/use-query/audits.ts
index 1cabb9b8d9..47bfd1002f 100644
--- a/src/web/hooks/use-query/audits.ts
+++ b/src/web/hooks/use-query/audits.ts
@@ -6,29 +6,12 @@
 import type Audit from 'gmp/models/audit';
 import {type FilterType} from 'gmp/models/filter';
 import useGmp from 'web/hooks/useGmp';
-import {type RefetchIntervalFn} from 'web/queries/helpers';
 import useGetEntities from 'web/queries/useGetEntities';
-import useGetEntity from 'web/queries/useGetEntity';
-
-interface UseGetAuditParams {
-  id: string;
-  refetchInterval?: RefetchIntervalFn<Audit>;
-}
 
 interface UseGetAuditsParams {
   filter?: FilterType;
 }
 
-export const useGetAudit = ({id, refetchInterval}: UseGetAuditParams) => {
-  const gmp = useGmp();
-  return useGetEntity<Audit>({
-    gmpMethod: gmp.audit.get.bind(gmp.audit),
-    queryId: 'get_audit',
-    id,
-    refetchInterval,
-  });
-};
-
 export const useGetAudits = ({filter}: UseGetAuditsParams = {}) => {
   const gmp = useGmp();
   return useGetEntities<Audit>({
diff --git a/src/web/pages/audits/DetailsPage.tsx b/src/web/pages/audits/DetailsPage.tsx
index 24d1a61f0a..c0a369828e 100644
--- a/src/web/pages/audits/DetailsPage.tsx
+++ b/src/web/pages/audits/DetailsPage.tsx
@@ -36,7 +36,7 @@ import EntityPermissions, {
 } from 'web/entity/EntityPermissions';
 import {goToDetails, goToList} from 'web/entity/navigation';
 import EntityTags from 'web/entity/Tags';
-import {useGetAudit} from 'web/hooks/use-query/audits';
+import {useGetAudit} from 'web/hooks/use-query/audit';
 import {useGetPermissions} from 'web/hooks/use-query/permissions';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';

From 3d8bfc5103380cb30329d9d2bbc1e23de2ce7e91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 08:11:09 +0200
Subject: [PATCH 27/36] Change: Split credential store query hooks into two
 modules

---
 .../__tests__/CredentialStore.test.tsx        | 74 ++++++-------------
 .../__tests__/CredentialStores.test.tsx       | 46 ++++++++++++
 src/web/hooks/use-query/credential-store.ts   | 12 ---
 src/web/hooks/use-query/credential-stores.ts  | 18 +++++
 .../credential-store/CredentialStorePage.tsx  |  2 +-
 5 files changed, 88 insertions(+), 64 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/CredentialStores.test.tsx
 create mode 100644 src/web/hooks/use-query/credential-stores.ts

diff --git a/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx b/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
index 3524029504..6825af84d2 100644
--- a/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
+++ b/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
@@ -5,81 +5,53 @@
 
 import {describe, expect, test, testing} from '@gsa/testing';
 import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
-import CollectionCounts from 'gmp/collection/collection-counts';
-import QueryFilter from 'gmp/models/filter/query-filter';
 import {createSession} from 'gmp/testing';
 import {
   useEditCredentialStore,
-  useGetCredentialStores,
   useVerifyCredentialStore,
 } from 'web/hooks/use-query/credential-store';
 
-const filter = QueryFilter.fromString('name~credential');
-
 const createGmp = () => ({
   session: createSession({token: 'test-token'}),
   settings: {},
-  credentialstores: {
-    get: testing.fn().mockResolvedValue({
-      data: [{id: 'credential-1', name: 'Credential 1'}],
-      meta: {
-        filter,
-        counts: new CollectionCounts({all: 1, filtered: 1, length: 1}),
-      },
-    }),
-  },
   credentialstore: {
     edit: testing.fn().mockResolvedValue({data: {id: 'credential-1'}}),
     verify: testing.fn().mockResolvedValue({data: {id: 'credential-1'}}),
   },
 });
 
-describe('credential store query hooks', () => {
-  test('should fetch credential stores with a filter', async () => {
+describe('useEditCredentialStore', () => {
+  test('should edit a credential store', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-
+    const input = {id: 'credential-1', active: true};
     const TestComponent = () => {
-      const {data} = useGetCredentialStores({filter});
-      return <div data-testid="credential">{data?.entities[0]?.name}</div>;
+      const mutation = useEditCredentialStore({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
     };
 
     render(<TestComponent />);
-
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
     await waitFor(() => {
-      expect(screen.getByTestId('credential')).toHaveTextContent(
-        'Credential 1',
-      );
+      expect(gmp.credentialstore.edit.mock.calls[0][0]).toEqual(input);
     });
-
-    expect(gmp.credentialstores.get).toHaveBeenCalledWith({filter});
   });
+});
 
-  test.each([
-    [
-      'edit',
-      useEditCredentialStore,
-      'edit',
-      {id: 'credential-1', active: true},
-    ],
-    ['verify', useVerifyCredentialStore, 'verify', {id: 'credential-1'}],
-  ])(
-    'should %s a credential store',
-    async (_name, useMutation, method, input) => {
-      const gmp = createGmp();
-      const {render} = rendererWith({gmp, router: true});
-
-      const TestComponent = () => {
-        const mutation = useMutation({});
-        return <button onClick={() => mutation.mutate(input)}>Run</button>;
-      };
-
-      render(<TestComponent />);
-      fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+describe('useVerifyCredentialStore', () => {
+  test('should verify a credential store', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: 'credential-1'};
+    const TestComponent = () => {
+      const mutation = useVerifyCredentialStore({});
+      return <button onClick={() => mutation.mutate(input)}>Run</button>;
+    };
 
-      await waitFor(() => {
-        expect(gmp.credentialstore[method].mock.calls[0][0]).toEqual(input);
-      });
-    },
-  );
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Run'}));
+    await waitFor(() => {
+      expect(gmp.credentialstore.verify.mock.calls[0][0]).toEqual(input);
+    });
+  });
 });
diff --git a/src/web/hooks/use-query/__tests__/CredentialStores.test.tsx b/src/web/hooks/use-query/__tests__/CredentialStores.test.tsx
new file mode 100644
index 0000000000..a7a70ffd82
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/CredentialStores.test.tsx
@@ -0,0 +1,46 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import CollectionCounts from 'gmp/collection/collection-counts';
+import QueryFilter from 'gmp/models/filter/query-filter';
+import {createSession} from 'gmp/testing';
+import {useGetCredentialStores} from 'web/hooks/use-query/credential-stores';
+
+const filter = QueryFilter.fromString('name~credential');
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  credentialstores: {
+    get: testing.fn().mockResolvedValue({
+      data: [{id: 'credential-1', name: 'Credential 1'}],
+      meta: {
+        filter,
+        counts: new CollectionCounts({all: 1, filtered: 1, length: 1}),
+      },
+    }),
+  },
+});
+
+describe('useGetCredentialStores', () => {
+  test('should fetch credential stores with a filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const TestComponent = () => {
+      const {data} = useGetCredentialStores({filter});
+      return <div data-testid="credential">{data?.entities[0]?.name}</div>;
+    };
+
+    render(<TestComponent />);
+    await waitFor(() => {
+      expect(screen.getByTestId('credential')).toHaveTextContent(
+        'Credential 1',
+      );
+    });
+    expect(gmp.credentialstores.get).toHaveBeenCalledWith({filter});
+  });
+});
diff --git a/src/web/hooks/use-query/credential-store.ts b/src/web/hooks/use-query/credential-store.ts
index 8d6511b8f8..b3165a1fec 100644
--- a/src/web/hooks/use-query/credential-store.ts
+++ b/src/web/hooks/use-query/credential-store.ts
@@ -6,10 +6,7 @@
 import {type CredentialStoreModifyParams} from 'gmp/commands/credential-store';
 import {type EntityActionResponse} from 'gmp/commands/entity';
 import type Rejection from 'gmp/http/rejection';
-import type CredentialStore from 'gmp/models/credential-store';
-import {type FilterType} from 'gmp/models/filter';
 import useGmp from 'web/hooks/useGmp';
-import useGetEntities from 'web/queries/useGetEntities';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
 interface UseEditCredentialStoreParams {
@@ -22,15 +19,6 @@ interface UseVerifyCredentialStoreParams {
   onError?: (error: Error) => void;
 }
 
-export const useGetCredentialStores = ({filter}: {filter?: FilterType}) => {
-  const gmp = useGmp();
-  return useGetEntities<CredentialStore>({
-    queryId: 'get_credential_stores',
-    filter,
-    gmpMethod: gmp.credentialstores.get.bind(gmp.credentialstores),
-  });
-};
-
 export const useEditCredentialStore = ({
   onError,
   onSuccess,
diff --git a/src/web/hooks/use-query/credential-stores.ts b/src/web/hooks/use-query/credential-stores.ts
new file mode 100644
index 0000000000..35929c11cf
--- /dev/null
+++ b/src/web/hooks/use-query/credential-stores.ts
@@ -0,0 +1,18 @@
+/* SPDX-FileCopyrightText: 2025 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type CredentialStore from 'gmp/models/credential-store';
+import {type FilterType} from 'gmp/models/filter';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntities from 'web/queries/useGetEntities';
+
+export const useGetCredentialStores = ({filter}: {filter?: FilterType}) => {
+  const gmp = useGmp();
+  return useGetEntities<CredentialStore>({
+    queryId: 'get_credential_stores',
+    filter,
+    gmpMethod: gmp.credentialstores.get.bind(gmp.credentialstores),
+  });
+};
diff --git a/src/web/pages/credential-store/CredentialStorePage.tsx b/src/web/pages/credential-store/CredentialStorePage.tsx
index b9c42d2f02..a21bf17ec5 100644
--- a/src/web/pages/credential-store/CredentialStorePage.tsx
+++ b/src/web/pages/credential-store/CredentialStorePage.tsx
@@ -22,10 +22,10 @@ import TableCol from 'web/components/table/TableCol';
 import TableData from 'web/components/table/TableData';
 import TableRow from 'web/components/table/TableRow';
 import {
-  useGetCredentialStores,
   useEditCredentialStore,
   useVerifyCredentialStore,
 } from 'web/hooks/use-query/credential-store';
+import {useGetCredentialStores} from 'web/hooks/use-query/credential-stores';
 import useTranslation from 'web/hooks/useTranslation';
 import ConnectionStatusPill from 'web/pages/credential-store/ConnectionStatusPill';
 import CredentialStoreDialog, {

From b7eb6f0f1e604c396b41959229c1ddb4a5942525 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 08:21:38 +0200
Subject: [PATCH 28/36] Change: Split oci image target query hooks into two
 modules

---
 .../__tests__/OciImageTarget.test.tsx         | 115 ++++++++++++++++++
 .../__tests__/OciImageTargets.test.tsx        |  81 +++++-------
 src/web/hooks/use-query/oci-image-target.ts   |  94 ++++++++++++++
 src/web/hooks/use-query/oci-image-targets.ts  |  84 +------------
 .../ContainerImageTargetsComponent.tsx        |   2 +-
 5 files changed, 239 insertions(+), 137 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/OciImageTarget.test.tsx
 create mode 100644 src/web/hooks/use-query/oci-image-target.ts

diff --git a/src/web/hooks/use-query/__tests__/OciImageTarget.test.tsx b/src/web/hooks/use-query/__tests__/OciImageTarget.test.tsx
new file mode 100644
index 0000000000..2cee468c76
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/OciImageTarget.test.tsx
@@ -0,0 +1,115 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneOciImageTarget,
+  useCreateOciImageTarget,
+  useDeleteOciImageTarget,
+  useSaveOciImageTarget,
+} from 'web/hooks/use-query/oci-image-target';
+
+const target = {id: 'target-1', name: 'Target 1'};
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  ociimagetarget: {
+    create: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'target-1'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    clone: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
+  },
+});
+
+describe('useCreateOciImageTarget', () => {
+  test('should create an OCI image target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {name: 'New Target', imageReferences: 'registry/image'};
+
+    const TestComponent = () => {
+      const mutation = useCreateOciImageTarget({});
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.ociimagetarget.create.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useSaveOciImageTarget', () => {
+  test('should save an OCI image target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: target.id, name: 'Saved'};
+
+    const TestComponent = () => {
+      const mutation = useSaveOciImageTarget({});
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => {
+      expect(gmp.ociimagetarget.save.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useDeleteOciImageTarget', () => {
+  test('should delete an OCI image target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteOciImageTarget({});
+      return (
+        <button onClick={() => mutation.mutate({id: target.id})}>Delete</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.ociimagetarget.delete).toHaveBeenCalledWith({id: target.id});
+    });
+  });
+});
+
+describe('useCloneOciImageTarget', () => {
+  test('should clone an OCI image target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCloneOciImageTarget({});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: target.id, name: 'Cloned Target'})
+          }
+        >
+          Clone
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.ociimagetarget.clone).toHaveBeenCalledWith({id: target.id});
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx b/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
index a71a6b734b..228a472104 100644
--- a/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
+++ b/src/web/hooks/use-query/__tests__/OciImageTargets.test.tsx
@@ -11,11 +11,7 @@ import {createSession} from 'gmp/testing';
 import {
   useBulkDeleteOciImageTargets,
   useBulkExportOciImageTargets,
-  useCloneOciImageTarget,
-  useCreateOciImageTarget,
-  useDeleteOciImageTarget,
   useGetOciImageTargets,
-  useSaveOciImageTarget,
 } from 'web/hooks/use-query/oci-image-targets';
 
 const filter = QueryFilter.fromString('name~target');
@@ -37,15 +33,9 @@ const createGmp = () => ({
     export: testing.fn().mockResolvedValue({data: 'targets'}),
     exportByFilter: testing.fn().mockResolvedValue({data: 'targets'}),
   },
-  ociimagetarget: {
-    create: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'target-1'}}),
-    delete: testing.fn().mockResolvedValue(undefined),
-    clone: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
-  },
 });
 
-describe('OCI image target query hooks', () => {
+describe('useGetOciImageTargets', () => {
   test('should fetch OCI image targets with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -63,62 +53,47 @@ describe('OCI image target query hooks', () => {
 
     expect(gmp.ociimagetargets.get).toHaveBeenCalledWith({filter});
   });
+});
 
-  test('should forward OCI image target mutations', async () => {
+describe('useBulkDeleteOciImageTargets', () => {
+  test('should delete OCI image targets', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-    const input = {name: 'New Target', imageReferences: 'registry/image'};
 
     const TestComponent = () => {
-      const create = useCreateOciImageTarget({});
-      const save = useSaveOciImageTarget({});
-      const remove = useDeleteOciImageTarget({});
-      const clone = useCloneOciImageTarget({});
-      const bulkDelete = useBulkDeleteOciImageTargets({});
-      const bulkExport = useBulkExportOciImageTargets({});
+      const mutation = useBulkDeleteOciImageTargets({});
       return (
-        <>
-          <button onClick={() => create.mutate(input)}>Create</button>
-          <button onClick={() => save.mutate({id: 'target-1', name: 'Saved'})}>
-            Save
-          </button>
-          <button onClick={() => remove.mutate({id: 'target-1'})}>
-            Delete
-          </button>
-          <button
-            onClick={() =>
-              clone.mutate({id: 'target-1', name: 'Cloned Target'})
-            }
-          >
-            Clone
-          </button>
-          <button onClick={() => bulkDelete.mutate([target] as never)}>
-            Bulk delete
-          </button>
-          <button onClick={() => bulkExport.mutate(filter as never)}>
-            Bulk export
-          </button>
-        </>
+        <button onClick={() => mutation.mutate([target] as never)}>
+          Delete
+        </button>
       );
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Bulk delete'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Bulk export'}));
 
     await waitFor(() => {
-      expect(gmp.ociimagetarget.create.mock.calls[0][0]).toEqual(input);
-      expect(gmp.ociimagetarget.save.mock.calls[0][0]).toEqual({
-        id: 'target-1',
-        name: 'Saved',
-      });
-      expect(gmp.ociimagetarget.delete).toHaveBeenCalledWith({id: 'target-1'});
-      expect(gmp.ociimagetarget.clone).toHaveBeenCalledWith({id: 'target-1'});
       expect(gmp.ociimagetargets.delete).toHaveBeenCalledWith([target]);
+    });
+  });
+});
+
+describe('useBulkExportOciImageTargets', () => {
+  test('should export OCI image targets by filter', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useBulkExportOciImageTargets({});
+      return (
+        <button onClick={() => mutation.mutate(filter as never)}>Export</button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Export'}));
+
+    await waitFor(() => {
       expect(gmp.ociimagetargets.exportByFilter).toHaveBeenCalledWith(filter);
     });
   });
diff --git a/src/web/hooks/use-query/oci-image-target.ts b/src/web/hooks/use-query/oci-image-target.ts
new file mode 100644
index 0000000000..2da580c09a
--- /dev/null
+++ b/src/web/hooks/use-query/oci-image-target.ts
@@ -0,0 +1,94 @@
+/* SPDX-FileCopyrightText: 2025 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionResponse} from 'gmp/commands/entity';
+import {
+  type OciImageTargetCreateParams,
+  type OciImageTargetSaveParams,
+} from 'gmp/commands/oci-image-target';
+import type Rejection from 'gmp/http/rejection';
+import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
+import useMoveToTrashCan from 'web/queries/useMoveToTrashCan';
+import useSaveMutation from 'web/queries/useSaveMutation';
+
+interface UseCreateOciImageTargetParams {
+  onSuccess?: (data: EntityActionResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseModifyOciImageTargetParams {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export const useCreateOciImageTarget = ({
+  onSuccess,
+  onError,
+}: UseCreateOciImageTargetParams) => {
+  const gmp = useGmp();
+
+  return useCreateMutation<
+    OciImageTargetCreateParams,
+    EntityActionResponse,
+    Rejection
+  >({
+    gmpMethod: gmp.ociimagetarget.create.bind(gmp.ociimagetarget),
+    entityType: 'ociimagetarget',
+    invalidateQueryIds: ['get_oci_image_targets'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useSaveOciImageTarget = ({
+  onError,
+  onSuccess,
+}: UseModifyOciImageTargetParams) => {
+  const gmp = useGmp();
+
+  return useSaveMutation<
+    OciImageTargetSaveParams,
+    EntityActionResponse,
+    Rejection
+  >({
+    gmpMethod: gmp.ociimagetarget.save.bind(gmp.ociimagetarget),
+    entityType: 'ociimagetarget',
+    invalidateQueryIds: ['get_oci_image_targets'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useDeleteOciImageTarget = ({
+  onError,
+  onSuccess,
+}: UseModifyOciImageTargetParams) => {
+  const gmp = useGmp();
+
+  return useMoveToTrashCan({
+    gmpMethod: ({id}) => gmp.ociimagetarget.delete({id}),
+    entityType: 'ociimagetarget',
+    invalidateQueryIds: ['get_oci_image_targets'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCloneOciImageTarget = ({
+  onError,
+  onSuccess,
+}: UseCreateOciImageTargetParams) => {
+  const gmp = useGmp();
+
+  return useCloneMutation<EntityActionResponse, Rejection>({
+    gmpMethod: ({id}) => gmp.ociimagetarget.clone({id}),
+    entityType: 'ociimagetarget',
+    invalidateQueryIds: ['get_oci_image_targets'],
+    onError,
+    onSuccess,
+  });
+};
diff --git a/src/web/hooks/use-query/oci-image-targets.ts b/src/web/hooks/use-query/oci-image-targets.ts
index 4eaf715536..cefd233408 100644
--- a/src/web/hooks/use-query/oci-image-targets.ts
+++ b/src/web/hooks/use-query/oci-image-targets.ts
@@ -3,11 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionResponse} from 'gmp/commands/entity';
-import {
-  type OciImageTargetCreateParams,
-  type OciImageTargetSaveParams,
-} from 'gmp/commands/oci-image-target';
 import type Rejection from 'gmp/http/rejection';
 import type Response from 'gmp/http/response';
 import {type XmlMeta} from 'gmp/http/transform/fast-xml';
@@ -16,23 +11,14 @@ import {isFilterType} from 'gmp/models/filter/utils';
 import type OciImageTarget from 'gmp/models/oci-image-target';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
-import useCloneMutation from 'web/queries/useCloneMutation';
-import useCreateMutation from 'web/queries/useCreateMutation';
 import useGetEntities from 'web/queries/useGetEntities';
 import useGmpMutation from 'web/queries/useGmpMutation';
-import useMoveToTrashCan from 'web/queries/useMoveToTrashCan';
-import useSaveMutation from 'web/queries/useSaveMutation';
 
 type OciImageTargetBulkInput = OciImageTarget[] | FilterType;
 
-interface UseCreateOciImageTargetParams {
-  onSuccess?: (data: EntityActionResponse) => void;
-  onError?: (error: Error) => void;
-}
-
 interface UseModifyOciImageTargetParams {
-  onSuccess?: () => void;
   onError?: (error: Error) => void;
+  onSuccess?: () => void;
 }
 
 export const useGetOciImageTargets = ({filter}: {filter?: FilterType}) => {
@@ -45,74 +31,6 @@ export const useGetOciImageTargets = ({filter}: {filter?: FilterType}) => {
   });
 };
 
-export const useCreateOciImageTarget = ({
-  onSuccess,
-  onError,
-}: UseCreateOciImageTargetParams) => {
-  const gmp = useGmp();
-
-  return useCreateMutation<
-    OciImageTargetCreateParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.ociimagetarget.create.bind(gmp.ociimagetarget),
-    entityType: 'ociimagetarget',
-    invalidateQueryIds: ['get_oci_image_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useSaveOciImageTarget = ({
-  onError,
-  onSuccess,
-}: UseModifyOciImageTargetParams) => {
-  const gmp = useGmp();
-
-  return useSaveMutation<
-    OciImageTargetSaveParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.ociimagetarget.save.bind(gmp.ociimagetarget),
-    entityType: 'ociimagetarget',
-    invalidateQueryIds: ['get_oci_image_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useDeleteOciImageTarget = ({
-  onError,
-  onSuccess,
-}: UseModifyOciImageTargetParams) => {
-  const gmp = useGmp();
-
-  return useMoveToTrashCan({
-    gmpMethod: gmp.ociimagetarget.delete.bind(gmp.ociimagetarget),
-    entityType: 'ociimagetarget',
-    invalidateQueryIds: ['get_oci_image_targets'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useCloneOciImageTarget = ({
-  onError,
-  onSuccess,
-}: UseCreateOciImageTargetParams) => {
-  const gmp = useGmp();
-
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    gmpMethod: gmp.ociimagetarget.clone.bind(gmp.ociimagetarget),
-    entityType: 'ociimagetarget',
-    invalidateQueryIds: ['get_oci_image_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
 export const useBulkDeleteOciImageTargets = ({
   onError,
   onSuccess,
diff --git a/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx b/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
index ae8be1986e..80832d5bde 100644
--- a/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
+++ b/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
@@ -22,7 +22,7 @@ import {
   useCreateOciImageTarget,
   useDeleteOciImageTarget,
   useSaveOciImageTarget,
-} from 'web/hooks/use-query/oci-image-targets';
+} from 'web/hooks/use-query/oci-image-target';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
 import ContainerImageTargetsDialog, {

From 83481a7a5314d7bc28dfe01f4b184b4174e1a67f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 08:24:28 +0200
Subject: [PATCH 29/36] Change: Split policy query hooks into two modules

---
 .../use-query/__tests__/Policies.test.tsx     |  82 +-------------
 .../hooks/use-query/__tests__/Policy.test.tsx | 104 ++++++++++++++++++
 src/web/hooks/use-query/policies.ts           |  14 ---
 src/web/hooks/use-query/policy.ts             |  21 ++++
 src/web/pages/policies/DetailsPage.tsx        |   2 +-
 5 files changed, 127 insertions(+), 96 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/Policy.test.tsx
 create mode 100644 src/web/hooks/use-query/policy.ts

diff --git a/src/web/hooks/use-query/__tests__/Policies.test.tsx b/src/web/hooks/use-query/__tests__/Policies.test.tsx
index 1824575b71..0b0f960071 100644
--- a/src/web/hooks/use-query/__tests__/Policies.test.tsx
+++ b/src/web/hooks/use-query/__tests__/Policies.test.tsx
@@ -10,7 +10,7 @@ import type FilterType from 'gmp/models/filter/filter-type';
 import QueryFilter from 'gmp/models/filter/query-filter';
 import Policy from 'gmp/models/policy';
 import {createSession} from 'gmp/testing';
-import {useGetPolicy, useGetPolicies} from 'web/hooks/use-query/policies';
+import {useGetPolicies} from 'web/hooks/use-query/policies';
 
 const policy = Policy.fromElement({
   _id: 'policy-1',
@@ -32,27 +32,6 @@ const policy2 = Policy.fromElement({
 
 const filter = QueryFilter.fromString('name~test');
 
-const SinglePolicyComponent = ({id}: {id: string}) => {
-  const {data, isLoading, isError} = useGetPolicy({id});
-
-  if (isLoading) {
-    return <div data-testid="loading">Loading...</div>;
-  }
-  if (isError) {
-    return <div data-testid="error">Error</div>;
-  }
-  if (!data) {
-    return <div data-testid="no-data">No data</div>;
-  }
-
-  return (
-    <div data-testid="policy">
-      <span data-testid="policy-name">{data.name}</span>
-      <span data-testid="policy-id">{data.id}</span>
-    </div>
-  );
-};
-
 const PolicyListComponent = ({filter}: {filter?: FilterType}) => {
   const {data, isLoading, isError} = useGetPolicies(
     filter ? {filter} : undefined,
@@ -82,9 +61,6 @@ const PolicyListComponent = ({filter}: {filter?: FilterType}) => {
 const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
   session: createSession({token}),
   settings: {},
-  policy: {
-    get: testing.fn().mockResolvedValue({data: policy}),
-  },
   policies: {
     get: testing.fn().mockResolvedValue({
       data: [policy, policy2],
@@ -96,62 +72,6 @@ const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
   },
 });
 
-describe('useGetPolicy', () => {
-  test('should fetch a single policy', async () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SinglePolicyComponent id="policy-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('policy-name')).toHaveTextContent(
-        'Test Policy',
-      );
-    });
-
-    expect(gmp.policy.get).toHaveBeenCalledWith({id: 'policy-1'});
-    expect(screen.getByTestId('policy-id')).toHaveTextContent('policy-1');
-  });
-
-  test('should show loading state initially', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-    render(<SinglePolicyComponent id="policy-1" />);
-
-    expect(screen.getByTestId('loading')).toBeInTheDocument();
-  });
-
-  test('should not fetch a policy when the ID is empty', () => {
-    const gmp = createGmp();
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SinglePolicyComponent id="" />);
-
-    expect(screen.getByTestId('no-data')).toBeInTheDocument();
-    expect(gmp.policy.get).not.toHaveBeenCalled();
-  });
-
-  test('should not fetch a policy without a session token', () => {
-    const gmp = createGmp({token: undefined});
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SinglePolicyComponent id="policy-1" />);
-
-    expect(gmp.policy.get).not.toHaveBeenCalled();
-  });
-
-  test('should show an error when fetching a policy fails', async () => {
-    const gmp = createGmp();
-    gmp.policy.get.mockRejectedValue(new Error('Request failed'));
-    const {render} = rendererWith({gmp, router: true});
-
-    render(<SinglePolicyComponent id="policy-1" />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId('error')).toBeInTheDocument();
-    });
-  });
-});
-
 describe('useGetPolicies', () => {
   test('should fetch a list of policies', async () => {
     const gmp = createGmp();
diff --git a/src/web/hooks/use-query/__tests__/Policy.test.tsx b/src/web/hooks/use-query/__tests__/Policy.test.tsx
new file mode 100644
index 0000000000..9bbda42e0d
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/Policy.test.tsx
@@ -0,0 +1,104 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {rendererWith, screen, waitFor} from 'web/testing';
+import Policy from 'gmp/models/policy';
+import {createSession} from 'gmp/testing';
+import {useGetPolicy} from 'web/hooks/use-query/policy';
+
+const policy = Policy.fromElement({
+  _id: 'policy-1',
+  name: 'Test Policy',
+  comment: 'A test policy',
+  creation_time: '2019-07-16T06:31:29Z',
+  modification_time: '2019-07-16T06:44:55Z',
+  permissions: {permission: [{name: 'everything'}]},
+});
+
+const SinglePolicyComponent = ({id}: {id: string}) => {
+  const {data, isLoading, isError} = useGetPolicy({id});
+
+  if (isLoading) {
+    return <div data-testid="loading">Loading...</div>;
+  }
+  if (isError) {
+    return <div data-testid="error">Error</div>;
+  }
+  if (!data) {
+    return <div data-testid="no-data">No data</div>;
+  }
+
+  return (
+    <div data-testid="policy">
+      <span data-testid="policy-name">{data.name}</span>
+      <span data-testid="policy-id">{data.id}</span>
+    </div>
+  );
+};
+
+const createGmp = ({token}: {token?: string} = {token: 'test-token'}) => ({
+  session: createSession({token}),
+  settings: {},
+  policy: {
+    get: testing.fn().mockResolvedValue({data: policy}),
+  },
+});
+
+describe('useGetPolicy', () => {
+  test('should fetch a single policy', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SinglePolicyComponent id="policy-1" />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('policy-name')).toHaveTextContent(
+        'Test Policy',
+      );
+    });
+
+    expect(gmp.policy.get).toHaveBeenCalledWith({id: 'policy-1'});
+    expect(screen.getByTestId('policy-id')).toHaveTextContent('policy-1');
+  });
+
+  test('should show loading state initially', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    render(<SinglePolicyComponent id="policy-1" />);
+
+    expect(screen.getByTestId('loading')).toBeInTheDocument();
+  });
+
+  test('should not fetch a policy when the ID is empty', () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SinglePolicyComponent id="" />);
+
+    expect(screen.getByTestId('no-data')).toBeInTheDocument();
+    expect(gmp.policy.get).not.toHaveBeenCalled();
+  });
+
+  test('should not fetch a policy without a session token', () => {
+    const gmp = createGmp({token: undefined});
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SinglePolicyComponent id="policy-1" />);
+
+    expect(gmp.policy.get).not.toHaveBeenCalled();
+  });
+
+  test('should show an error when fetching a policy fails', async () => {
+    const gmp = createGmp();
+    gmp.policy.get.mockRejectedValue(new Error('Request failed'));
+    const {render} = rendererWith({gmp, router: true});
+
+    render(<SinglePolicyComponent id="policy-1" />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('error')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/policies.ts b/src/web/hooks/use-query/policies.ts
index b4330279f4..d1ad063a96 100644
--- a/src/web/hooks/use-query/policies.ts
+++ b/src/web/hooks/use-query/policies.ts
@@ -7,25 +7,11 @@ import {type FilterType} from 'gmp/models/filter';
 import type Policy from 'gmp/models/policy';
 import useGmp from 'web/hooks/useGmp';
 import useGetEntities from 'web/queries/useGetEntities';
-import useGetEntity from 'web/queries/useGetEntity';
-
-interface UseGetPolicyParams {
-  id: string;
-}
 
 interface UseGetPoliciesParams {
   filter?: FilterType;
 }
 
-export const useGetPolicy = ({id}: UseGetPolicyParams) => {
-  const gmp = useGmp();
-  return useGetEntity<Policy>({
-    gmpMethod: gmp.policy.get.bind(gmp.policy),
-    queryId: 'get_policy',
-    id,
-  });
-};
-
 export const useGetPolicies = ({filter}: UseGetPoliciesParams = {}) => {
   const gmp = useGmp();
   return useGetEntities<Policy>({
diff --git a/src/web/hooks/use-query/policy.ts b/src/web/hooks/use-query/policy.ts
new file mode 100644
index 0000000000..ee472bd0ed
--- /dev/null
+++ b/src/web/hooks/use-query/policy.ts
@@ -0,0 +1,21 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type Policy from 'gmp/models/policy';
+import useGmp from 'web/hooks/useGmp';
+import useGetEntity from 'web/queries/useGetEntity';
+
+interface UseGetPolicyParams {
+  id: string;
+}
+
+export const useGetPolicy = ({id}: UseGetPolicyParams) => {
+  const gmp = useGmp();
+  return useGetEntity<Policy>({
+    gmpMethod: gmp.policy.get.bind(gmp.policy),
+    queryId: 'get_policy',
+    id,
+  });
+};
diff --git a/src/web/pages/policies/DetailsPage.tsx b/src/web/pages/policies/DetailsPage.tsx
index 685e169bca..94e9e2c275 100644
--- a/src/web/pages/policies/DetailsPage.tsx
+++ b/src/web/pages/policies/DetailsPage.tsx
@@ -27,7 +27,7 @@ import EntityPermissions from 'web/entity/EntityPermissions';
 import {goToDetails, goToList} from 'web/entity/navigation';
 import EntityTags from 'web/entity/Tags';
 import {useGetPermissions} from 'web/hooks/use-query/permissions';
-import {useGetPolicy} from 'web/hooks/use-query/policies';
+import {useGetPolicy} from 'web/hooks/use-query/policy';
 import useTranslation from 'web/hooks/useTranslation';
 import PolicyDetails from 'web/pages/policies/Details';
 import PolicyComponent from 'web/pages/policies/PoliciesComponent';

From 140beb4780d36a7cfe95ff121257cabc9ec54719 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 09:14:06 +0200
Subject: [PATCH 30/36] Change: Split web application target query hooks into
 two modules

---
 .../__tests__/WebApplicationTarget.test.tsx   | 117 ++++++++++++++++++
 .../__tests__/WebApplicationTargets.test.tsx  |  87 +++++--------
 .../hooks/use-query/web-application-target.ts |  93 ++++++++++++++
 .../use-query/web-application-targets.ts      |  82 ------------
 src/web/pages/tasks/TaskComponent.tsx         |   4 +-
 .../WebApplicationTargetsComponent.tsx        |   8 +-
 6 files changed, 243 insertions(+), 148 deletions(-)
 create mode 100644 src/web/hooks/use-query/__tests__/WebApplicationTarget.test.tsx
 create mode 100644 src/web/hooks/use-query/web-application-target.ts

diff --git a/src/web/hooks/use-query/__tests__/WebApplicationTarget.test.tsx b/src/web/hooks/use-query/__tests__/WebApplicationTarget.test.tsx
new file mode 100644
index 0000000000..2e7e241ff1
--- /dev/null
+++ b/src/web/hooks/use-query/__tests__/WebApplicationTarget.test.tsx
@@ -0,0 +1,117 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, expect, test, testing} from '@gsa/testing';
+import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import {createSession} from 'gmp/testing';
+import {
+  useCloneWebApplicationTarget,
+  useCreateWebApplicationTarget,
+  useDeleteWebApplicationTarget,
+  useSaveWebApplicationTarget,
+} from 'web/hooks/use-query/web-application-target';
+
+const target = {id: 'target-1', name: 'Target 1'};
+
+const createGmp = () => ({
+  session: createSession({token: 'test-token'}),
+  settings: {},
+  webapplicationtarget: {
+    create: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
+    save: testing.fn().mockResolvedValue({data: {id: 'target-1'}}),
+    delete: testing.fn().mockResolvedValue(undefined),
+    clone: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
+  },
+});
+
+describe('useCreateWebApplicationTarget', () => {
+  test('should create a web application target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {name: 'New Target', urls: 'https://example.com'};
+
+    const TestComponent = () => {
+      const mutation = useCreateWebApplicationTarget({});
+      return <button onClick={() => mutation.mutate(input)}>Create</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
+
+    await waitFor(() => {
+      expect(gmp.webapplicationtarget.create.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useSaveWebApplicationTarget', () => {
+  test('should save a web application target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+    const input = {id: target.id, name: 'Saved'};
+
+    const TestComponent = () => {
+      const mutation = useSaveWebApplicationTarget({});
+      return <button onClick={() => mutation.mutate(input)}>Save</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
+
+    await waitFor(() => {
+      expect(gmp.webapplicationtarget.save.mock.calls[0][0]).toEqual(input);
+    });
+  });
+});
+
+describe('useDeleteWebApplicationTarget', () => {
+  test('should delete a web application target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useDeleteWebApplicationTarget({});
+      return <button onClick={() => mutation.mutate(target)}>Delete</button>;
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
+
+    await waitFor(() => {
+      expect(gmp.webapplicationtarget.delete).toHaveBeenCalledWith({
+        id: target.id,
+      });
+    });
+  });
+});
+
+describe('useCloneWebApplicationTarget', () => {
+  test('should clone a web application target', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useCloneWebApplicationTarget({});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({id: target.id, name: 'Cloned Target'})
+          }
+        >
+          Clone
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
+
+    await waitFor(() => {
+      expect(gmp.webapplicationtarget.clone).toHaveBeenCalledWith({
+        id: target.id,
+      });
+    });
+  });
+});
diff --git a/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx b/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
index cec43e70ed..69290f57a8 100644
--- a/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
+++ b/src/web/hooks/use-query/__tests__/WebApplicationTargets.test.tsx
@@ -11,11 +11,7 @@ import {createSession} from 'gmp/testing';
 import {
   useBulkDeleteWebApplicationTargets,
   useBulkExportWebApplicationTargets,
-  useCloneWebApplicationTarget,
-  useCreateWebApplicationTarget,
-  useDeleteWebApplicationTarget,
   useGetWebApplicationTargets,
-  useSaveWebApplicationTarget,
 } from 'web/hooks/use-query/web-application-targets';
 
 const filter = QueryFilter.fromString('name~target');
@@ -37,15 +33,9 @@ const createGmp = () => ({
     export: testing.fn().mockResolvedValue({data: 'targets'}),
     exportByFilter: testing.fn().mockResolvedValue({data: 'targets'}),
   },
-  webapplicationtarget: {
-    create: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'target-1'}}),
-    delete: testing.fn().mockResolvedValue(undefined),
-    clone: testing.fn().mockResolvedValue({data: {id: 'target-2'}}),
-  },
 });
 
-describe('web application target query hooks', () => {
+describe('useGetWebApplicationTargets', () => {
   test('should fetch web application targets with a filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
@@ -63,70 +53,49 @@ describe('web application target query hooks', () => {
 
     expect(gmp.webapplicationtargets.get).toHaveBeenCalledWith({filter});
   });
+});
 
-  test('should forward web application target mutations', async () => {
+describe('useBulkDeleteWebApplicationTargets', () => {
+  test('should delete web application targets by filter', async () => {
     const gmp = createGmp();
     const {render} = rendererWith({gmp, router: true});
-    const input = {name: 'New Target', urls: 'https://example.com'};
 
     const TestComponent = () => {
-      const create = useCreateWebApplicationTarget({});
-      const save = useSaveWebApplicationTarget({});
-      const remove = useDeleteWebApplicationTarget({});
-      const clone = useCloneWebApplicationTarget({});
-      const bulkDelete = useBulkDeleteWebApplicationTargets({});
-      const bulkExport = useBulkExportWebApplicationTargets({});
+      const mutation = useBulkDeleteWebApplicationTargets({});
       return (
-        <>
-          <button onClick={() => create.mutate(input)}>Create</button>
-          <button onClick={() => save.mutate({id: 'target-1', name: 'Saved'})}>
-            Save
-          </button>
-          <button
-            onClick={() => remove.mutate({id: 'target-1', name: 'Target 1'})}
-          >
-            Delete
-          </button>
-          <button
-            onClick={() =>
-              clone.mutate({id: 'target-1', name: 'Cloned Target'})
-            }
-          >
-            Clone
-          </button>
-          <button onClick={() => bulkDelete.mutate(filter as never)}>
-            Bulk delete
-          </button>
-          <button onClick={() => bulkExport.mutate([target] as never)}>
-            Bulk export
-          </button>
-        </>
+        <button onClick={() => mutation.mutate(filter as never)}>Delete</button>
       );
     };
 
     render(<TestComponent />);
-    fireEvent.click(screen.getByRole('button', {name: 'Create'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Save'}));
     fireEvent.click(screen.getByRole('button', {name: 'Delete'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Clone'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Bulk delete'}));
-    fireEvent.click(screen.getByRole('button', {name: 'Bulk export'}));
 
     await waitFor(() => {
-      expect(gmp.webapplicationtarget.create.mock.calls[0][0]).toEqual(input);
-      expect(gmp.webapplicationtarget.save.mock.calls[0][0]).toEqual({
-        id: 'target-1',
-        name: 'Saved',
-      });
-      expect(gmp.webapplicationtarget.delete).toHaveBeenCalledWith({
-        id: 'target-1',
-      });
-      expect(gmp.webapplicationtarget.clone).toHaveBeenCalledWith({
-        id: 'target-1',
-      });
       expect(gmp.webapplicationtargets.deleteByFilter).toHaveBeenCalledWith(
         filter,
       );
+    });
+  });
+});
+
+describe('useBulkExportWebApplicationTargets', () => {
+  test('should export web application targets', async () => {
+    const gmp = createGmp();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useBulkExportWebApplicationTargets({});
+      return (
+        <button onClick={() => mutation.mutate([target] as never)}>
+          Export
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Export'}));
+
+    await waitFor(() => {
       expect(gmp.webapplicationtargets.export).toHaveBeenCalledWith([target]);
     });
   });
diff --git a/src/web/hooks/use-query/web-application-target.ts b/src/web/hooks/use-query/web-application-target.ts
new file mode 100644
index 0000000000..ae78e215e0
--- /dev/null
+++ b/src/web/hooks/use-query/web-application-target.ts
@@ -0,0 +1,93 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {type EntityActionData} from 'gmp/commands/entity';
+import {
+  type WebApplicationTargetCreateParams,
+  type WebApplicationTargetSaveParams,
+} from 'gmp/commands/web-application-target';
+import useGmp from 'web/hooks/useGmp';
+import useCloneMutation from 'web/queries/useCloneMutation';
+import useCreateMutation from 'web/queries/useCreateMutation';
+import useMoveToTrashCan from 'web/queries/useMoveToTrashCan';
+import useSaveMutation from 'web/queries/useSaveMutation';
+
+interface UseCreateWebApplicationTargetParams {
+  onSuccess?: (data: EntityActionData) => void;
+  onError?: (error: Error) => void;
+}
+
+interface UseModifyWebApplicationTargetParams {
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export const useCreateWebApplicationTarget = ({
+  onSuccess,
+  onError,
+}: UseCreateWebApplicationTargetParams) => {
+  const gmp = useGmp();
+
+  return useCreateMutation<WebApplicationTargetCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.webapplicationtarget.create(data);
+      return response.data;
+    },
+    entityType: 'webapplicationtarget',
+    invalidateQueryIds: ['get_web_application_targets'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useSaveWebApplicationTarget = ({
+  onError,
+  onSuccess,
+}: UseModifyWebApplicationTargetParams) => {
+  const gmp = useGmp();
+
+  return useSaveMutation<WebApplicationTargetSaveParams>({
+    gmpMethod: async data => {
+      await gmp.webapplicationtarget.save(data);
+    },
+    entityType: 'webapplicationtarget',
+    invalidateQueryIds: ['get_web_application_targets'],
+    onError,
+    onSuccess,
+  });
+};
+
+export const useDeleteWebApplicationTarget = ({
+  onError,
+  onSuccess,
+}: UseModifyWebApplicationTargetParams) => {
+  const gmp = useGmp();
+
+  return useMoveToTrashCan({
+    gmpMethod: ({id}) => gmp.webapplicationtarget.delete({id}),
+    entityType: 'webapplicationtarget',
+    invalidateQueryIds: ['get_web_application_targets'],
+    onSuccess,
+    onError,
+  });
+};
+
+export const useCloneWebApplicationTarget = ({
+  onError,
+  onSuccess,
+}: UseCreateWebApplicationTargetParams) => {
+  const gmp = useGmp();
+
+  return useCloneMutation<EntityActionData>({
+    gmpMethod: async ({id}) => {
+      const response = await gmp.webapplicationtarget.clone({id});
+      return response.data;
+    },
+    entityType: 'webapplicationtarget',
+    invalidateQueryIds: ['get_web_application_targets'],
+    onError,
+    onSuccess,
+  });
+};
diff --git a/src/web/hooks/use-query/web-application-targets.ts b/src/web/hooks/use-query/web-application-targets.ts
index ff1a174938..09d040efc0 100644
--- a/src/web/hooks/use-query/web-application-targets.ts
+++ b/src/web/hooks/use-query/web-application-targets.ts
@@ -3,11 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionResponse} from 'gmp/commands/entity';
-import {
-  type WebApplicationTargetCreateParams,
-  type WebApplicationTargetSaveParams,
-} from 'gmp/commands/web-application-target';
 import type Rejection from 'gmp/http/rejection';
 import type Response from 'gmp/http/response';
 import {type XmlMeta} from 'gmp/http/transform/fast-xml';
@@ -16,20 +11,11 @@ import {isFilterType} from 'gmp/models/filter/utils';
 import type WebApplicationTarget from 'gmp/models/web-application-target';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
-import useCloneMutation from 'web/queries/useCloneMutation';
-import useCreateMutation from 'web/queries/useCreateMutation';
 import useGetEntities from 'web/queries/useGetEntities';
 import useGmpMutation from 'web/queries/useGmpMutation';
-import useMoveToTrashCan from 'web/queries/useMoveToTrashCan';
-import useSaveMutation from 'web/queries/useSaveMutation';
 
 type WebApplicationTargetBulkInput = WebApplicationTarget[] | FilterType;
 
-interface UseCreateWebApplicationTargetParams {
-  onSuccess?: (data: EntityActionResponse) => void;
-  onError?: (error: Error) => void;
-}
-
 interface UseModifyWebApplicationTargetParams {
   onSuccess?: () => void;
   onError?: (error: Error) => void;
@@ -49,74 +35,6 @@ export const useGetWebApplicationTargets = ({
   });
 };
 
-export const useCreateWebApplicationTarget = ({
-  onSuccess,
-  onError,
-}: UseCreateWebApplicationTargetParams) => {
-  const gmp = useGmp();
-
-  return useCreateMutation<
-    WebApplicationTargetCreateParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.webapplicationtarget.create.bind(gmp.webapplicationtarget),
-    entityType: 'webapplicationtarget',
-    invalidateQueryIds: ['get_web_application_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useSaveWebApplicationTarget = ({
-  onError,
-  onSuccess,
-}: UseModifyWebApplicationTargetParams) => {
-  const gmp = useGmp();
-
-  return useSaveMutation<
-    WebApplicationTargetSaveParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.webapplicationtarget.save.bind(gmp.webapplicationtarget),
-    entityType: 'webapplicationtarget',
-    invalidateQueryIds: ['get_web_application_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
-export const useDeleteWebApplicationTarget = ({
-  onError,
-  onSuccess,
-}: UseModifyWebApplicationTargetParams) => {
-  const gmp = useGmp();
-
-  return useMoveToTrashCan({
-    gmpMethod: gmp.webapplicationtarget.delete.bind(gmp.webapplicationtarget),
-    entityType: 'webapplicationtarget',
-    invalidateQueryIds: ['get_web_application_targets'],
-    onSuccess,
-    onError,
-  });
-};
-
-export const useCloneWebApplicationTarget = ({
-  onError,
-  onSuccess,
-}: UseCreateWebApplicationTargetParams) => {
-  const gmp = useGmp();
-
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    gmpMethod: gmp.webapplicationtarget.clone.bind(gmp.webapplicationtarget),
-    entityType: 'webapplicationtarget',
-    invalidateQueryIds: ['get_web_application_targets'],
-    onError,
-    onSuccess,
-  });
-};
-
 export const useBulkDeleteWebApplicationTargets = ({
   onError,
   onSuccess,
diff --git a/src/web/pages/tasks/TaskComponent.tsx b/src/web/pages/tasks/TaskComponent.tsx
index a3ac73456c..afcd003721 100644
--- a/src/web/pages/tasks/TaskComponent.tsx
+++ b/src/web/pages/tasks/TaskComponent.tsx
@@ -499,9 +499,7 @@ const TaskComponent = ({
     setOciImageTargetId(data.id);
   };
 
-  const handleWebApplicationTargetCreated = (resp: {data: {id?: string}}) => {
-    const {data} = resp;
-
+  const handleWebApplicationTargetCreated = (data: {id?: string}) => {
     setWebApplicationTargetId(data.id);
   };
 
diff --git a/src/web/pages/web-application-targets/WebApplicationTargetsComponent.tsx b/src/web/pages/web-application-targets/WebApplicationTargetsComponent.tsx
index 2a01ac2f08..c9e2b2028b 100644
--- a/src/web/pages/web-application-targets/WebApplicationTargetsComponent.tsx
+++ b/src/web/pages/web-application-targets/WebApplicationTargetsComponent.tsx
@@ -4,7 +4,7 @@
  */
 
 import React, {useState} from 'react';
-import {type EntityActionResponse} from 'gmp/commands/entity';
+import {type EntityActionData} from 'gmp/commands/entity';
 import {
   type default as Credential,
   type CredentialType,
@@ -18,7 +18,7 @@ import {
   useCreateWebApplicationTarget,
   useDeleteWebApplicationTarget,
   useSaveWebApplicationTarget,
-} from 'web/hooks/use-query/web-application-targets';
+} from 'web/hooks/use-query/web-application-target';
 import useGmp from 'web/hooks/useGmp';
 import useTranslation from 'web/hooks/useTranslation';
 import CredentialDialog, {
@@ -32,7 +32,7 @@ interface WebApplicationTargetComponentRenderProps {
   delete: (entity: WebApplicationTarget) => Promise<void>;
   edit: (entity: WebApplicationTarget) => Promise<void>;
   create: () => Promise<void>;
-  clone: (entity: WebApplicationTarget) => Promise<EntityActionResponse>;
+  clone: (entity: WebApplicationTarget) => Promise<EntityActionData>;
   download: (entity: WebApplicationTarget) => Promise<void>;
   save: (entity: WebApplicationTarget) => Promise<void>;
 }
@@ -45,7 +45,7 @@ interface WebApplicationTargetsComponentProps {
   onDeleteError?: (error: Error) => void;
   onSaved?: () => void;
   onSaveError?: (error: Error) => void;
-  onCreated?: (response: EntityActionResponse) => void;
+  onCreated?: (response: EntityActionData) => void;
   onCreateError?: (error: Error) => void;
   onCloned?: () => void;
   onCloneError?: (error: Error) => void;

From 999e6e8edfeee3fa48454fa0bb196f29690220a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 09:14:58 +0200
Subject: [PATCH 31/36] Change WebAppliactionTargetCommand to return void from
 save method

All save methods of commands should just return a Promise<void> because
it just updates the current entity.
---
 src/gmp/commands/__tests__/web-application-target.test.ts | 2 +-
 src/gmp/commands/web-application-target.ts                | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/gmp/commands/__tests__/web-application-target.test.ts b/src/gmp/commands/__tests__/web-application-target.test.ts
index d68596e213..f59ac6a771 100644
--- a/src/gmp/commands/__tests__/web-application-target.test.ts
+++ b/src/gmp/commands/__tests__/web-application-target.test.ts
@@ -122,7 +122,7 @@ describe('WebApplicationTargetCommand tests', () => {
         in_use: YES_VALUE,
       },
     });
-    expect(result.data.id).toEqual('wat-123');
+    expect(result).toBeUndefined();
   });
 
   test('should omit exclude_url when not provided in save', async () => {
diff --git a/src/gmp/commands/web-application-target.ts b/src/gmp/commands/web-application-target.ts
index 42c0f6b5ad..ef35048402 100644
--- a/src/gmp/commands/web-application-target.ts
+++ b/src/gmp/commands/web-application-target.ts
@@ -81,7 +81,7 @@ class WebApplicationTargetCommand extends EntityCommand<WebApplicationTarget> {
     reverseLookupOnly,
     reverseLookupUnify,
     inUse,
-  }: WebApplicationTargetSaveParams): Promise<EntityActionResponse> {
+  }: WebApplicationTargetSaveParams) {
     log.debug('Modifying web application target', {
       id,
       name,
@@ -89,7 +89,7 @@ class WebApplicationTargetCommand extends EntityCommand<WebApplicationTarget> {
       urls,
       credentialId,
     });
-    return this.entityAction({
+    await this.entityAction({
       cmd: 'save_web_application_target',
       web_application_target_id: id,
       name,

From f07bef8963c2500ac4f53a082a8468a5ce92daca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 09:16:55 +0200
Subject: [PATCH 32/36] Add type for CredentialStoreCommand verify params

This new interface will be re used in a query hook.
---
 src/gmp/commands/credential-store.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/gmp/commands/credential-store.ts b/src/gmp/commands/credential-store.ts
index a5611bfbee..588cfd5ee9 100644
--- a/src/gmp/commands/credential-store.ts
+++ b/src/gmp/commands/credential-store.ts
@@ -28,6 +28,10 @@ export interface CredentialStoreModifyParams {
   serverCaCertificate?: File;
 }
 
+export interface CredentialStoreVerifyParams {
+  id: string;
+}
+
 const log = logger.getLogger('gmp.commands.credentialStore');
 
 class CredentialStoreCommand extends EntityCommand<
@@ -90,7 +94,7 @@ class CredentialStoreCommand extends EntityCommand<
     });
   }
 
-  async verify({id}: {id: string}): Promise<EntityActionResponse> {
+  async verify({id}: CredentialStoreVerifyParams) {
     log.debug('Verifying credential store', {id});
 
     return this.entityAction({

From dbca7e959ad9f1d8fad75ab7344b6db5f1741723 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 09:17:47 +0200
Subject: [PATCH 33/36] Improve credential store test expectations

---
 src/web/hooks/use-query/__tests__/CredentialStore.test.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx b/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
index 6825af84d2..6fe086d75d 100644
--- a/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
+++ b/src/web/hooks/use-query/__tests__/CredentialStore.test.tsx
@@ -33,7 +33,7 @@ describe('useEditCredentialStore', () => {
     render(<TestComponent />);
     fireEvent.click(screen.getByRole('button', {name: 'Run'}));
     await waitFor(() => {
-      expect(gmp.credentialstore.edit.mock.calls[0][0]).toEqual(input);
+      expect(gmp.credentialstore.edit).toHaveBeenCalledWith(input);
     });
   });
 });
@@ -51,7 +51,7 @@ describe('useVerifyCredentialStore', () => {
     render(<TestComponent />);
     fireEvent.click(screen.getByRole('button', {name: 'Run'}));
     await waitFor(() => {
-      expect(gmp.credentialstore.verify.mock.calls[0][0]).toEqual(input);
+      expect(gmp.credentialstore.verify).toHaveBeenCalledWith(input);
     });
   });
 });

From d95c145e740dad8c03b6f892a9867eb23d9fb39f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 09:18:53 +0200
Subject: [PATCH 34/36] Change: Unify params and return values of single entity
 query hooks

Always behave the same for all single entity query hooks. Clone and
create return EntityActionData. Save and delete just return void.
---
 src/web/hooks/use-query/agent-group.ts        | 29 ++++++++--------
 src/web/hooks/use-query/agent.ts              | 23 ++++++-------
 src/web/hooks/use-query/credential-store.ts   | 26 ++++++++-------
 src/web/hooks/use-query/oci-image-target.ts   | 33 +++++++++----------
 src/web/hooks/use-query/user.ts               |  7 ++--
 .../agent-groups/AgentGroupsComponent.tsx     |  6 ++--
 .../__tests__/AgentGroupsComponent.test.tsx   | 32 ++++++++----------
 .../ContainerImageTargetsComponent.tsx        |  6 ++--
 .../ContainerImageTargetComponent.test.tsx    | 22 ++++++-------
 src/web/pages/tasks/TaskComponent.tsx         |  4 +--
 .../users/__tests__/UserComponent.test.tsx    | 17 ++++++----
 .../WebApplicationTargetsComponent.test.tsx   | 18 +++++-----
 12 files changed, 110 insertions(+), 113 deletions(-)

diff --git a/src/web/hooks/use-query/agent-group.ts b/src/web/hooks/use-query/agent-group.ts
index 78a45a0393..3cfdcfb298 100644
--- a/src/web/hooks/use-query/agent-group.ts
+++ b/src/web/hooks/use-query/agent-group.ts
@@ -7,8 +7,7 @@ import {
   type AgentGroupCreateParams,
   type AgentGroupSaveParams,
 } from 'gmp/commands/agent-group';
-import {type EntityActionResponse} from 'gmp/commands/entity';
-import type Rejection from 'gmp/http/rejection';
+import {type EntityActionData} from 'gmp/commands/entity';
 import AgentGroup from 'gmp/models/agent-group';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
@@ -17,7 +16,7 @@ import useDeleteMutation from 'web/queries/useDeleteMutation';
 import useSaveMutation from 'web/queries/useSaveMutation';
 
 interface UseCreateAgentGroupParams {
-  onSuccess?: (data: EntityActionResponse) => void;
+  onSuccess?: (data: EntityActionData) => void;
   onError?: (error: Error) => void;
 }
 
@@ -31,12 +30,11 @@ export const useCreateAgentGroup = ({
   onError,
 }: UseCreateAgentGroupParams) => {
   const gmp = useGmp();
-  return useCreateMutation<
-    AgentGroupCreateParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.agentgroup.create.bind(gmp.agentgroup),
+  return useCreateMutation<AgentGroupCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.agentgroup.create(data);
+      return response.data;
+    },
     entityType: AgentGroup.entityType,
     invalidateQueryIds: ['get_agent_groups'],
     onError,
@@ -49,8 +47,11 @@ export const useCloneAgentGroup = ({
   onSuccess,
 }: UseCreateAgentGroupParams) => {
   const gmp = useGmp();
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    gmpMethod: gmp.agentgroup.clone.bind(gmp.agentgroup),
+  return useCloneMutation<EntityActionData>({
+    gmpMethod: async ({id}) => {
+      const response = await gmp.agentgroup.clone({id});
+      return response.data;
+    },
     entityType: AgentGroup.entityType,
     invalidateQueryIds: ['get_agent_groups'],
     onError,
@@ -63,8 +64,10 @@ export const useSaveAgentGroup = ({
   onSuccess,
 }: UseModifyAgentGroupParams) => {
   const gmp = useGmp();
-  return useSaveMutation<AgentGroupSaveParams, void, Rejection>({
-    gmpMethod: gmp.agentgroup.save.bind(gmp.agentgroup),
+  return useSaveMutation<AgentGroupSaveParams>({
+    gmpMethod: async data => {
+      await gmp.agentgroup.save(data);
+    },
     entityType: AgentGroup.entityType,
     invalidateQueryIds: ['get_agent_groups'],
     onError,
diff --git a/src/web/hooks/use-query/agent.ts b/src/web/hooks/use-query/agent.ts
index c08dcd62d7..003ead8055 100644
--- a/src/web/hooks/use-query/agent.ts
+++ b/src/web/hooks/use-query/agent.ts
@@ -5,7 +5,6 @@
 
 import {useQueryClient} from '@tanstack/react-query';
 import {type AgentModifyParams} from 'gmp/commands/agent';
-import type Rejection from 'gmp/http/rejection';
 import type Response from 'gmp/http/response';
 import {isArray} from 'gmp/utils/identity';
 import useGmp from 'web/hooks/useGmp';
@@ -46,9 +45,9 @@ export const useModifyAgent = ({
       },
     });
 
-  return useSaveMutation<AgentModifyParams, void, Rejection>({
+  return useSaveMutation<AgentModifyParams>({
     entityType: 'agent',
-    gmpMethod: gmp.agent.save.bind(gmp.agent),
+    gmpMethod: data => gmp.agent.save(data),
     invalidateQueryIds: ['get_agents'],
     onSuccess: async () => {
       await invalidateAgents();
@@ -75,14 +74,12 @@ export const useDownloadAgentSupportBundle = ({
 }: UseDownloadAgentSupportBundleParams = {}) => {
   const gmp = useGmp();
 
-  return useGmpMutation<
-    DownloadAgentSupportBundleInput,
-    Response<ArrayBuffer>,
-    Rejection
-  >({
-    gmpMethod: ({id, encryption}) =>
-      gmp.agent.downloadSupportBundle(id, encryption),
-    onSuccess,
-    onError,
-  });
+  return useGmpMutation<DownloadAgentSupportBundleInput, Response<ArrayBuffer>>(
+    {
+      gmpMethod: ({id, encryption}) =>
+        gmp.agent.downloadSupportBundle(id, encryption),
+      onSuccess,
+      onError,
+    },
+  );
 };
diff --git a/src/web/hooks/use-query/credential-store.ts b/src/web/hooks/use-query/credential-store.ts
index b3165a1fec..a117459f31 100644
--- a/src/web/hooks/use-query/credential-store.ts
+++ b/src/web/hooks/use-query/credential-store.ts
@@ -3,9 +3,10 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type CredentialStoreModifyParams} from 'gmp/commands/credential-store';
-import {type EntityActionResponse} from 'gmp/commands/entity';
-import type Rejection from 'gmp/http/rejection';
+import {
+  type CredentialStoreVerifyParams,
+  type CredentialStoreModifyParams,
+} from 'gmp/commands/credential-store';
 import useGmp from 'web/hooks/useGmp';
 import useGmpMutation from 'web/queries/useGmpMutation';
 
@@ -24,13 +25,11 @@ export const useEditCredentialStore = ({
   onSuccess,
 }: UseEditCredentialStoreParams) => {
   const gmp = useGmp();
-
-  return useGmpMutation<
-    CredentialStoreModifyParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.credentialstore.edit.bind(gmp.credentialstore),
+  return useGmpMutation<CredentialStoreModifyParams>({
+    gmpMethod: async data => {
+      const response = await gmp.credentialstore.edit(data);
+      return response.data;
+    },
     invalidateQueryIds: ['get_credential_stores'],
     onError,
     onSuccess,
@@ -43,8 +42,11 @@ export const useVerifyCredentialStore = ({
 }: UseVerifyCredentialStoreParams) => {
   const gmp = useGmp();
 
-  return useGmpMutation<{id: string}, EntityActionResponse, Rejection>({
-    gmpMethod: gmp.credentialstore.verify.bind(gmp.credentialstore),
+  return useGmpMutation<CredentialStoreVerifyParams>({
+    gmpMethod: async ({id}) => {
+      const response = await gmp.credentialstore.verify({id});
+      return response.data;
+    },
     onError,
     onSuccess,
   });
diff --git a/src/web/hooks/use-query/oci-image-target.ts b/src/web/hooks/use-query/oci-image-target.ts
index 2da580c09a..7badd820e0 100644
--- a/src/web/hooks/use-query/oci-image-target.ts
+++ b/src/web/hooks/use-query/oci-image-target.ts
@@ -3,12 +3,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import {type EntityActionResponse} from 'gmp/commands/entity';
+import {type EntityActionData} from 'gmp/commands/entity';
 import {
   type OciImageTargetCreateParams,
   type OciImageTargetSaveParams,
 } from 'gmp/commands/oci-image-target';
-import type Rejection from 'gmp/http/rejection';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
@@ -16,7 +15,7 @@ import useMoveToTrashCan from 'web/queries/useMoveToTrashCan';
 import useSaveMutation from 'web/queries/useSaveMutation';
 
 interface UseCreateOciImageTargetParams {
-  onSuccess?: (data: EntityActionResponse) => void;
+  onSuccess?: (data: EntityActionData) => void;
   onError?: (error: Error) => void;
 }
 
@@ -31,12 +30,11 @@ export const useCreateOciImageTarget = ({
 }: UseCreateOciImageTargetParams) => {
   const gmp = useGmp();
 
-  return useCreateMutation<
-    OciImageTargetCreateParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.ociimagetarget.create.bind(gmp.ociimagetarget),
+  return useCreateMutation<OciImageTargetCreateParams, EntityActionData>({
+    gmpMethod: async data => {
+      const response = await gmp.ociimagetarget.create(data);
+      return response.data;
+    },
     entityType: 'ociimagetarget',
     invalidateQueryIds: ['get_oci_image_targets'],
     onError,
@@ -50,12 +48,10 @@ export const useSaveOciImageTarget = ({
 }: UseModifyOciImageTargetParams) => {
   const gmp = useGmp();
 
-  return useSaveMutation<
-    OciImageTargetSaveParams,
-    EntityActionResponse,
-    Rejection
-  >({
-    gmpMethod: gmp.ociimagetarget.save.bind(gmp.ociimagetarget),
+  return useSaveMutation<OciImageTargetSaveParams>({
+    gmpMethod: async data => {
+      await gmp.ociimagetarget.save(data);
+    },
     entityType: 'ociimagetarget',
     invalidateQueryIds: ['get_oci_image_targets'],
     onError,
@@ -84,8 +80,11 @@ export const useCloneOciImageTarget = ({
 }: UseCreateOciImageTargetParams) => {
   const gmp = useGmp();
 
-  return useCloneMutation<EntityActionResponse, Rejection>({
-    gmpMethod: ({id}) => gmp.ociimagetarget.clone({id}),
+  return useCloneMutation<EntityActionData>({
+    gmpMethod: async ({id}) => {
+      const response = await gmp.ociimagetarget.clone({id});
+      return response.data;
+    },
     entityType: 'ociimagetarget',
     invalidateQueryIds: ['get_oci_image_targets'],
     onError,
diff --git a/src/web/hooks/use-query/user.ts b/src/web/hooks/use-query/user.ts
index eb620a2b42..39b55d2e2b 100644
--- a/src/web/hooks/use-query/user.ts
+++ b/src/web/hooks/use-query/user.ts
@@ -75,15 +75,14 @@ export const useCreateUser = ({
 export const useSaveUser = ({
   onSuccess,
   onError,
-}: UseUserMutationCallbacks<EntityActionData> = {}) => {
+}: UseUserMutationCallbacks<void> = {}) => {
   const gmp = useGmp();
-  return useGmpMutation<UserSaveInput, EntityActionData>({
+  return useGmpMutation<UserSaveInput, void>({
     gmpMethod: async data => {
-      const response = await gmp.user.save({
+      await gmp.user.save({
         ...data,
         oldName: data.oldName ?? data.name,
       });
-      return response.data;
     },
     invalidateQueryIds: ['get_users', 'get_user'],
     onSuccess,
diff --git a/src/web/pages/agent-groups/AgentGroupsComponent.tsx b/src/web/pages/agent-groups/AgentGroupsComponent.tsx
index 1db38bf5d0..ebf60fca9f 100644
--- a/src/web/pages/agent-groups/AgentGroupsComponent.tsx
+++ b/src/web/pages/agent-groups/AgentGroupsComponent.tsx
@@ -5,8 +5,6 @@
 
 import React, {useState} from 'react';
 import {type EntityActionData} from 'gmp/commands/entity';
-import type Response from 'gmp/http/response';
-import {type XmlMeta} from 'gmp/http/transform/fast-xml';
 import type AgentGroup from 'gmp/models/agent-group';
 import {isDefined} from 'gmp/utils/identity';
 import {
@@ -22,7 +20,7 @@ import AgentGroupsDialog, {
 
 interface AgentGroupsComponentRenderProps {
   create: () => void;
-  clone: (entity: AgentGroup) => Promise<Response<EntityActionData, XmlMeta>>;
+  clone: (entity: AgentGroup) => Promise<EntityActionData>;
   delete: (entity: AgentGroup) => Promise<void>;
   edit: (entity: AgentGroup) => void;
 }
@@ -31,7 +29,7 @@ interface AgentGroupsComponentProps {
   children: (actions: AgentGroupsComponentRenderProps) => React.ReactNode;
   onCloned?: () => void;
   onCloneError?: (error: Error) => void;
-  onCreated?: (response: Response<EntityActionData, XmlMeta>) => void;
+  onCreated?: (data: EntityActionData) => void;
   onCreateError?: (error: Error) => void;
   onDeleted?: () => void;
   onDeleteError?: (error: Error) => void;
diff --git a/src/web/pages/agent-groups/__tests__/AgentGroupsComponent.test.tsx b/src/web/pages/agent-groups/__tests__/AgentGroupsComponent.test.tsx
index f608f8ae6b..ea9b34f653 100644
--- a/src/web/pages/agent-groups/__tests__/AgentGroupsComponent.test.tsx
+++ b/src/web/pages/agent-groups/__tests__/AgentGroupsComponent.test.tsx
@@ -7,7 +7,6 @@ import {describe, expect, test, testing} from '@gsa/testing';
 import {fireEvent, rendererWith, screen, wait} from 'web/testing';
 import {type EntityActionData} from 'gmp/commands/entity';
 import Response from 'gmp/http/response';
-import {type XmlMeta} from 'gmp/http/transform/fast-xml';
 import AgentGroup from 'gmp/models/agent-group';
 import {createSession} from 'gmp/testing';
 import Button from 'web/components/form/Button';
@@ -19,8 +18,10 @@ const sampleAgentGroup: AgentGroup = new AgentGroup({
 });
 
 const createGmp = () => {
-  const createMock = testing.fn().mockResolvedValue({id: '123'});
-  const cloneMock = testing.fn().mockResolvedValue({id: 'cloned'});
+  const createMock = testing.fn().mockResolvedValue(new Response({id: '123'}));
+  const cloneMock = testing
+    .fn()
+    .mockResolvedValue(new Response({id: 'cloned'}));
   const deleteMock = testing.fn().mockResolvedValue(undefined);
   const saveMock = testing.fn().mockResolvedValue(undefined);
 
@@ -52,9 +53,7 @@ describe('AgentGroupsComponent tests', () => {
 
     type AgentGroupsActions = {
       create: () => void;
-      clone: (
-        entity: AgentGroup,
-      ) => Promise<Response<EntityActionData, XmlMeta>>;
+      clone: (entity: AgentGroup) => Promise<EntityActionData>;
       delete: (entity: AgentGroup) => Promise<void>;
       edit: (entity: AgentGroup) => void;
     };
@@ -83,17 +82,14 @@ describe('AgentGroupsComponent tests', () => {
 
     await wait();
 
-    expect(saveMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: 'g1',
-        name: 'group1',
-        comment: '',
-        scannerId: '',
-        agentIds: [],
-        schedulerCronTime: '0 */12 * * *',
-      }),
-      expect.anything(),
-    );
+    expect(saveMock).toHaveBeenCalledWith({
+      id: 'g1',
+      name: 'group1',
+      comment: '',
+      scannerId: '',
+      agentIds: [],
+      schedulerCronTime: '0 */12 * * *',
+    });
     expect(onSaved).toHaveBeenCalled();
   });
 
@@ -163,7 +159,7 @@ describe('AgentGroupsComponent tests', () => {
     cloneMock.mockRejectedValue(error);
 
     let cloneFn:
-      | ((entity: AgentGroup) => Promise<Response<EntityActionData, XmlMeta>>)
+      | ((entity: AgentGroup) => Promise<EntityActionData>)
       | undefined;
 
     const {render} = rendererWith({gmp});
diff --git a/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx b/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
index 80832d5bde..bd348b968b 100644
--- a/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
+++ b/src/web/pages/container-image-targets/ContainerImageTargetsComponent.tsx
@@ -4,7 +4,7 @@
  */
 
 import React, {useState} from 'react';
-import {type EntityActionResponse} from 'gmp/commands/entity';
+import {type EntityActionData} from 'gmp/commands/entity';
 import {
   type OciImageTargetCreateParams,
   type OciImageTargetSaveParams,
@@ -36,7 +36,7 @@ interface ContainerImageTargetComponentRenderProps {
   delete: (entity: OciImageTarget) => Promise<void>;
   edit: (entity: OciImageTarget) => Promise<void>;
   create: () => Promise<void>;
-  clone: (entity: OciImageTarget) => Promise<EntityActionResponse>;
+  clone: (entity: OciImageTarget) => Promise<EntityActionData>;
   download: (entity: OciImageTarget) => Promise<void>;
   save: (entity: OciImageTarget) => Promise<void>;
 }
@@ -49,7 +49,7 @@ interface ContainerImageTargetsComponentProps {
   onDeleteError?: (error: Error) => void;
   onSaved?: () => void;
   onSaveError?: (error: Error) => void;
-  onCreated?: (response: EntityActionResponse) => void;
+  onCreated?: (response: EntityActionData) => void;
   onCreateError?: (error: Error) => void;
   onCloned?: () => void;
   onCloneError?: (error: Error) => void;
diff --git a/src/web/pages/container-image-targets/__tests__/ContainerImageTargetComponent.test.tsx b/src/web/pages/container-image-targets/__tests__/ContainerImageTargetComponent.test.tsx
index c87b9b92a1..7c007b20f1 100644
--- a/src/web/pages/container-image-targets/__tests__/ContainerImageTargetComponent.test.tsx
+++ b/src/web/pages/container-image-targets/__tests__/ContainerImageTargetComponent.test.tsx
@@ -16,12 +16,12 @@ type MaybeMock<T> = T | ((...args: unknown[]) => Promise<T>);
 
 type CreateGmpParams = {
   getAllCredentials?: unknown[];
-  createOciImageTarget?: MaybeMock<{id: string}>;
-  saveOciImageTarget?: MaybeMock<{id: string}>;
-  cloneOciImageTarget?: MaybeMock<{id: string}>;
+  createOciImageTarget?: MaybeMock<Response<{id: string}>>;
+  saveOciImageTarget?: MaybeMock<Response<{id: string}>>;
+  cloneOciImageTarget?: MaybeMock<Response<{id: string}>>;
   deleteOciImageTarget?: MaybeMock<undefined>;
   exportOciImageTarget?: MaybeMock<Response | string>;
-  createCredentialResponse?: MaybeMock<unknown>;
+  createCredentialResponse?: MaybeMock<Response<{id: string}>>;
   createCredential?: MaybeMock<unknown>;
 };
 
@@ -43,12 +43,12 @@ const assertHandlerError = (mock: MockFn, error: Error) => {
 
 const createGmp = ({
   getAllCredentials = [],
-  createOciImageTarget = {id: 'created-id'},
-  saveOciImageTarget = {id: 'saved-id'},
-  cloneOciImageTarget = {id: 'cloned-id'},
+  createOciImageTarget = new Response({id: 'created-id'}),
+  saveOciImageTarget = new Response({id: 'saved-id'}),
+  cloneOciImageTarget = new Response({id: 'cloned-id'}),
   deleteOciImageTarget,
   exportOciImageTarget = new Response('some-data'),
-  createCredentialResponse = {data: {id: 'cred-id'}},
+  createCredentialResponse = new Response({id: 'cred-id'}),
   createCredential = testing.fn().mockResolvedValue(createCredentialResponse),
 }: CreateGmpParams = {}): {
   credentials: {getAll: ReturnType<typeof testing.fn>};
@@ -218,7 +218,7 @@ describe('ContainerImageTargetsComponent tests', () => {
       screen.queryByText('Edit Container Image Target - foo'),
     ).not.toBeInTheDocument();
     expect(onSaveError).not.toHaveBeenCalled();
-    expect(onSaved).toHaveBeenCalledWith({id: 'saved-id'});
+    expect(onSaved).toHaveBeenCalledWith(undefined);
   });
 
   test('should call onSaveError if saving fails and show error', async () => {
@@ -506,7 +506,7 @@ describe('ContainerImageTargetsComponent tests', () => {
     expect(
       screen.queryByText('Edit Container Image Target - foo'),
     ).not.toBeInTheDocument();
-    expect(onSaved).toHaveBeenCalledWith({id: 'saved-id'});
+    expect(onSaved).toHaveBeenCalledWith(undefined);
   });
 
   test('should handle editing target with undefined excludeImages', async () => {
@@ -539,7 +539,7 @@ describe('ContainerImageTargetsComponent tests', () => {
     expect(
       screen.queryByText('Edit Container Image Target - foo'),
     ).not.toBeInTheDocument();
-    expect(onSaved).toHaveBeenCalledWith({id: 'saved-id'});
+    expect(onSaved).toHaveBeenCalledWith(undefined);
   });
 
   test('should render edit dialog when both imageReferences and excludeImages are undefined', async () => {
diff --git a/src/web/pages/tasks/TaskComponent.tsx b/src/web/pages/tasks/TaskComponent.tsx
index afcd003721..631b0c0a37 100644
--- a/src/web/pages/tasks/TaskComponent.tsx
+++ b/src/web/pages/tasks/TaskComponent.tsx
@@ -493,9 +493,7 @@ const TaskComponent = ({
     setTargetId(data.id);
   };
 
-  const handleOciImageTargetCreated = (resp: {data: {id?: string}}) => {
-    const {data} = resp;
-
+  const handleOciImageTargetCreated = (data: {id: string}) => {
     setOciImageTargetId(data.id);
   };
 
diff --git a/src/web/pages/users/__tests__/UserComponent.test.tsx b/src/web/pages/users/__tests__/UserComponent.test.tsx
index e6fcdfdd34..b674c10dce 100644
--- a/src/web/pages/users/__tests__/UserComponent.test.tsx
+++ b/src/web/pages/users/__tests__/UserComponent.test.tsx
@@ -6,6 +6,7 @@
 import {describe, expect, test, testing} from '@gsa/testing';
 import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
 import CollectionCounts from 'gmp/collection/collection-counts';
+import Response from 'gmp/http/response';
 import Group from 'gmp/models/group';
 import Role from 'gmp/models/role';
 import Settings from 'gmp/models/settings';
@@ -63,12 +64,14 @@ const createGmp = () => ({
     reloadIntervalInactive: 0,
   },
   user: {
-    create: testing.fn().mockResolvedValue({data: {id: 'created'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'saved'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'cloned'}}),
+    create: testing.fn().mockResolvedValue(new Response({id: 'created'})),
+    save: testing.fn().mockResolvedValue(new Response({id: 'saved'})),
+    clone: testing.fn().mockResolvedValue(new Response({id: 'cloned'})),
     delete: testing.fn().mockResolvedValue(undefined),
-    export: testing.fn().mockResolvedValue({data: 'user-data'}),
-    currentAuthSettings: testing.fn().mockResolvedValue({data: authSettings}),
+    export: testing.fn().mockResolvedValue(new Response('user-data')),
+    currentAuthSettings: testing
+      .fn()
+      .mockResolvedValue(new Response(authSettings)),
     currentSettings: testing
       .fn()
       .mockResolvedValue(currentSettingsDefaultResponse),
@@ -163,7 +166,7 @@ describe('UserComponent', () => {
         oldName: 'user 1',
         password: '',
       });
-      expect(onSaved).toHaveBeenCalledWith({id: 'saved'});
+      expect(onSaved).toHaveBeenCalledWith(undefined);
     });
   });
 
@@ -204,7 +207,7 @@ describe('UserComponent', () => {
         groupIds: ['group1', 'group2'],
         roleIds: ['role1', 'role2'],
       });
-      expect(onSaved).toHaveBeenCalledWith({id: 'saved'});
+      expect(onSaved).toHaveBeenCalledWith(undefined);
     });
   });
 
diff --git a/src/web/pages/web-application-targets/__tests__/WebApplicationTargetsComponent.test.tsx b/src/web/pages/web-application-targets/__tests__/WebApplicationTargetsComponent.test.tsx
index 19e9dc3a09..ed12e55c31 100644
--- a/src/web/pages/web-application-targets/__tests__/WebApplicationTargetsComponent.test.tsx
+++ b/src/web/pages/web-application-targets/__tests__/WebApplicationTargetsComponent.test.tsx
@@ -16,12 +16,12 @@ type MaybeMock<T> = T | ((...args: unknown[]) => Promise<T>);
 
 type CreateGmpParams = {
   getAllCredentials?: unknown[];
-  createWebApplicationTarget?: MaybeMock<{id: string}>;
-  saveWebApplicationTarget?: MaybeMock<{id: string}>;
-  cloneWebApplicationTarget?: MaybeMock<{id: string}>;
+  createWebApplicationTarget?: MaybeMock<Response<{id: string}>>;
+  saveWebApplicationTarget?: MaybeMock<Response<{id: string}>>;
+  cloneWebApplicationTarget?: MaybeMock<Response<{id: string}>>;
   deleteWebApplicationTarget?: MaybeMock<undefined>;
   exportWebApplicationTarget?: MaybeMock<Response | string>;
-  createCredential?: MaybeMock<unknown>;
+  createCredential?: MaybeMock<Response<{id: string}>>;
 };
 
 type MockFn = ReturnType<typeof testing.fn>;
@@ -36,12 +36,14 @@ const assertHandlerError = (mock: MockFn, error: Error) => {
 
 const createGmp = ({
   getAllCredentials = [],
-  createWebApplicationTarget = {id: 'created-id'},
-  saveWebApplicationTarget = {id: 'saved-id'},
-  cloneWebApplicationTarget = {id: 'cloned-id'},
+  createWebApplicationTarget = new Response({id: 'created-id'}),
+  saveWebApplicationTarget = new Response({id: 'saved-id'}),
+  cloneWebApplicationTarget = new Response({id: 'cloned-id'}),
   deleteWebApplicationTarget,
   exportWebApplicationTarget = new Response('some-data'),
-  createCredential = testing.fn().mockResolvedValue({data: {id: 'cred-id'}}),
+  createCredential = testing
+    .fn()
+    .mockResolvedValue(new Response({id: 'cred-id'})),
 }: CreateGmpParams = {}): {
   credentials: {getAll: ReturnType<typeof testing.fn>};
   webapplicationtarget: Record<string, ReturnType<typeof testing.fn>>;

From fba6bb608ce96896f266f2c3c1c759ed7c08ad19 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 13:14:41 +0200
Subject: [PATCH 35/36] Change: Update importing a port list

Show success message and don't call onImported and onImportError
handlers twice.
---
 public/locales/gsa-de.json                    |  1 +
 public/locales/gsa-en.json                    |  1 +
 public/locales/gsa-it.json                    |  1 +
 public/locales/gsa-ja.json                    |  1 +
 public/locales/gsa-zh_CN.json                 |  1 +
 public/locales/gsa-zh_TW.json                 |  1 +
 .../use-query/__tests__/PortList.test.tsx     | 67 +++++++++++++++++--
 src/web/hooks/use-query/port-list.ts          |  2 +
 src/web/pages/portlists/PortListComponent.tsx | 13 +---
 .../__tests__/PortListComponent.test.tsx      | 13 ++--
 10 files changed, 76 insertions(+), 25 deletions(-)

diff --git a/public/locales/gsa-de.json b/public/locales/gsa-de.json
index 66a2d5fe54..aded6f0ab8 100644
--- a/public/locales/gsa-de.json
+++ b/public/locales/gsa-de.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "Portanzahl: Gesamt",
   "Port Counts: UDP": "Portanzahl: UDP",
   "Port List": "Portliste",
+  "Port List imported successfully.": "Portliste erfolgreich importiert.",
   "Port List: {{name}}": "Portliste: {{name}}",
   "Port Lists": "Portlisten",
   "Port Lists Filter": "Portlisten-Filter",
diff --git a/public/locales/gsa-en.json b/public/locales/gsa-en.json
index 31e7021425..c8492eadfe 100644
--- a/public/locales/gsa-en.json
+++ b/public/locales/gsa-en.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "Port Counts: Total",
   "Port Counts: UDP": "Port Counts: UDP",
   "Port List": "Port List",
+  "Port List imported successfully.": "Port List imported successfully.",
   "Port List: {{name}}": "Port List: {{name}}",
   "Port Lists": "Port Lists",
   "Port Lists Filter": "Port Lists Filter",
diff --git a/public/locales/gsa-it.json b/public/locales/gsa-it.json
index cd4b0d1dd6..a99f2f7a1a 100644
--- a/public/locales/gsa-it.json
+++ b/public/locales/gsa-it.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "Conteggi porte: Totale",
   "Port Counts: UDP": "Conteggi porte: UDP",
   "Port List": "Elenco porte",
+  "Port List imported successfully.": "",
   "Port List: {{name}}": "Elenco porte: {{name}}",
   "Port Lists": "Elenchi porte",
   "Port Lists Filter": "Filtro elenchi porte",
diff --git a/public/locales/gsa-ja.json b/public/locales/gsa-ja.json
index 8522cfe63a..1fdd25dc02 100644
--- a/public/locales/gsa-ja.json
+++ b/public/locales/gsa-ja.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "ポート数: 合計",
   "Port Counts: UDP": "ポート数: UDP",
   "Port List": "ポートリスト",
+  "Port List imported successfully.": "",
   "Port List: {{name}}": "ポートリスト: {{name}}",
   "Port Lists": "ポートリスト",
   "Port Lists Filter": "ポートリストフィルター",
diff --git a/public/locales/gsa-zh_CN.json b/public/locales/gsa-zh_CN.json
index cd3d603a88..70e9d5ab4b 100644
--- a/public/locales/gsa-zh_CN.json
+++ b/public/locales/gsa-zh_CN.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "端口数量: 总数",
   "Port Counts: UDP": "端口数量: UDP",
   "Port List": "端口列表",
+  "Port List imported successfully.": "",
   "Port List: {{name}}": "端口列表：{{name}}",
   "Port Lists": "端口列表",
   "Port Lists Filter": "端口列表筛选",
diff --git a/public/locales/gsa-zh_TW.json b/public/locales/gsa-zh_TW.json
index d693528400..38ba130500 100644
--- a/public/locales/gsa-zh_TW.json
+++ b/public/locales/gsa-zh_TW.json
@@ -1604,6 +1604,7 @@
   "Port Counts: Total": "",
   "Port Counts: UDP": "",
   "Port List": "連接埠清單",
+  "Port List imported successfully.": "",
   "Port List: {{name}}": "",
   "Port Lists": "連接埠清單",
   "Port Lists Filter": "",
diff --git a/src/web/hooks/use-query/__tests__/PortList.test.tsx b/src/web/hooks/use-query/__tests__/PortList.test.tsx
index cbc2ecdad9..9e2994449e 100644
--- a/src/web/hooks/use-query/__tests__/PortList.test.tsx
+++ b/src/web/hooks/use-query/__tests__/PortList.test.tsx
@@ -5,6 +5,7 @@
 
 import {describe, expect, test, testing} from '@gsa/testing';
 import {fireEvent, rendererWith, screen, waitFor} from 'web/testing';
+import Response from 'gmp/http/response';
 import {createSession} from 'gmp/testing';
 import {
   useClonePortList,
@@ -20,14 +21,14 @@ const createGmp = () => ({
   session: createSession({token: 'test-token'}),
   settings: {},
   portlist: {
-    create: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
-    save: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
-    clone: testing.fn().mockResolvedValue({data: {id: 'port-list-2'}}),
+    create: testing.fn().mockResolvedValue(new Response({id: 'port-list-1'})),
+    save: testing.fn().mockResolvedValue(new Response({id: 'port-list-1'})),
+    clone: testing.fn().mockResolvedValue(new Response({id: 'port-list-2'})),
     delete: testing.fn().mockResolvedValue(undefined),
-    import: testing.fn().mockResolvedValue({data: {id: 'port-list-1'}}),
-    createPortRange: testing.fn().mockResolvedValue({
-      data: {id: 'port-range-1'},
-    }),
+    import: testing.fn().mockResolvedValue(new Response({id: 'port-list-1'})),
+    createPortRange: testing
+      .fn()
+      .mockResolvedValue(new Response({id: 'port-range-1'})),
     deletePortRange: testing.fn().mockResolvedValue(undefined),
   },
 });
@@ -198,6 +199,58 @@ describe('useImportPortList', () => {
       expect(gmp.portlist.import).toHaveBeenCalledWith(input);
     });
   });
+
+  test('should call onSuccess with the imported port list data', async () => {
+    const gmp = createGmp();
+    const onSuccess = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useImportPortList({onSuccess});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({xmlFile: new File(['port list'], 'port-list.xml')})
+          }
+        >
+          Import
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Import'}));
+
+    await waitFor(() => {
+      expect(onSuccess).toHaveBeenCalledWith({id: 'port-list-1'});
+    });
+  });
+
+  test('should call onError when importing a port list fails', async () => {
+    const error = new Error('Import failed');
+    const gmp = createGmp();
+    gmp.portlist.import.mockRejectedValue(error);
+    const onError = testing.fn();
+    const {render} = rendererWith({gmp, router: true});
+
+    const TestComponent = () => {
+      const mutation = useImportPortList({onError});
+      return (
+        <button
+          onClick={() =>
+            mutation.mutate({xmlFile: new File(['port list'], 'port-list.xml')})
+          }
+        >
+          Import
+        </button>
+      );
+    };
+
+    render(<TestComponent />);
+    fireEvent.click(screen.getByRole('button', {name: 'Import'}));
+
+    await waitFor(() => expect(onError.mock.calls[0][0]).toBe(error));
+  });
 });
 
 describe('useCreatePortRange', () => {
diff --git a/src/web/hooks/use-query/port-list.ts b/src/web/hooks/use-query/port-list.ts
index 3c0efe2bc5..2fbcd3ddc8 100644
--- a/src/web/hooks/use-query/port-list.ts
+++ b/src/web/hooks/use-query/port-list.ts
@@ -11,6 +11,7 @@ import {
   type PortListCommandCreatePortRangeParams,
   type PortListCommandDeletePortRangeParams,
 } from 'gmp/commands/port-list';
+import _ from 'gmp/locale';
 import useGmp from 'web/hooks/useGmp';
 import useCloneMutation from 'web/queries/useCloneMutation';
 import useCreateMutation from 'web/queries/useCreateMutation';
@@ -108,6 +109,7 @@ export const useImportPortList = ({
       const response = await gmp.portlist.import(data);
       return response.data;
     },
+    successMessage: _('Port List imported successfully.'),
     invalidateQueryIds: ['get_port_lists'],
     onSuccess,
     onError,
diff --git a/src/web/pages/portlists/PortListComponent.tsx b/src/web/pages/portlists/PortListComponent.tsx
index 8eee97e995..7af87bfb27 100644
--- a/src/web/pages/portlists/PortListComponent.tsx
+++ b/src/web/pages/portlists/PortListComponent.tsx
@@ -223,17 +223,8 @@ const PortListComponent = ({
   };
 
   const handleImportPortList = async (data: PortListImportDialogState) => {
-    try {
-      const response = await importPortListMutation.mutateAsync(data);
-      if (isDefined(onImported)) {
-        onImported(response);
-      }
-      closeImportDialog();
-    } catch (error) {
-      if (isDefined(onImportError)) {
-        onImportError(error as Rejection);
-      }
-    }
+    await importPortListMutation.mutateAsync(data);
+    closeImportDialog();
   };
 
   const handleSavePortList = async (
diff --git a/src/web/pages/portlists/__tests__/PortListComponent.test.tsx b/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
index a3d8726070..01e32cdd54 100644
--- a/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
+++ b/src/web/pages/portlists/__tests__/PortListComponent.test.tsx
@@ -12,6 +12,7 @@ import {
   wait,
   fireEvent,
 } from 'web/testing';
+import Response from 'gmp/http/response';
 import PortList from 'gmp/models/port-list';
 import {createSession} from 'gmp/testing';
 import Button from 'web/components/form/Button';
@@ -26,20 +27,18 @@ const currentSettings = testing
   .mockResolvedValue(currentSettingsDefaultResponse);
 const createGmp = ({
   getPortListResponse = defaultGetPortListResponse,
-  createPortListResponse = {data: {id: '123'}},
+  createPortListResponse = new Response({id: '123'}),
   // oxlint-disable-next-line typescript/no-useless-default-assignment
   deletePortListResponse = undefined,
-  savePortListResponse = {data: {id: '123'}},
-  clonePortListResponse = {data: {id: '123'}},
-  createPortRangeResponse = {id: '1234'},
+  savePortListResponse = new Response({id: '123'}),
+  clonePortListResponse = new Response({id: '123'}),
+  createPortRangeResponse = new Response({id: '1234'}),
   getPortList = testing.fn().mockResolvedValue(getPortListResponse),
   createPortList = testing.fn().mockResolvedValue(createPortListResponse),
   deletePortList = testing.fn().mockResolvedValue(deletePortListResponse),
   savePortList = testing.fn().mockResolvedValue(savePortListResponse),
   clonePortList = testing.fn().mockResolvedValue(clonePortListResponse),
-  createPortRange = testing
-    .fn()
-    .mockResolvedValue({data: createPortRangeResponse}),
+  createPortRange = testing.fn().mockResolvedValue(createPortRangeResponse),
   deletePortRange = testing.fn().mockResolvedValue(undefined),
 } = {}) => ({
   portlist: {

From 0525f9876d61f4be0f7494f0611d220163bf078c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Ricks?= <bjoern.ricks@greenbone.net>
Date: Wed, 7 Oct 2026 13:54:39 +0200
Subject: [PATCH 36/36] Update public/locales/gsa-it.json

Co-authored-by: Daniele Mangiagli <daniele.mangiagli@greenbone.net>
---
 public/locales/gsa-it.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/public/locales/gsa-it.json b/public/locales/gsa-it.json
index a99f2f7a1a..5d74f3c008 100644
--- a/public/locales/gsa-it.json
+++ b/public/locales/gsa-it.json
@@ -1604,7 +1604,8 @@
   "Port Counts: Total": "Conteggi porte: Totale",
   "Port Counts: UDP": "Conteggi porte: UDP",
   "Port List": "Elenco porte",
-  "Port List imported successfully.": "",
+  "Port List imported successfully.": "Elenco porte importato con successo.",
+
   "Port List: {{name}}": "Elenco porte: {{name}}",
   "Port Lists": "Elenchi porte",
   "Port Lists Filter": "Filtro elenchi porte",