From 05fc04c8066f466803e27e98cd27df5def0f07c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hornych?= <lukashornych@proton.me>
Date: Sun, 22 Sep 2024 22:12:13 +0200
Subject: [PATCH] feat(#117): jfr, tasks, backups refactor and fixes

---
 package.json                                  |   2 +-
 .../BackupViewerModuleRegistrar.ts            |  14 +
 .../components/BackupCatalogDialog.vue        | 141 +++++++++
 .../backup-viewer/components/BackupViewer.vue | 286 ++++++++++++++++++
 .../components/RestoreCatalogDialog.vue       | 119 ++++++++
 .../model/BackupViewerDefinition.ts           |  17 ++
 .../model/BackupViewerTabParams.ts}           |   8 +-
 .../model/BackupViewerTabParamsDto.ts}        |   2 +-
 .../service/BackupViewerService.ts            | 104 +++++++
 .../service/BackupViewerTabFactory.ts         |  36 +++
 src/modules/backups/BackupsModuleRegistrar.ts |  14 -
 .../backups/components/BackupCatalog.vue      |  86 ------
 src/modules/backups/components/Backups.vue    | 262 ----------------
 .../backups/components/RestoreCatalog.vue     |  62 ----
 .../backups/model/BackupsDefinition.ts        |  17 --
 src/modules/backups/service/BackupsService.ts |  87 ------
 .../backups/service/BackupsTabFactory.ts      |  36 ---
 .../base/component/VExecuteQueryButton.vue    |  10 +-
 src/modules/base/component/VFormDialog.vue    |   9 +-
 .../base/component/VTabMainActionButton.vue   |  29 ++
 src/modules/base/component/VTabToolbar.vue    |   2 +-
 .../connection/driver/EvitaDBDriver.ts        |  41 +--
 .../driver/grpc/EvitaDBDriverGrpc.ts          | 244 +++++++--------
 .../driver/grpc/service/BackupConverter.ts    |  19 +-
 .../grpc/service/CatalogSchemaConverter.ts    |   5 +-
 .../driver/grpc/service/EntityConverter.ts    |   2 +-
 .../grpc/service/EvitaValueConverter.ts       |   2 +-
 .../grpc/service/ServerStatusConverter.ts     |   4 +-
 ...tateConverter.ts => TaskStateConverter.ts} |  35 +--
 ...obsConverter.ts => TaskStatusConverter.ts} |  16 +-
 .../explorer/component/CatalogItem.vue        |   6 +-
 .../explorer/component/ConnectionItem.vue     |  16 +-
 .../explorer/model/ConnectionActionType.ts    |   2 +-
 .../{data => }/CatalogVersionAtResponse.ts    |   4 +-
 .../model/{data => data-type}/Currency.ts     |   0
 src/modules/connection/model/data/Price.ts    |   3 +-
 .../model/data/TaskSimplifiedState.ts         |   6 -
 .../connection/model/{data => file}/File.ts   |   0
 .../model/{data => file}/FilesToFetch.ts      |   4 +-
 .../model/{data => jfr}/EventType.ts          |   2 +-
 .../connection/model/schema/EntitySchema.ts   |   3 +-
 .../model/{data => status}/ApiEndpoint.ts     |   0
 .../model/{data => status}/ApiReadiness.ts    |   0
 .../model/{data => status}/ApiServerStatus.ts |   0
 .../model/{data => status}/ServerStatus.ts    |   0
 .../connection/model/task/TaskState.ts        |   6 +
 .../model/{data => task}/TaskStatus.ts        |  33 +-
 .../model/{data => task}/TaskStatuses.ts      |   6 +-
 .../entity-property-value/EntityPrice.ts      |   2 +-
 .../entity-property-value/NativeValue.ts      |   2 +-
 .../global/components/TabWindowBody.vue       |  55 ----
 .../console/component/GraphQLConsole.vue      |  10 +-
 src/modules/i18n/en.json                      | 139 +++++++--
 .../jfr-recording/JfrModuleRegistrar.ts       |  15 -
 .../jfr-recording/components/JfrEndRecord.vue |  23 --
 .../components/JfrStartRecord.vue             |  85 ------
 .../components/JfrVisualizer.vue              | 135 ---------
 .../model/JfrVisualizerDefinition.ts          |  11 -
 .../jfr-recording/service/JfrService.ts       |  46 ---
 .../jfr-recording/service/JfrTabFactory.ts    |  37 ---
 .../jfr-viewer/JfrViewerModuleRegistrar.ts    |  12 +
 .../components/EndJfrRecordingDialog.vue      |  67 ++++
 .../jfr-viewer/components/JfrViewer.vue       | 206 +++++++++++++
 .../components/StartJfrRecordingDialog.vue    | 118 ++++++++
 .../jfr-viewer/model/JfrViewerDefinition.ts   |  18 ++
 .../model/JfrViewerTabParams.ts}              |   8 +-
 .../model/JfrViewerTabParamsDto.ts}           |   4 +-
 .../jfr-viewer/service/JfrViewerService.ts    |  48 +++
 .../jfr-viewer/service/JfrViewerTabFactory.ts |  38 +++
 src/modules/jobs/JobModuleRegistrar.ts        |  12 -
 src/modules/jobs/components/JobVisualizer.vue | 209 -------------
 src/modules/jobs/components/JobsControl.vue   |  30 --
 src/modules/jobs/model/JobDefinition.ts       |  11 -
 src/modules/jobs/services/JobService.ts       |  31 --
 src/modules/jobs/services/JobTabFactory.ts    |  36 ---
 src/modules/modules.ts                        |  12 +-
 .../server-status/component/ServerStatus.vue  |   8 +-
 .../service/ServerStatusService.ts            |   6 +-
 .../task-viewer/TaskViewerModuleRegistrar.ts  |  13 +
 .../task-viewer/components/TaskViewer.vue     |  38 +++
 .../components/TasksVisualizer.vue            | 275 +++++++++++++++++
 .../task-viewer/model/TaskViewerDefinition.ts |  18 ++
 .../model/TaskViewerTabParams.ts}             |   7 +-
 .../model/TaskViewerTabParamsDto.ts}          |   4 +-
 .../task-viewer/services/TaskViewerService.ts |  35 +++
 .../services/TaskViewerTabFactory.ts          |  37 +++
 .../workspace/WorkspaceModuleRegistrar.ts     |  16 +-
 .../workspace/service/WorkspaceService.ts     |   6 +-
 src/modules/workspace/tab/model/TabType.ts    |   1 +
 .../tab/service/SharedTabResolver.ts          |   8 +-
 src/vue-plugins/vuetify.ts                    |   4 +
 yarn.lock                                     |   8 +-
 92 files changed, 2079 insertions(+), 1627 deletions(-)
 create mode 100644 src/modules/backup-viewer/BackupViewerModuleRegistrar.ts
 create mode 100644 src/modules/backup-viewer/components/BackupCatalogDialog.vue
 create mode 100644 src/modules/backup-viewer/components/BackupViewer.vue
 create mode 100644 src/modules/backup-viewer/components/RestoreCatalogDialog.vue
 create mode 100644 src/modules/backup-viewer/model/BackupViewerDefinition.ts
 rename src/modules/{backups/model/BackupsTabParams.ts => backup-viewer/model/BackupViewerTabParams.ts} (74%)
 rename src/modules/{backups/model/BackupsTabParamsDto.ts => backup-viewer/model/BackupViewerTabParamsDto.ts} (81%)
 create mode 100644 src/modules/backup-viewer/service/BackupViewerService.ts
 create mode 100644 src/modules/backup-viewer/service/BackupViewerTabFactory.ts
 delete mode 100644 src/modules/backups/BackupsModuleRegistrar.ts
 delete mode 100644 src/modules/backups/components/BackupCatalog.vue
 delete mode 100644 src/modules/backups/components/Backups.vue
 delete mode 100644 src/modules/backups/components/RestoreCatalog.vue
 delete mode 100644 src/modules/backups/model/BackupsDefinition.ts
 delete mode 100644 src/modules/backups/service/BackupsService.ts
 delete mode 100644 src/modules/backups/service/BackupsTabFactory.ts
 create mode 100644 src/modules/base/component/VTabMainActionButton.vue
 rename src/modules/connection/driver/grpc/service/{TaskSimplifiedStateConverter.ts => TaskStateConverter.ts} (53%)
 rename src/modules/connection/driver/grpc/service/{JobsConverter.ts => TaskStatusConverter.ts} (85%)
 rename src/modules/connection/model/{data => }/CatalogVersionAtResponse.ts (74%)
 rename src/modules/connection/model/{data => data-type}/Currency.ts (100%)
 delete mode 100644 src/modules/connection/model/data/TaskSimplifiedState.ts
 rename src/modules/connection/model/{data => file}/File.ts (100%)
 rename src/modules/connection/model/{data => file}/FilesToFetch.ts (92%)
 rename src/modules/connection/model/{data => jfr}/EventType.ts (92%)
 rename src/modules/connection/model/{data => status}/ApiEndpoint.ts (100%)
 rename src/modules/connection/model/{data => status}/ApiReadiness.ts (100%)
 rename src/modules/connection/model/{data => status}/ApiServerStatus.ts (100%)
 rename src/modules/connection/model/{data => status}/ServerStatus.ts (100%)
 create mode 100644 src/modules/connection/model/task/TaskState.ts
 rename src/modules/connection/model/{data => task}/TaskStatus.ts (50%)
 rename src/modules/connection/model/{data => task}/TaskStatuses.ts (79%)
 delete mode 100644 src/modules/global/components/TabWindowBody.vue
 delete mode 100644 src/modules/jfr-recording/JfrModuleRegistrar.ts
 delete mode 100644 src/modules/jfr-recording/components/JfrEndRecord.vue
 delete mode 100644 src/modules/jfr-recording/components/JfrStartRecord.vue
 delete mode 100644 src/modules/jfr-recording/components/JfrVisualizer.vue
 delete mode 100644 src/modules/jfr-recording/model/JfrVisualizerDefinition.ts
 delete mode 100644 src/modules/jfr-recording/service/JfrService.ts
 delete mode 100644 src/modules/jfr-recording/service/JfrTabFactory.ts
 create mode 100644 src/modules/jfr-viewer/JfrViewerModuleRegistrar.ts
 create mode 100644 src/modules/jfr-viewer/components/EndJfrRecordingDialog.vue
 create mode 100644 src/modules/jfr-viewer/components/JfrViewer.vue
 create mode 100644 src/modules/jfr-viewer/components/StartJfrRecordingDialog.vue
 create mode 100644 src/modules/jfr-viewer/model/JfrViewerDefinition.ts
 rename src/modules/{jfr-recording/model/JfrVisualizerTabParams.ts => jfr-viewer/model/JfrViewerTabParams.ts} (62%)
 rename src/modules/{jobs/model/JobTabParamsDto.ts => jfr-viewer/model/JfrViewerTabParamsDto.ts} (74%)
 create mode 100644 src/modules/jfr-viewer/service/JfrViewerService.ts
 create mode 100644 src/modules/jfr-viewer/service/JfrViewerTabFactory.ts
 delete mode 100644 src/modules/jobs/JobModuleRegistrar.ts
 delete mode 100644 src/modules/jobs/components/JobVisualizer.vue
 delete mode 100644 src/modules/jobs/components/JobsControl.vue
 delete mode 100644 src/modules/jobs/model/JobDefinition.ts
 delete mode 100644 src/modules/jobs/services/JobService.ts
 delete mode 100644 src/modules/jobs/services/JobTabFactory.ts
 create mode 100644 src/modules/task-viewer/TaskViewerModuleRegistrar.ts
 create mode 100644 src/modules/task-viewer/components/TaskViewer.vue
 create mode 100644 src/modules/task-viewer/components/TasksVisualizer.vue
 create mode 100644 src/modules/task-viewer/model/TaskViewerDefinition.ts
 rename src/modules/{jobs/model/JobTabParams.ts => task-viewer/model/TaskViewerTabParams.ts} (69%)
 rename src/modules/{jfr-recording/model/JfrVisualizerTabParamsDto.ts => task-viewer/model/TaskViewerTabParamsDto.ts} (73%)
 create mode 100644 src/modules/task-viewer/services/TaskViewerService.ts
 create mode 100644 src/modules/task-viewer/services/TaskViewerTabFactory.ts

diff --git a/package.json b/package.json
index 4ff15889..3f19af15 100644
--- a/package.json
+++ b/package.json
@@ -54,7 +54,7 @@
     "vue-router": "^4.0.0",
     "vue-toastification": "^2.0.0-rc.5",
     "vue3-apexcharts": "^1.4.4",
-    "vuetify": "^3.1.0",
+    "vuetify": "^3.6.0",
     "webfontloader": "^1.0.0",
     "xml-formatter": "^3.5.0",
     "xxhashjs": "^0.2.2"
diff --git a/src/modules/backup-viewer/BackupViewerModuleRegistrar.ts b/src/modules/backup-viewer/BackupViewerModuleRegistrar.ts
new file mode 100644
index 00000000..027cbae7
--- /dev/null
+++ b/src/modules/backup-viewer/BackupViewerModuleRegistrar.ts
@@ -0,0 +1,14 @@
+import { ModuleContextBuilder } from "@/ModuleContextBuilder";
+import { ModuleRegistrar } from "@/ModuleRegistrar";
+import { BackupViewerService, backupViewerServiceInjectionKey } from "./service/BackupViewerService";
+import { ConnectionService, connectionServiceInjectionKey } from '@/modules/connection/service/ConnectionService'
+
+//TODO: docs
+export class BackupViewerModuleRegistrar implements ModuleRegistrar {
+
+    register(builder: ModuleContextBuilder): void {
+        const connectionService: ConnectionService = builder.inject(connectionServiceInjectionKey)
+        const backupViewerService: BackupViewerService = new BackupViewerService(connectionService)
+        builder.provide(backupViewerServiceInjectionKey, backupViewerService)
+    }
+}
diff --git a/src/modules/backup-viewer/components/BackupCatalogDialog.vue b/src/modules/backup-viewer/components/BackupCatalogDialog.vue
new file mode 100644
index 00000000..4a081dfc
--- /dev/null
+++ b/src/modules/backup-viewer/components/BackupCatalogDialog.vue
@@ -0,0 +1,141 @@
+<script setup lang="ts">
+import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
+import { computed, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import VFormDialog from '@/modules/base/component/VFormDialog.vue'
+import { DateTime } from 'luxon'
+import { Timestamp } from '@bufbuild/protobuf'
+import { BackupViewerService, useBackupViewerService } from '@/modules/backup-viewer/service/BackupViewerService'
+import { Connection } from '@/modules/connection/model/Connection'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import { CatalogVersionAtResponse } from '@/modules/connection/model/CatalogVersionAtResponse'
+
+const backupViewerService: BackupViewerService = useBackupViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = defineProps<{
+    modelValue: boolean,
+    connection: Connection,
+    catalogName: string
+}>()
+const emit = defineEmits<{
+    (e: 'update:modelValue', value: boolean): void,
+    (e: 'backup', date: string): void
+}>()
+
+const pastMomentRules = [
+    (value: any): any => {
+        if (value != undefined && value.trim().length > 0) return true
+        return t('backupViewer.backup.form.pastMoment.validations.required')
+    }
+]
+
+const minimalDate = ref<string | undefined>()
+const minimalDateLoaded = ref<boolean>(false)
+
+const pastMoment = ref<string>()
+const includeWal = ref<boolean>(false)
+const changed = computed<boolean>(() => pastMoment.value != undefined)
+
+async function loadMinimalDate(): Promise<CatalogVersionAtResponse> {
+    return await backupViewerService.getMinimalBackupDate(
+        props.connection,
+        props.catalogName
+    )
+}
+
+function reset(): void {
+    pastMoment.value = ''
+    includeWal.value = false
+}
+
+async function backup(): Promise<boolean> {
+    try {
+        // todo lho simplify
+        // todo lho verify date data type
+        const jsDate = new Date(pastMoment.value!)
+        const offsetDateTime: DateTime = DateTime.fromJSDate(jsDate)
+        const timestamp: Timestamp = Timestamp.fromDate(jsDate)
+
+        await backupViewerService.backupCatalog(
+            props.connection,
+            props.catalogName,
+            includeWal.value,
+            new OffsetDateTime(timestamp, offsetDateTime.toFormat('ZZ'))
+        )
+        toaster.success(t(
+            'backupViewer.backup.notification.backupRequested',
+            { catalogName: props.catalogName }
+        ))
+        return true
+    } catch (e: any) {
+        toaster.error(t(
+            'backupViewer.backup.notification.couldNotRequestBackup',
+            {
+                catalogName: props.catalogName,
+                reason: e.message
+            }
+        ))
+        return false
+    }
+}
+
+loadMinimalDate().then((catalogVersionAt) => {
+    minimalDate.value = catalogVersionAt.introducedAt.toString()
+    minimalDateLoaded.value = true
+})
+</script>
+
+<template>
+    <VFormDialog
+        :model-value="modelValue"
+        :changed="changed"
+        confirm-button-icon="mdi-cloud-download-outline"
+        :confirm="backup"
+        :reset="reset"
+        @update:model-value="emit('update:modelValue', $event)"
+    >
+        <template #title>
+            {{ t('backupViewer.backup.title') }}
+        </template>
+
+        <template #prepend-form>
+            <I18nT keypath="backupViewer.backup.description">
+                <template #catalogName>
+                    <strong>{{ catalogName }}</strong>
+                </template>
+            </I18nT>
+        </template>
+
+        <template #default>
+            <VDateInput
+                v-model="pastMoment"
+                :label="t('backupViewer.backup.form.pastMoment.label')"
+                :disabled="!minimalDateLoaded"
+                :min="minimalDate"
+                :max="new Date().toISOString()"
+                :rules="pastMomentRules"
+            />
+            <VCheckbox
+                v-model="includeWal"
+                :label="t('backupViewer.backup.form.includeWal.label')"
+                :messages="t('backupViewer.backup.form.includeWal.description')"
+            />
+        </template>
+
+        <template #append-form>
+            <VAlert type="info" icon="mdi-information-outline">
+                {{ t('backupViewer.backup.info') }}
+            </VAlert>
+        </template>
+
+        <template #confirm-button-body>
+            {{ t('backupViewer.backup.button.backup') }}
+        </template>
+    </VFormDialog>
+</template>
+
+<style scoped>
+
+</style>
diff --git a/src/modules/backup-viewer/components/BackupViewer.vue b/src/modules/backup-viewer/components/BackupViewer.vue
new file mode 100644
index 00000000..6adeaf50
--- /dev/null
+++ b/src/modules/backup-viewer/components/BackupViewer.vue
@@ -0,0 +1,286 @@
+<script setup lang="ts">
+import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
+import { List } from 'immutable'
+import { computed, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { VBtn, VIcon, VList } from 'vuetify/lib/components/index.mjs'
+import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
+import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
+import { backupTaskName, restoreTaskName, BackupViewerService, useBackupViewerService } from '../service/BackupViewerService'
+import { onUnmounted } from 'vue'
+import { BackupViewerTabParams } from '@/modules/backup-viewer/model/BackupViewerTabParams'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+import BackupCatalogDialog from '@/modules/backup-viewer/components/BackupCatalogDialog.vue'
+import VTabToolbar from '@/modules/base/component/VTabToolbar.vue'
+import VTabMainActionButton from '@/modules/base/component/VTabMainActionButton.vue'
+import { Command } from '@/modules/keymap/model/Command'
+import VActionTooltip from '@/modules/base/component/VActionTooltip.vue'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import TasksVisualizer from '@/modules/task-viewer/components/TasksVisualizer.vue'
+import { File } from '@/modules/connection/model/file/File'
+import RestoreCatalogDialog from '@/modules/backup-viewer/components/RestoreCatalogDialog.vue'
+
+const backupViewerService: BackupViewerService = useBackupViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const emit = defineEmits<TabComponentEvents>()
+const props = defineProps<TabComponentProps<BackupViewerTabParams, VoidTabData>>()
+
+const path: List<string> = List([t('backupViewer.path')])
+
+const initialized = ref<boolean>(false)
+
+const backupsIntervalId = setInterval(loadBackupFiles, 2000)
+
+onUnmounted(() => {
+    clearInterval(backupsIntervalId)
+})
+
+const showBackupCatalogDialog = ref<boolean>(false)
+const showRestoreCatalogDialog = ref<boolean>(false)
+const restoreBackupFile = ref<File | undefined>()
+
+const backupsInPreparationPresent = ref<boolean>(false)
+const backupFilesLoaded = ref<boolean>(false)
+const backupFiles = ref<FilesToFetch>()
+const backupFileItems = computed<File[]>(() => {
+    if (backupFiles.value == undefined) {
+        return []
+    }
+    return backupFiles.value.filesToFetch.toArray()
+})
+const pageNumber = ref<number>(1)
+const pageCount = computed<number>(() => {
+    if (backupFiles.value == undefined) {
+        return 1
+    }
+    return Math.ceil(backupFiles.value.totalNumberOfRecords / pageSize.value)
+})
+const pageSize = ref<number>(20)
+const file = ref<File>()
+
+loadBackupFiles().then(() => {
+    initialized.value = true
+    emit('ready')
+})
+
+watch(pageNumber, async () => {
+    await loadBackupFiles()
+})
+
+async function loadBackupFiles(): Promise<void> {
+    try {
+        backupFiles.value = await backupViewerService.getBackupFiles(
+            props.params.connection,
+            pageNumber.value,
+            pageSize.value
+        )
+        backupFilesLoaded.value = true
+    } catch (e: any) {
+        toaster.error(t(
+            'backupViewer.notification.couldNotLoadBackupFiles',
+            { reason: e.message }
+        ))
+    }
+}
+
+function showRestoreDialog(file: File): void {
+    restoreBackupFile.value = file
+    showRestoreCatalogDialog.value = true
+}
+
+function hideRestoreDialog(): void {
+    showRestoreCatalogDialog.value = false
+    restoreBackupFile.value = undefined
+}
+
+async function downloadBackup(file: File){
+    try {
+        const blob = await backupViewerService.downloadBackup(props.params.connection, file.fileId)
+
+        const downloadUrl = URL.createObjectURL(blob)
+        const link = document.createElement('a')
+        link.href = downloadUrl
+        link.download = file.name
+        document.body.appendChild(link)
+        link.click()
+    } catch (e: any) {
+        toaster.error(t(
+            'backupViewer.notification.couldNotDownloadBackupFile',
+            {
+                fileName: file.name,
+                reason: e.message
+            }
+        ))
+    }
+}
+
+// todo lho prototype for local file restore
+// async function upload(){
+//     await backupViewerService.uploadBackup(props.params.connection, sendCatalogChunks())
+// }
+//
+// async function* sendCatalogChunks(): AsyncIterable<GrpcRestoreCatalogRequest> {
+//     if (!file.value) {
+//         return;
+//     }
+//
+//     const CHUNK_SIZE = 64 * 1024; // 64 KB chunks
+//     const fileReader = new FileReader();
+//     let offset = 0;
+//     const totalSize = file.value.size;
+//
+//     // Helper function to read a chunk
+//     function readChunk() {
+//         if (offset >= totalSize) {
+//             fileReader.abort();
+//             return;
+//         }
+//         const chunk = file.value!.slice(offset, offset + CHUNK_SIZE);
+//         fileReader.readAsArrayBuffer(chunk);
+//     }
+//
+//     // Promise to handle the load of one chunk
+//     const onLoadPromise = () => {
+//         return new Promise<Uint8Array>((resolve, reject) => {
+//             fileReader.onload = (event: ProgressEvent<FileReader>) => {
+//                 if (event.target?.result) {
+//                     const arrayBuffer = event.target.result as ArrayBuffer;
+//                     const fileChunk = new Uint8Array(arrayBuffer);
+//                     offset += CHUNK_SIZE;
+//                     resolve(fileChunk);
+//                 }
+//             };
+//
+//             fileReader.onerror = () => {
+//                 console.error('Error reading file.');
+//                 fileReader.abort();
+//                 reject(new Error('Error reading file'));
+//             };
+//         });
+//     };
+//
+//     try {
+//         while (offset < totalSize) {
+//             readChunk();
+//             const chunk = await onLoadPromise();
+//             yield new GrpcRestoreCatalogRequest({
+//                 catalogName: 'random',
+//                 backupFile: chunk
+//             }); // Yield the chunk here
+//         }
+//     } catch (error) {
+//         console.error('Error during file upload:', error);
+//     }
+// }
+</script>
+
+<template>
+    <div v-if="initialized" class="backup-viewer">
+        <VTabToolbar prepend-icon="mdi-cloud-download-outline" :path="path">
+            <template #append>
+                <VTabMainActionButton @click="showBackupCatalogDialog = true">
+                    <VIcon>mdi-cloud-download-outline</VIcon>
+
+                    {{ t('backupViewer.button.backupCatalog') }}
+                </VTabMainActionButton>
+            </template>
+        </VTabToolbar>
+
+        <div>
+            <!--        todo lho add restore tasks -->
+            <TasksVisualizer
+                v-show="backupsInPreparationPresent"
+                :connection="params.connection"
+                :subheader="t('backupViewer.tasks.title')"
+                :states="[TaskState.Running, TaskState.Queued]"
+                :task-type="backupTaskName"
+                :page-size="5"
+                hideable-pagination
+                @update:active-jobs-present="backupsInPreparationPresent = $event"
+            />
+
+            <VList v-if="backupFilesLoaded">
+                <VListSubheader v-if="backupsInPreparationPresent">
+                    {{ t('backupViewer.list.title') }}
+                </VListSubheader>
+
+                <VDataIterator :items="backupFileItems" :page="pageNumber">
+                    <template #default="{ items }">
+                        <!--                    todo lho revise -->
+                        <VListItem v-for="item in items" :key="item.raw.fileId.code">
+                            <VRow class="align-center">
+                                <VCol>
+                                    <div class="d-flex align-center">
+                                        <VListItemTitle>{{ item.raw.name }}</VListItemTitle>
+                                        <VChip
+                                            color="grey"
+                                            text-color="white"
+                                            class="ml-2 small-chip"
+                                        >finished
+                                        </VChip
+                                        >
+                                    </div>
+                                </VCol>
+                                <VCol
+                                    class="d-flex justify-end"
+                                    cols="auto"
+                                    v-if="item.raw.created"
+                                >
+                                    <VBtn
+                                        icon="mdi-download"
+                                        variant="flat"
+                                        @click="downloadBackup(item.raw)"
+                                    />
+                                    <VBtn
+                                        icon="mdi-database-arrow-right-outline"
+                                        variant="flat"
+                                        @click="showRestoreDialog(item.raw)"
+                                    />
+                                </VCol>
+                                <VCol class="d-flex justify-end" cols="auto" v-else>
+                                    <!--                                todo lho what is this?-->
+                                    <VBtn
+                                        icon="mdi-window-close"
+                                        variant="flat"
+                                    />
+                                </VCol>
+                            </VRow>
+                        </VListItem>
+                    </template>
+
+                    <template #footer>
+                        <VPagination v-model="pageNumber" :length="pageCount" />
+                    </template>
+                </VDataIterator>
+            </VList>
+        </div>
+
+        <BackupCatalogDialog
+            v-if="showBackupCatalogDialog"
+            v-model="showBackupCatalogDialog"
+            :connection="params.connection"
+            :catalog-name="params.catalogName"
+        />
+        <RestoreCatalogDialog
+            v-if="showRestoreCatalogDialog"
+            :model-value="showRestoreCatalogDialog"
+            :connection="params.connection"
+            :file="restoreBackupFile!"
+            @update:model-value="hideRestoreDialog()"
+        />
+    </div>
+</template>
+
+<style lang="scss" scoped>
+.backup-viewer {
+    display: grid;
+    grid-template-rows: 3rem 1fr;
+
+    &__body {
+        position: relative;
+    }
+}
+</style>
diff --git a/src/modules/backup-viewer/components/RestoreCatalogDialog.vue b/src/modules/backup-viewer/components/RestoreCatalogDialog.vue
new file mode 100644
index 00000000..557f4558
--- /dev/null
+++ b/src/modules/backup-viewer/components/RestoreCatalogDialog.vue
@@ -0,0 +1,119 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import { computed, ref } from 'vue'
+import { File } from '@/modules/connection/model/file/File'
+import { Connection } from '@/modules/connection/model/Connection'
+import { BackupViewerService, useBackupViewerService } from '@/modules/backup-viewer/service/BackupViewerService'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import { ClassifierValidationErrorType } from '@/modules/connection/model/data-type/ClassifierValidationErrorType'
+import VFormDialog from '@/modules/base/component/VFormDialog.vue'
+
+const backupViewerService: BackupViewerService = useBackupViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = defineProps<{
+    modelValue: boolean,
+    connection: Connection,
+    file: File
+}>()
+const emit = defineEmits<{
+    (e: 'update:modelValue', value: boolean): void
+}>()
+
+
+const catalogNameRules = [
+    (value: string): any => {
+        if (value != undefined && value.trim().length > 0) return true
+        return t('backupViewer.restore.form.catalogName.validations.required')
+    },
+    async (value: string): Promise<any> => {
+        const classifierValidationResult : ClassifierValidationErrorType | undefined =
+            await backupViewerService.isCatalogNameValid(props.connection, value)
+        if (classifierValidationResult == undefined) return true
+        return t(`backupViewer.restore.form.catalogName.validations.${classifierValidationResult}`)
+    },
+    async (value: string): Promise<any> => {
+        const available: boolean = await backupViewerService.isCatalogNameAvailable(props.connection, value)
+        if (available) return true
+        return t('backupViewer.restore.form.catalogName.validations.notAvailable')
+    }
+]
+
+const catalogName = ref<string>('')
+const changed = computed<boolean>(() => catalogName.value != undefined && catalogName.value.length > 0)
+
+function reset(): void {
+    catalogName.value = ''
+}
+
+async function restore(): Promise<boolean> {
+    try {
+        await backupViewerService.restoreCatalog(
+            props.connection,
+            props.file.fileId,
+            catalogName.value
+        )
+        toaster.success(t(
+            'backupViewer.restore.notification.restoreRequested',
+            { fileName: props.file.name }
+        ))
+        return true
+    } catch (e: any) {
+        toaster.error(t(
+            'backupViewer.restore.notification.couldNotRestoreBackupFile',
+            {
+                fileName: props.file.name,
+                reason: e.message
+            }
+        ))
+        return false
+    }
+}
+</script>
+
+<template>
+    <VFormDialog
+        :model-value="modelValue"
+        :changed="changed"
+        confirm-button-icon="mdi-cloud-upload-outline"
+        :confirm="restore"
+        :reset="reset"
+        @update:model-value="emit('update:modelValue', $event)"
+    >
+        <template #title>
+            {{ t('backupViewer.restore.title') }}
+        </template>
+
+        <template #prepend-form>
+            <I18nT keypath="backupViewer.restore.description">
+                <template #fileName>
+                    <strong>{{ file.name }}</strong>
+                </template>
+            </I18nT>
+        </template>
+
+        <template #default>
+            <VTextField
+                v-model="catalogName"
+                :label="t('backupViewer.restore.form.catalogName.label')"
+                :rules="catalogNameRules"
+                required
+            />
+        </template>
+
+        <template #append-form>
+            <VAlert icon="mdi-information-outline" type="info">
+                {{ t('backupViewer.restore.info') }}
+            </VAlert>
+        </template>
+
+        <template #confirm-button-body>
+            {{ t('backupViewer.restore.button.restore') }}
+        </template>
+    </VFormDialog>
+</template>
+
+<style scoped>
+
+</style>
diff --git a/src/modules/backup-viewer/model/BackupViewerDefinition.ts b/src/modules/backup-viewer/model/BackupViewerDefinition.ts
new file mode 100644
index 00000000..2c287598
--- /dev/null
+++ b/src/modules/backup-viewer/model/BackupViewerDefinition.ts
@@ -0,0 +1,17 @@
+import { TabDefinition } from "@/modules/workspace/tab/model/TabDefinition";
+import { VoidTabData } from "@/modules/workspace/tab/model/void/VoidTabData";
+import { DefineComponent, markRaw } from "vue";
+import { BackupViewerTabParams } from '@/modules/backup-viewer/model/BackupViewerTabParams'
+import BackupViewer from '@/modules/backup-viewer/components/BackupViewer.vue'
+
+export class BackupViewerDefinition extends TabDefinition<BackupViewerTabParams, VoidTabData> {
+    constructor(title: string, params: BackupViewerTabParams) {
+        super(undefined,
+            title,
+            'mdi-cloud-download-outline',
+            markRaw(BackupViewer as DefineComponent<any, any, any>),
+            params,
+            new VoidTabData()
+        )
+    }
+}
diff --git a/src/modules/backups/model/BackupsTabParams.ts b/src/modules/backup-viewer/model/BackupViewerTabParams.ts
similarity index 74%
rename from src/modules/backups/model/BackupsTabParams.ts
rename to src/modules/backup-viewer/model/BackupViewerTabParams.ts
index 52144d7f..22a97644 100644
--- a/src/modules/backups/model/BackupsTabParams.ts
+++ b/src/modules/backup-viewer/model/BackupViewerTabParams.ts
@@ -1,9 +1,9 @@
 import { TabParams } from "@/modules/workspace/tab/model/TabParams";
-import { BackupsTabParamsDto } from "./BackupsTabParamsDto";
+import { BackupViewerTabParamsDto } from "./BackupViewerTabParamsDto";
 import { ExecutableTabRequest } from "@/modules/workspace/tab/model/ExecutableTabRequest";
 import { Connection } from "@/modules/connection/model/Connection";
 
-export class BackupTabParams implements TabParams<BackupsTabParamsDto>, ExecutableTabRequest {
+export class BackupViewerTabParams implements TabParams<BackupViewerTabParamsDto>, ExecutableTabRequest {
     readonly executeOnOpen: boolean
     readonly connection: Connection
     readonly catalogName: string
@@ -13,10 +13,10 @@ export class BackupTabParams implements TabParams<BackupsTabParamsDto>, Executab
         this.executeOnOpen = executeOnOpen
         this.catalogName = catalogName
     }
-    toSerializable(): BackupsTabParamsDto {
+    toSerializable(): BackupViewerTabParamsDto {
         return {
             connection: this.connection,
             catalogName: this.catalogName
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/backups/model/BackupsTabParamsDto.ts b/src/modules/backup-viewer/model/BackupViewerTabParamsDto.ts
similarity index 81%
rename from src/modules/backups/model/BackupsTabParamsDto.ts
rename to src/modules/backup-viewer/model/BackupViewerTabParamsDto.ts
index 63ab05dc..88e78201 100644
--- a/src/modules/backups/model/BackupsTabParamsDto.ts
+++ b/src/modules/backup-viewer/model/BackupViewerTabParamsDto.ts
@@ -2,7 +2,7 @@ import { Connection } from "@/modules/connection/model/Connection";
 import { TabDataDto } from "@/modules/workspace/tab/model/TabDataDto";
 import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
 
-export interface BackupsTabParamsDto extends TabParamsDto {
+export interface BackupViewerTabParamsDto extends TabParamsDto {
     readonly connection: Connection
     readonly catalogName: string
 }
diff --git a/src/modules/backup-viewer/service/BackupViewerService.ts b/src/modules/backup-viewer/service/BackupViewerService.ts
new file mode 100644
index 00000000..db098002
--- /dev/null
+++ b/src/modules/backup-viewer/service/BackupViewerService.ts
@@ -0,0 +1,104 @@
+import { Connection } from '@/modules/connection/model/Connection'
+import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
+import { Uuid } from '@/modules/connection/model/data-type/Uuid'
+import { mandatoryInject } from '@/utils/reactivity'
+import { InjectionKey } from 'vue'
+import {
+    GrpcRestoreCatalogRequest,
+    GrpcRestoreCatalogResponse
+} from '@/modules/connection/driver/grpc/gen/GrpcEvitaManagementAPI_pb'
+import { ConnectionService } from '@/modules/connection/service/ConnectionService'
+import { CatalogVersionAtResponse } from '@/modules/connection/model/CatalogVersionAtResponse'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { ClassifierValidationErrorType } from '@/modules/connection/model/data-type/ClassifierValidationErrorType'
+import { EvitaDBDriver } from '@/modules/connection/driver/EvitaDBDriver'
+import { ClassifierType } from '@/modules/connection/model/data-type/ClassifierType'
+import { UnexpectedError } from '@/modules/base/exception/UnexpectedError'
+
+export const backupViewerServiceInjectionKey: InjectionKey<BackupViewerService> = Symbol('backupViewerService')
+
+export const backupTaskName: string = 'BackupTask'
+export const restoreTaskName: string = 'RestoreTask'
+
+export class BackupViewerService {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService) {
+        this.connectionService = connectionService
+    }
+
+    async getMinimalBackupDate(
+        connection: Connection,
+        catalogName: string
+    ): Promise<CatalogVersionAtResponse> {
+        const driver = await this.connectionService.getDriver(connection)
+        return driver.getMinimalBackupDate(connection, catalogName)
+    }
+
+    async backupCatalog(
+        connection: Connection,
+        catalogName: string,
+        includingWAL: boolean,
+        pastMoment: OffsetDateTime
+    ): Promise<TaskStatus> {
+        const driver = await this.connectionService.getDriver(connection)
+        return driver.createBackup(
+            connection,
+            catalogName,
+            includingWAL,
+            pastMoment
+        )
+    }
+
+    async getBackupFiles(
+        connection: Connection,
+        pageNumber: number,
+        pageSize: number
+    ): Promise<FilesToFetch> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.getFilesToFetch(connection, backupTaskName, pageNumber, pageSize)
+    }
+
+    async restoreCatalog(
+        connection: Connection,
+        fileId: Uuid,
+        catalogName: string
+    ): Promise<TaskStatus> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.restoreCatalog(connection, fileId, catalogName)
+    }
+
+    async downloadBackup(connection: Connection, fileId: Uuid): Promise<Blob> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.downloadFile(connection, fileId)
+    }
+
+    async uploadBackup(connection: Connection, stream: AsyncIterable<GrpcRestoreCatalogRequest>): Promise<GrpcRestoreCatalogResponse>{
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.uploadFile(connection, stream)
+    }
+
+    async isCatalogNameValid(connection: Connection, catalogName: string): Promise<ClassifierValidationErrorType | undefined> {
+        const driver: EvitaDBDriver = await this.connectionService.getDriver(connection)
+        return driver.isClassifierValid(connection, ClassifierType.Catalog, catalogName)
+    }
+
+    async isCatalogNameAvailable(connection: Connection, catalogName: string): Promise<boolean> {
+        const driver: EvitaDBDriver = await this.connectionService.getDriver(connection)
+        try {
+            await driver.getCatalog(connection, catalogName)
+        } catch (e) {
+            // todo lho better exceptions
+            if (e instanceof UnexpectedError) {
+                // catalog not found
+                return true
+            }
+        }
+        return false
+    }
+}
+
+export const useBackupViewerService = (): BackupViewerService => {
+    return mandatoryInject(backupViewerServiceInjectionKey) as BackupViewerService
+}
diff --git a/src/modules/backup-viewer/service/BackupViewerTabFactory.ts b/src/modules/backup-viewer/service/BackupViewerTabFactory.ts
new file mode 100644
index 00000000..eb00a176
--- /dev/null
+++ b/src/modules/backup-viewer/service/BackupViewerTabFactory.ts
@@ -0,0 +1,36 @@
+import { Connection } from "@/modules/connection/model/Connection";
+import { ConnectionService } from "@/modules/connection/service/ConnectionService";
+import { mandatoryInject } from "@/utils/reactivity";
+import { InjectionKey } from "vue";
+import { BackupViewerDefinition } from "../model/BackupViewerDefinition";
+import { TabParamsDto } from "@/modules/workspace/tab/model/TabParamsDto";
+import { TabDataDto } from "@/modules/workspace/tab/model/TabDataDto";
+import { BackupViewerTabParamsDto } from "../model/BackupViewerTabParamsDto";
+import { BackupViewerTabParams } from '@/modules/backup-viewer/model/BackupViewerTabParams'
+
+export const backupsTabFactoryInjectionKey: InjectionKey<BackupViewerTabFactory> = Symbol('BackupsTabFactory')
+
+export class BackupViewerTabFactory {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService){
+        this.connectionService = connectionService
+    }
+
+    createNew(connection: Connection, catalogName: string, executeOnOpen: boolean = false):BackupViewerDefinition {
+        return new BackupViewerDefinition('Backups', this.createTabParams(connection, catalogName, executeOnOpen))
+    }
+
+    private createTabParams(connection: Connection, catalogName: string, executeOnOpen: boolean = false):BackupViewerTabParams {
+        return new BackupViewerTabParams(connection, catalogName, executeOnOpen)
+    }
+
+    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabDataDto): BackupViewerDefinition {
+        const params: BackupViewerTabParamsDto = paramsJson as BackupViewerTabParams
+        return new BackupViewerDefinition('Backups', this.createTabParams(this.connectionService.getConnection(params.connection.id), params.catalogName))
+    }
+}
+
+export const useBackupsTabFactory = (): BackupViewerTabFactory => {
+    return mandatoryInject(backupsTabFactoryInjectionKey) as BackupViewerTabFactory
+}
diff --git a/src/modules/backups/BackupsModuleRegistrar.ts b/src/modules/backups/BackupsModuleRegistrar.ts
deleted file mode 100644
index ade16d73..00000000
--- a/src/modules/backups/BackupsModuleRegistrar.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { ModuleContextBuilder } from "@/ModuleContextBuilder";
-import { ModuleRegistrar } from "@/ModuleRegistrar";
-import { EvitaDBDriverResolver, evitaDBDriverResolverInjectionKey } from "../connection/driver/EvitaDBDriverResolver";
-import { BackupsService, backupsServiceInjectionKey } from "./service/BackupsService";
-
-//TODO: docs
-export class BackupsModuleRegistrar implements ModuleRegistrar {
-    register(builder: ModuleContextBuilder): void {
-        const evitaDBDriverResolver: EvitaDBDriverResolver = builder.inject(evitaDBDriverResolverInjectionKey)
-        const backupService: BackupsService = new BackupsService(evitaDBDriverResolver)
-        builder.provide(backupsServiceInjectionKey, backupService)
-    }
-
-}
\ No newline at end of file
diff --git a/src/modules/backups/components/BackupCatalog.vue b/src/modules/backups/components/BackupCatalog.vue
deleted file mode 100644
index d87b2029..00000000
--- a/src/modules/backups/components/BackupCatalog.vue
+++ /dev/null
@@ -1,86 +0,0 @@
-<template>
-    <VDialog v-model="visibleAddBackup" class="w-25" @update:model-value="isExit">
-        <VCard>
-            <VCardTitleWithActions>
-                <template #default>
-                    {{
-                        t('backups.createDialog.titleFirst') +
-                        `"${catalogName}"` +
-                        t('backups.createDialog.titleSecond')
-                    }}
-                </template>
-            </VCardTitleWithActions>
-            <VCardText>
-                <VDateInput
-                    v-model="selectedDate"
-                    :min="minimalDate?.toString()"
-                    :max="new Date().toISOString()"
-                />
-                <VCheckbox
-                    label="Include WAL"
-                    messages="Will apply all mutations from WAL during restoration resulting in the latest version of catalog"
-                />
-                <VAlert
-                    type="info"
-                    icon="mdi-information-outline"
-                    :text="t('backups.createDialog.information')"
-                    class="mt-4"
-                />
-                <div class="mt-4 buttons">
-                    <VBtn
-                        variant="elevated"
-                        :text="t('common.button.cancel')"
-                        @click="exit()"
-                    ></VBtn>
-                    <VBtn variant="outlined" @click="backup">
-                        <VIcon>mdi-cloud-download-outline</VIcon>
-                        {{ t('common.button.backup') }}
-                    </VBtn>
-                </div>
-            </VCardText>
-        </VCard>
-    </VDialog>
-</template>
-
-<script setup lang="ts">
-import VCardTitleWithActions from '@/modules/base/component/VCardTitleWithActions.vue'
-import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
-import { ref } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { VDateInput } from 'vuetify/lib/labs/components.mjs'
-
-const { t } = useI18n()
-
-const visibleAddBackup = ref<boolean>(true)
-const selectedDate = ref<string>()
-const props = defineProps<{
-    catalogName: string
-    minimalDate: OffsetDateTime
-}>()
-const emit = defineEmits<{
-    (e: 'exit'): void
-    (e: 'backup', date: string): void
-}>()
-
-function exit():void {
-    emit('exit')
-}
-
-function backup():void {
-    if (selectedDate.value) emit('backup', selectedDate.value!)
-}
-
-function isExit(visible: boolean):void{
-    if(!visible){
-        emit('exit')
-    }
-}
-</script>
-
-<style scoped>
-.buttons {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-}
-</style>
diff --git a/src/modules/backups/components/Backups.vue b/src/modules/backups/components/Backups.vue
deleted file mode 100644
index 5de59cbb..00000000
--- a/src/modules/backups/components/Backups.vue
+++ /dev/null
@@ -1,262 +0,0 @@
-<template>
-    <TabWindowBody
-        icon="mdi-cloud-download-outline"
-        :path="path"
-        :visible-button="true"
-        @top-button-click="() => (visibleAddBackup = !visibleAddBackup)"
-    >
-        <JobVisualizer
-            :connection="props.params.connection"
-            @task-ended="getAllBackupFiles"
-            :simplified-state="[
-                TaskSimplifiedState.TaskRunning,
-                TaskSimplifiedState.TaskQueued,
-            ]"
-            task-type="BackupTask"
-        />
-        <VList>
-            <VListItem
-                v-for="item in backupFiles?.filesToFetch"
-                :key="item.fileId.code"
-            >
-                <VRow class="align-center">
-                    <VCol>
-                        <div class="d-flex align-center">
-                            <VListItemTitle>{{ item.name }}</VListItemTitle>
-                            <VChip
-                                color="grey"
-                                text-color="white"
-                                class="ml-2 small-chip"
-                            >finished
-                            </VChip
-                            >
-                        </div>
-                    </VCol>
-                    <VCol
-                        class="d-flex justify-end"
-                        cols="auto"
-                        v-if="item.created"
-                    >
-                        <VBtn icon variant="flat" @click="downloadBackup(item.fileId, item.name)">
-                            <VIcon>mdi-download</VIcon>
-                        </VBtn>
-                        <VBtn
-                            icon
-                            variant="flat"
-                            @click="showRestoreDialog(item.fileId)"
-                        >
-                            <VIcon>mdi-database-arrow-right-outline</VIcon>
-                        </VBtn>
-                    </VCol>
-                    <VCol class="d-flex justify-end" cols="auto" v-else>
-                        <VBtn icon variant="flat">
-                            <VIcon>mdi-window-close</VIcon>
-                        </VBtn>
-                    </VCol>
-                </VRow>
-            </VListItem>
-        </VList>
-        <VPagination
-            v-if="
-                backupFiles?.totalNumberOfRecords &&
-                Math.ceil(backupFiles?.totalNumberOfRecords / pageSize) > 1
-            "
-            :rounded="true"
-            @update:model-value="(x) => (pageNumber = x)"
-            :length="Math.ceil(backupFiles?.totalNumberOfRecords! / pageSize)"
-        >
-        </VPagination>
-        <BackupDialog
-            :catalog-name="props.params.catalogName"
-            :minimal-date="minimalDate!"
-            @exit="() => (visibleAddBackup = false)"
-            @backup="backup"
-            v-if="visibleAddBackup"
-        />
-        <RestoreCatalog
-            @exit="() => (visibleRestoreCatalog = !visibleRestoreCatalog)"
-            @restore="restoreBackup"
-            v-if="visibleRestoreCatalog"
-        />
-    </TabWindowBody>
-</template>
-
-<script setup lang="ts">
-import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
-import { List } from 'immutable'
-import { ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { VBtn, VIcon, VList } from 'vuetify/lib/components/index.mjs'
-import { BackupTabParams } from '../model/BackupsTabParams'
-import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
-import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
-import { BackupsService, useBackupsService } from '../service/BackupsService'
-import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
-import { DateTime } from 'luxon'
-import { Timestamp } from '@bufbuild/protobuf'
-import { UnexpectedError } from '@/modules/base/exception/UnexpectedError'
-import { FilesToFetch } from '@/modules/connection/model/data/FilesToFetch'
-import TabWindowBody from '@/modules/global/components/TabWindowBody.vue'
-import JobVisualizer from '@/modules/jobs/components/JobVisualizer.vue'
-import { TaskSimplifiedState } from '@/modules/connection/model/data/TaskSimplifiedState'
-import BackupDialog from './BackupCatalog.vue'
-import RestoreCatalog from './RestoreCatalog.vue'
-import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import { GrpcRestoreCatalogRequest } from '@/modules/connection/driver/grpc/gen/GrpcEvitaManagementAPI_pb'
-import { onUnmounted } from 'vue'
-
-const emit = defineEmits<TabComponentEvents>()
-const props = defineProps<TabComponentProps<BackupTabParams, VoidTabData>>()
-const { t } = useI18n()
-const backupService: BackupsService = useBackupsService()
-
-const path: List<string> = List([t('backups.path')])
-const visibleAddBackup = ref<boolean>(false)
-const visibleRestoreCatalog = ref<boolean>(false)
-const restoreBackupFileId = ref<Uuid>()
-const minimalDateLoaded = ref<boolean>(false)
-const minimalDate = ref<OffsetDateTime>()
-const backupFilesLoaded = ref<boolean>(false)
-const backupFiles = ref<FilesToFetch>()
-const includingWAL = ref<boolean>(false)
-const pageNumber = ref<number>(1)
-const pageSize = ref<number>(10)
-const file = ref<File>()
-
-getMinimalDate().then(() => checkAllDataLoaded())
-getAllBackupFiles().then(() => checkAllDataLoaded())
-
-watch(pageNumber, async () => {
-    await getAllBackupFiles()
-})
-
-async function getMinimalDate(): Promise<void> {
-    const minimalDateResponse = await backupService.getMinimalBackupDate(
-        props.params.connection,
-        props.params.catalogName
-    )
-    minimalDate.value = minimalDateResponse.introducedAt
-    minimalDateLoaded.value = true
-}
-
-async function getAllBackupFiles(): Promise<void> {
-    const files = await backupService.getAllBackups(
-        props.params.connection,
-        pageNumber.value,
-        pageSize.value
-    )
-    backupFiles.value = files
-    backupFilesLoaded.value = true
-}
-
-async function backup(selectedDate: string): Promise<void> {
-    const jsDate = new Date(selectedDate)
-    const offsetDateTime = DateTime.fromJSDate(jsDate)
-    const timestamp = Timestamp.fromDate(jsDate)
-    const result = await backupService.backupCatalog(
-        props.params.connection,
-        props.params.catalogName,
-        includingWAL.value,
-        new OffsetDateTime(timestamp, offsetDateTime.toFormat('ZZ'))
-    )
-    if (!result.exception) {
-        visibleAddBackup.value = false
-    } else throw new UnexpectedError(result.exception)
-}
-
-function checkAllDataLoaded(): void {
-    if (backupFilesLoaded.value && minimalDateLoaded.value) emit('ready')
-}
-
-function showRestoreDialog(fileId: Uuid): void {
-    restoreBackupFileId.value = fileId
-    visibleRestoreCatalog.value = true
-}
-
-async function restoreBackup(catalogName: string) {
-    const result = await backupService.restoreCatalog(
-        props.params.connection,
-        catalogName,
-        restoreBackupFileId.value!
-    )
-    if (!result.exception) {
-        visibleRestoreCatalog.value = false
-    } else throw new UnexpectedError(result.exception)
-}
-
-async function downloadBackup(fileId: Uuid, name: string){
-    const blob = await backupService.downloadBackup(props.params.connection, fileId)
-    const downloadUrl = URL.createObjectURL(blob)
-    const link = document.createElement('a');
-    link.href = downloadUrl;
-    link.download = name;
-    document.body.appendChild(link);
-    link.click();
-}
-
-async function upload(){
-    await backupService.uploadBackup(props.params.connection, sendCatalogChunks())
-}
-
-async function* sendCatalogChunks(): AsyncIterable<GrpcRestoreCatalogRequest> {
-    if (!file.value) {
-        return;
-    }
-
-    const CHUNK_SIZE = 64 * 1024; // 64 KB chunks
-    const fileReader = new FileReader();
-    let offset = 0;
-    const totalSize = file.value.size;
-
-    // Helper function to read a chunk
-    function readChunk() {
-        if (offset >= totalSize) {
-            fileReader.abort();
-            return;
-        }
-        const chunk = file.value!.slice(offset, offset + CHUNK_SIZE);
-        fileReader.readAsArrayBuffer(chunk);
-    }
-
-    // Promise to handle the load of one chunk
-    const onLoadPromise = () => {
-        return new Promise<Uint8Array>((resolve, reject) => {
-            fileReader.onload = (event: ProgressEvent<FileReader>) => {
-                if (event.target?.result) {
-                    const arrayBuffer = event.target.result as ArrayBuffer;
-                    const fileChunk = new Uint8Array(arrayBuffer);
-                    offset += CHUNK_SIZE;
-                    resolve(fileChunk);
-                }
-            };
-
-            fileReader.onerror = () => {
-                console.error('Error reading file.');
-                fileReader.abort();
-                reject(new Error('Error reading file'));
-            };
-        });
-    };
-
-    try {
-        while (offset < totalSize) {
-            readChunk();
-            const chunk = await onLoadPromise();
-            yield new GrpcRestoreCatalogRequest({
-                catalogName: 'random',
-                backupFile: chunk
-            }); // Yield the chunk here
-        }
-    } catch (error) {
-        console.error('Error during file upload:', error);
-    }
-}
-
-const backupsIntervalId = setInterval(getAllBackupFiles, 2000)
-
-onUnmounted(() => {
-    clearInterval(backupsIntervalId)
-})
-</script>
-
-<style scoped></style>
diff --git a/src/modules/backups/components/RestoreCatalog.vue b/src/modules/backups/components/RestoreCatalog.vue
deleted file mode 100644
index 7eea26ae..00000000
--- a/src/modules/backups/components/RestoreCatalog.vue
+++ /dev/null
@@ -1,62 +0,0 @@
-<template>
-    <VDialog v-model="visibleRestoreCatalog" class="w-25">
-        <VCard>
-            <VCardTitleWithActions>
-                <template #default>
-                    {{ t('backups.restoreDialog.title') }}
-                </template>
-            </VCardTitleWithActions>
-            <VCardText>
-                <VTextField :label="t('backups.restoreDialog.catalogName')" v-model="newCatalogName" />
-                <VAlert
-                    icon="mdi-information-outline"
-                    type="info"
-                    :text="t('backups.restoreDialog.infoAlert')"
-                />
-                <div class="mt-4 buttons">
-                    <VBtn
-                        :text="t('common.button.cancel')"
-                        @click="close"
-                    ></VBtn>
-                    <VBtn variant="outlined" @click="restore">
-                        <VIcon>mdi-cloud-upload-outline</VIcon>
-                        {{ t('common.button.restore') }}
-                    </VBtn>
-                </div>
-            </VCardText>
-        </VCard>
-    </VDialog>
-</template>
-
-<script setup lang="ts">
-import VCardTitleWithActions from '@/modules/base/component/VCardTitleWithActions.vue'
-import { useI18n } from 'vue-i18n'
-import { ref } from 'vue'
-
-const { t } = useI18n()
-
-const visibleRestoreCatalog = ref<boolean>(true)
-const newCatalogName = ref<string>('')
-
-const emit = defineEmits<{
-    (e: 'restore', newCatalogName: string): void
-    (e: 'exit'): void
-}>()
-
-function close() {
-    visibleRestoreCatalog.value = false
-    emit('exit')
-}
-
-function restore(){
-    emit('restore', newCatalogName.value)
-}
-</script>
-
-<style scoped>
-.buttons {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-}
-</style>
diff --git a/src/modules/backups/model/BackupsDefinition.ts b/src/modules/backups/model/BackupsDefinition.ts
deleted file mode 100644
index f461b3c6..00000000
--- a/src/modules/backups/model/BackupsDefinition.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { TabDefinition } from "@/modules/workspace/tab/model/TabDefinition";
-import { BackupTabParams } from "./BackupsTabParams";
-import { VoidTabData } from "@/modules/workspace/tab/model/void/VoidTabData";
-import { DefineComponent, markRaw } from "vue";
-import Backups from "../components/Backups.vue";
-
-export class BackupsDefinition extends TabDefinition<BackupTabParams, VoidTabData> {
-    constructor(title: string, params: BackupTabParams) {
-        super(undefined,
-            title,
-            'mdi-cloud-download-outline',
-            markRaw(Backups as DefineComponent<any, any, any>),
-            params,
-            new VoidTabData()
-        )
-    }
-}
diff --git a/src/modules/backups/service/BackupsService.ts b/src/modules/backups/service/BackupsService.ts
deleted file mode 100644
index 4c9d648a..00000000
--- a/src/modules/backups/service/BackupsService.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { EvitaDBDriverResolver } from '@/modules/connection/driver/EvitaDBDriverResolver'
-import { Connection } from '@/modules/connection/model/Connection'
-import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
-import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import { CatalogVersionAtResponse } from '@/modules/connection/model/data/CatalogVersionAtResponse'
-import { FilesToFetch } from '@/modules/connection/model/data/FilesToFetch'
-import { TaskStatus } from '@/modules/connection/model/data/TaskStatus'
-import { mandatoryInject } from '@/utils/reactivity'
-import { InjectionKey } from 'vue'
-import {
-    GrpcRestoreCatalogRequest,
-    GrpcRestoreCatalogResponse
-} from '@/modules/connection/driver/grpc/gen/GrpcEvitaManagementAPI_pb'
-
-export const backupsServiceInjectionKey: InjectionKey<BackupsService> =
-    Symbol('backupsService')
-
-export class BackupsService {
-    private readonly evitaDBDriverResolver: EvitaDBDriverResolver
-
-    constructor(evitaDBDriver: EvitaDBDriverResolver) {
-        this.evitaDBDriverResolver = evitaDBDriver
-    }
-
-    async getMinimalBackupDate(
-        connection: Connection,
-        catalogName: string
-    ): Promise<CatalogVersionAtResponse> {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(
-            connection
-        )
-        return driver.getMinimalBackupDate(connection, catalogName)
-    }
-
-    async backupCatalog(
-        connection: Connection,
-        catalogName: string,
-        includingWAL: boolean,
-        pastMoment: OffsetDateTime
-    ): Promise<TaskStatus> {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(
-            connection
-        )
-        return driver.createBackup(
-            connection,
-            catalogName,
-            includingWAL,
-            pastMoment
-        )
-    }
-
-    async getAllBackups(
-        connection: Connection,
-        pageNumber: number,
-        pageSize: number
-    ): Promise<FilesToFetch> {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(
-            connection
-        )
-        return await driver.getBackups(connection, pageNumber, pageSize)
-    }
-
-    async restoreCatalog(
-        connection: Connection,
-        catalogName: string,
-        fileId: Uuid
-    ) {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(
-            connection
-        )
-        return await driver.restoreCatalog(connection, catalogName, fileId)
-    }
-
-    async downloadBackup(connection: Connection, fileId: Uuid){
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.downloadFile(connection, fileId)
-    }
-
-    async uploadBackup(connection: Connection, stream: AsyncIterable<GrpcRestoreCatalogRequest>):Promise<GrpcRestoreCatalogResponse>{
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.uploadFile(connection, stream)
-    }
-}
-
-export const useBackupsService = (): BackupsService => {
-    return mandatoryInject(backupsServiceInjectionKey) as BackupsService
-}
diff --git a/src/modules/backups/service/BackupsTabFactory.ts b/src/modules/backups/service/BackupsTabFactory.ts
deleted file mode 100644
index d3e1f491..00000000
--- a/src/modules/backups/service/BackupsTabFactory.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { Connection } from "@/modules/connection/model/Connection";
-import { ConnectionService } from "@/modules/connection/service/ConnectionService";
-import { mandatoryInject } from "@/utils/reactivity";
-import { InjectionKey } from "vue";
-import { BackupsDefinition } from "../model/BackupsDefinition";
-import { BackupTabParams } from "../model/BackupsTabParams";
-import { TabParamsDto } from "@/modules/workspace/tab/model/TabParamsDto";
-import { TabDataDto } from "@/modules/workspace/tab/model/TabDataDto";
-import { BackupsTabParamsDto } from "../model/BackupsTabParamsDto";
-
-export const backupsTabFactoryInjectionKey: InjectionKey<BackupsTabFactory> = Symbol('BackupsTabFactory')
-
-export class BackupsTabFactory {
-    private readonly connectionService: ConnectionService
-
-    constructor(connectionService: ConnectionService){
-        this.connectionService = connectionService
-    }
-
-    createNew(connection: Connection, catalogName: string, executeOnOpen: boolean = false):BackupsDefinition {
-        return new BackupsDefinition('Backups', this.createTabParams(connection, catalogName, executeOnOpen))
-    }
-
-    private createTabParams(connection: Connection, catalogName: string, executeOnOpen: boolean = false):BackupTabParams {
-        return new BackupTabParams(connection, catalogName, executeOnOpen)
-    }
-
-    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabDataDto): BackupsDefinition {
-        const params: BackupsTabParamsDto = paramsJson as BackupTabParams
-        return new BackupsDefinition('Backups', this.createTabParams(this.connectionService.getConnection(params.connection.id), params.catalogName))
-    }
-}
-
-export const useBackupsTabFactory = (): BackupsTabFactory => {
-    return mandatoryInject(backupsTabFactoryInjectionKey) as BackupsTabFactory
-}
\ No newline at end of file
diff --git a/src/modules/base/component/VExecuteQueryButton.vue b/src/modules/base/component/VExecuteQueryButton.vue
index b9069648..4dfd99e9 100644
--- a/src/modules/base/component/VExecuteQueryButton.vue
+++ b/src/modules/base/component/VExecuteQueryButton.vue
@@ -1,6 +1,7 @@
 <script setup lang="ts">
 
 import { useI18n } from 'vue-i18n'
+import VTabMainActionButton from '@/modules/base/component/VTabMainActionButton.vue'
 
 const { t } = useI18n()
 
@@ -18,12 +19,7 @@ const emit = defineEmits<{
 </script>
 
 <template>
-    <VBtn
-        :loading="loading"
-        density="compact"
-        @click="emit('click')"
-        class="v-btn--variant-primary ml-3"
-    >
+    <VTabMainActionButton :loading="loading" @click="emit('click')">
         <VIcon>mdi-play-outline</VIcon>
 
         <slot>
@@ -32,7 +28,7 @@ const emit = defineEmits<{
             </VTooltip>
             {{ t('common.button.run') }}
         </slot>
-    </VBtn>
+    </VTabMainActionButton>
 </template>
 
 <style lang="scss" scoped>
diff --git a/src/modules/base/component/VFormDialog.vue b/src/modules/base/component/VFormDialog.vue
index 4d02aed6..bec72eff 100644
--- a/src/modules/base/component/VFormDialog.vue
+++ b/src/modules/base/component/VFormDialog.vue
@@ -17,6 +17,7 @@ const props = withDefaults(
         modelValue: boolean,
         changed?: boolean,
         dangerous?: boolean,
+        scrollable?: boolean,
         confirmButtonIcon?: string,
         confirm: () => Promise<boolean>,
         reset?: () => void,
@@ -24,6 +25,7 @@ const props = withDefaults(
     }>(),
     {
         changed: false,
+        scrollable: false,
         dangerous: false,
         confirmButtonIcon: 'mdi-check',
         reset: () => {},
@@ -71,7 +73,12 @@ async function confirm(): Promise<void> {
 </script>
 
 <template>
-    <VLabDialog :model-value="modelValue" :max-width="maxWidth" persistent>
+    <VLabDialog
+        :model-value="modelValue"
+        :max-width="maxWidth"
+        :scrollable="scrollable"
+        persistent
+    >
         <template #activator="{ props }">
             <slot name="activator" v-bind="{ props }"/>
         </template>
diff --git a/src/modules/base/component/VTabMainActionButton.vue b/src/modules/base/component/VTabMainActionButton.vue
new file mode 100644
index 00000000..4412ba4f
--- /dev/null
+++ b/src/modules/base/component/VTabMainActionButton.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+/**
+ * Pre-defined button representing the main action of tab (in the tab toolbar)
+ */
+
+const props = withDefaults(defineProps<{
+    loading?: boolean
+}>(), {
+    loading: false
+})
+const emit = defineEmits<{
+    (e: 'click'): void
+}>()
+</script>
+
+<template>
+    <VBtn
+        :loading="loading"
+        density="compact"
+        @click="emit('click')"
+        class="v-btn--variant-primary ml-3"
+    >
+        <slot />
+    </VBtn>
+</template>
+
+<style lang="scss" scoped>
+
+</style>
diff --git a/src/modules/base/component/VTabToolbar.vue b/src/modules/base/component/VTabToolbar.vue
index 939be21e..ae625807 100644
--- a/src/modules/base/component/VTabToolbar.vue
+++ b/src/modules/base/component/VTabToolbar.vue
@@ -67,7 +67,7 @@ const normalizedFlags = computed<List<Flag>>(() => {
         <template #append>
             <slot name="append"/>
         </template>
-        <template #extension>
+        <template v-if="$slots['extension']" #extension>
             <slot name="extension"/>
         </template>
     </VToolbar>
diff --git a/src/modules/connection/driver/EvitaDBDriver.ts b/src/modules/connection/driver/EvitaDBDriver.ts
index 6d48d59c..78139c47 100644
--- a/src/modules/connection/driver/EvitaDBDriver.ts
+++ b/src/modules/connection/driver/EvitaDBDriver.ts
@@ -3,22 +3,22 @@ import { Connection } from '@/modules/connection/model/Connection'
 import { CatalogSchema } from '@/modules/connection/model/schema/CatalogSchema'
 import { Response } from '@/modules/connection/model/data/Response'
 import { List } from 'immutable'
-import { ServerStatus } from '../model/data/ServerStatus'
-import { ApiReadiness } from '../model/data/ApiReadiness'
-import { ApiServerStatus } from '../model/data/ApiServerStatus'
 import { ClassifierValidationErrorType } from '@/modules/connection/model/data-type/ClassifierValidationErrorType'
 import { ClassifierType } from '@/modules/connection/model/data-type/ClassifierType'
-import { CatalogVersionAtResponse } from '../model/data/CatalogVersionAtResponse'
 import { OffsetDateTime } from '../model/data-type/OffsetDateTime'
-import { TaskStatus } from '../model/data/TaskStatus'
-import { FilesToFetch } from '../model/data/FilesToFetch'
-import { TaskStatuses } from '../model/data/TaskStatuses'
-import { TaskSimplifiedState } from '../model/data/TaskSimplifiedState'
 import { Uuid } from '../model/data-type/Uuid'
 import {
     GrpcRestoreCatalogRequest, GrpcRestoreCatalogResponse
 } from '@/modules/connection/driver/grpc/gen/GrpcEvitaManagementAPI_pb'
-import { EventType } from '@/modules/connection/model/data/EventType'
+import { ServerStatus } from '@/modules/connection/model/status/ServerStatus'
+import { ApiReadiness } from '@/modules/connection/model/status/ApiReadiness'
+import { ApiServerStatus } from '@/modules/connection/model/status/ApiServerStatus'
+import { CatalogVersionAtResponse } from '@/modules/connection/model/CatalogVersionAtResponse'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+import { TaskStatuses } from '@/modules/connection/model/task/TaskStatuses'
+import { EventType } from '@/modules/connection/model/jfr/EventType'
 
 /**
  * evitaDB version-agnostic driver to access data from connected evitaDB server
@@ -85,10 +85,7 @@ export interface EvitaDBDriver {
     replaceCatalog(connection: Connection, catalogNameToBeReplacedWith: string, catalogNameToBeReplaced: string): Promise<boolean>
     switchCatalogToAliveState(connection: Connection, catalogName: string): Promise<boolean>
 //TODO: Add doc
-    getMinimalBackupDate(
-        connection: Connection,
-        catalogName: string
-    ): Promise<CatalogVersionAtResponse>
+    getMinimalBackupDate(connection: Connection, catalogName: string): Promise<CatalogVersionAtResponse>
     //TODO: Add doc
     createBackup(
         connection: Connection,
@@ -97,27 +94,19 @@ export interface EvitaDBDriver {
         pastMoment: OffsetDateTime
     ): Promise<TaskStatus>
     //TODO: Add doc
-    getBackups(
-        connection: Connection,
-        pageNumber: number,
-        pageSize: number
-    ): Promise<FilesToFetch>
+    getFilesToFetch(connection: Connection, origin: string, pageNumber: number, pageSize: number): Promise<FilesToFetch>
     //TODO: Add doc
-    getActiveJobs(
+    getTaskStatuses(
         connection: Connection,
         pageNumber: number,
         pageSize: number,
-        simplifiedState?: TaskSimplifiedState[],
+        states?: TaskState[],
         taskType?: string
     ): Promise<TaskStatuses>
     //TODO: Add doc
-    restoreCatalog(
-        connection: Connection,
-        catalogName: string,
-        fileId: Uuid
-    ): Promise<TaskStatus>
+    restoreCatalog(connection: Connection, fileId: Uuid, catalogName: string): Promise<TaskStatus>
     //TODO: Add doc
-    cancelJob(connection: Connection, taskId: Uuid): Promise<boolean>
+    cancelTask(connection: Connection, taskId: Uuid): Promise<boolean>
     //TODO: Add doc
     getJfrRecords(connection: Connection, pageNumber: number, pageSize: number): Promise<FilesToFetch>
     //TODO: Add doc
diff --git a/src/modules/connection/driver/grpc/EvitaDBDriverGrpc.ts b/src/modules/connection/driver/grpc/EvitaDBDriverGrpc.ts
index 814fcaa6..5e3f71bd 100644
--- a/src/modules/connection/driver/grpc/EvitaDBDriverGrpc.ts
+++ b/src/modules/connection/driver/grpc/EvitaDBDriverGrpc.ts
@@ -12,7 +12,6 @@ import { Value } from '../../model/Value'
 import { EntitySchema } from '../../model/schema/EntitySchema'
 import {
     GrpcCatalogSchemaResponse,
-    GrpcDefineEntitySchemaResponse,
     GrpcCatalogVersionAtResponse,
     GrpcDeleteCollectionResponse, GrpcGoLiveAndCloseResponse, GrpcRenameCollectionResponse
 } from '@/modules/connection/driver/grpc/gen/GrpcEvitaSessionAPI_pb'
@@ -25,20 +24,10 @@ import { ClientProvider, EvitaSessionClient } from './service/ClientProvider'
 import { EntityConverter } from './service/EntityConverter'
 import { EvitaValueConverter } from './service/EvitaValueConverter'
 import { ExtraResultConverter } from './service/ExtraResultConverter'
-import { ServerStatus } from '../../model/data/ServerStatus'
 import { ServerStatusConverter } from './service/ServerStatusConverter'
 import ky from 'ky'
-import { ApiReadiness } from '../../model/data/ApiReadiness'
-import { ApiServerStatus } from '../../model/data/ApiServerStatus'
 import { OffsetDateTime } from '../../model/data-type/OffsetDateTime'
-import { CatalogVersionAtResponse } from '../../model/data/CatalogVersionAtResponse'
-import { TaskStatus } from '../../model/data/TaskStatus'
-import { FilesToFetch } from '../../model/data/FilesToFetch'
-import { BackupConverter } from './service/BackupConverter'
-import { JobsConverter } from './service/JobsConverter'
-import { TaskStatuses } from '../../model/data/TaskStatuses'
-import { TaskSimplifiedState } from '../../model/data/TaskSimplifiedState'
-import { TaskSimplifiedStateConverter } from './service/TaskSimplifiedStateConverter'
+import { TaskStateConverter } from './service/TaskStateConverter'
 import { GrpcDefineCatalogResponse } from '@/modules/connection/driver/grpc/gen/GrpcEvitaAPI_pb'
 import { EvitaSessionProvider } from '@/modules/connection/driver/grpc/service/EvitaSessionProvider'
 import { ConnectError } from '@connectrpc/connect'
@@ -53,7 +42,17 @@ import {
     GrpcRestoreCatalogRequest,
     GrpcRestoreCatalogResponse
 } from '@/modules/connection/driver/grpc/gen/GrpcEvitaManagementAPI_pb'
-import { EventType } from '@/modules/connection/model/data/EventType'
+import { BackupConverter } from '@/modules/connection/driver/grpc/service/BackupConverter'
+import { TaskStatusConverter } from '@/modules/connection/driver/grpc/service/TaskStatusConverter'
+import { ServerStatus } from '@/modules/connection/model/status/ServerStatus'
+import { ApiReadiness } from '@/modules/connection/model/status/ApiReadiness'
+import { ApiServerStatus } from '@/modules/connection/model/status/ApiServerStatus'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
+import { CatalogVersionAtResponse } from '@/modules/connection/model/CatalogVersionAtResponse'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { TaskStatuses } from '@/modules/connection/model/task/TaskStatuses'
+import { EventType } from '@/modules/connection/model/jfr/EventType'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
 
 //TODO: Add docs and add header 'X-EvitaDB-ClientID': this.getClientIdHeaderValue()
 export class EvitaDBDriverGrpc implements EvitaDBDriver {
@@ -72,16 +71,13 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
     private _responseConverter?: ResponseConverter
     private _serverStatusConverter?: ServerStatusConverter
     private _reservedKeywordsConverter?: ReservedKeywordsConverter
-    private _taskSimplifiedStateConverter?: TaskSimplifiedStateConverter
+    private _taskStateConverter?: TaskStateConverter
     private _backupConverter?: BackupConverter
-    private _jobsConverter?: JobsConverter
+    private _taskStatusConverter?: TaskStatusConverter
 
     private reservedKeywords?: Immutable.Map<ClassifierType, Immutable.List<Keyword>>
 
-    async getCatalogSchema(
-        connection: Connection,
-        catalogName: string
-    ): Promise<CatalogSchema> {
+    async getCatalogSchema(connection: Connection, catalogName: string): Promise<CatalogSchema> {
         try {
             const schemaRes: GrpcCatalogSchemaResponse =
                 await this.evitaSessionProvider.executeInReadOnlySession(
@@ -469,76 +465,6 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
         )
     }
 
-    private get evitaValueConverter(): EvitaValueConverter {
-        if (this._evitaValueConverter == undefined) {
-            this._evitaValueConverter = new EvitaValueConverter()
-        }
-        return this._evitaValueConverter
-    }
-
-    private get entityConverter(): EntityConverter {
-        if (this._entityConverter == undefined) {
-            this._entityConverter = new EntityConverter(this.evitaValueConverter)
-        }
-        return this._entityConverter
-    }
-
-    private get extraResultConverter(): ExtraResultConverter {
-        if (this._extraResultConverter == undefined) {
-            this._extraResultConverter = new ExtraResultConverter(this.entityConverter)
-        }
-        return this._extraResultConverter
-    }
-
-    private get catalogSchemaConverter(): CatalogSchemaConverter {
-        if (this._catalogSchemaConverter == undefined) {
-            this._catalogSchemaConverter = new CatalogSchemaConverter(this.evitaValueConverter)
-        }
-        return this._catalogSchemaConverter
-    }
-
-    private get catalogConverter(): CatalogConverter {
-        if (this._catalogConverter == undefined) {
-            this._catalogConverter = new CatalogConverter()
-        }
-        return this._catalogConverter
-    }
-
-    private get responseConverter(): ResponseConverter {
-        if (this._responseConverter == undefined) {
-            this._responseConverter = new ResponseConverter(this.entityConverter, this.extraResultConverter)
-        }
-        return this._responseConverter
-    }
-
-    private get serverStatusConverter(): ServerStatusConverter {
-        if (this._serverStatusConverter == undefined) {
-            this._serverStatusConverter = new ServerStatusConverter()
-        }
-        return this._serverStatusConverter
-    }
-
-    private get clientProvider(): ClientProvider {
-        if (this._clientProvider == undefined) {
-            this._clientProvider = new ClientProvider()
-        }
-        return this._clientProvider
-    }
-
-    private get evitaSessionProvider(): EvitaSessionProvider {
-        if (this._evitaSessionProvider == undefined) {
-            this._evitaSessionProvider = new EvitaSessionProvider(this.clientProvider)
-        }
-        return this._evitaSessionProvider
-    }
-
-    private get reservedKeywordsConverter(): ReservedKeywordsConverter {
-        if (this._reservedKeywordsConverter == undefined) {
-            this._reservedKeywordsConverter = new ReservedKeywordsConverter()
-        }
-        return this._reservedKeywordsConverter
-    }
-
     private isClassifierKeyword(classifierType: ClassifierType, classifier: string): boolean {
         if (classifier.trim().length === 0) {
             return false
@@ -558,23 +484,6 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
         return reservedKeywords.findIndex(it => it.equals(normalizedClassifier)) > -1
     }
 
-    // todo lho this shouldnt exist, component should call getCatalogs on new session
-    async downloadCatalogsSameSession(
-        connection: Connection,
-        sessionId: string
-    ): Promise<Catalog[]> {
-        const resultData = (
-            await this.clientProvider
-                .getEvitaManagementClient(connection)
-                .getCatalogStatistics(Empty, {
-                    headers: {
-                        sessionId
-                    }
-                })
-        ).catalogStatistics
-        return resultData.map((x) => this.catalogConverter.convert(x))
-    }
-
     async createBackup(
         connection: Connection,
         catalogName: string,
@@ -629,32 +538,26 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
         )
     }
 
-    async getBackups(
-        connection: Connection,
-        pageNumber: number,
-        pageSize: number = 50
-    ): Promise<FilesToFetch> {
+    async getFilesToFetch(connection: Connection, origin: string, pageNumber: number, pageSize: number): Promise<FilesToFetch> {
         const result = await this.clientProvider
             .getEvitaManagementClient(connection)
             .listFilesToFetch({
-                origin: 'BackupTask',
+                origin,
                 pageNumber,
                 pageSize
             })
-        return this.backupConverter.convertFilesTofetch(result)
+        return this.backupConverter.convertFilesToFetch(result)
     }
 
-    async getActiveJobs(
+    async getTaskStatuses(
         connection: Connection,
         pageNumber: number,
         pageSize: number,
-        simplifiedState?: TaskSimplifiedState[],
+        states?: TaskState[],
         taskType?: string
     ): Promise<TaskStatuses> {
-        const params = simplifiedState && simplifiedState.length > 0
-            ? this.taskSimplifiedStateConverter.convertTaskStatesToGrpc(
-                simplifiedState
-            )
+        const params = states && states.length > 0
+            ? this.taskStateConverter.convertTaskStatesToGrpc(states)
             : []
         const result = await this.clientProvider
             .getEvitaManagementClient(connection)
@@ -664,7 +567,7 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
                 taskType,
                 simplifiedState: params
             })
-        const jobs = this.jobsConverter.convertJobs(result)
+        const jobs = this.taskStatusConverter.convertJobs(result)
         return jobs
     }
 
@@ -675,7 +578,7 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
             pageSize
         })
 
-        return this.backupConverter.convertFilesTofetch(result)
+        return this.backupConverter.convertFilesToFetch(result)
     }
 
     async stopJfrRecording(connection: Connection):Promise<boolean> {
@@ -717,8 +620,8 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
 
     async restoreCatalog(
         connection: Connection,
-        catalogName: string,
-        fileId: Uuid
+        fileId: Uuid,
+        catalogName: string
     ): Promise<TaskStatus> {
         const result = await this.clientProvider
             .getEvitaManagementClient(connection)
@@ -729,10 +632,10 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
                     mostSignificantBits: fileId.mostSignificantBits
                 }
             })
-        return this.jobsConverter.convertJob(result.task!)
+        return this.taskStatusConverter.convertJob(result.task!)
     }
 
-    async cancelJob(connection: Connection, taskId: Uuid): Promise<boolean> {
+    async cancelTask(connection: Connection, taskId: Uuid): Promise<boolean> {
         const result = await this.clientProvider.getEvitaManagementClient(connection).cancelTask({
             taskId: {
                 leastSignificantBits: taskId.leastSignificantBits,
@@ -742,28 +645,99 @@ export class EvitaDBDriverGrpc implements EvitaDBDriver {
         return result.success
     }
 
-    private get taskSimplifiedStateConverter(): TaskSimplifiedStateConverter {
-        if (this._taskSimplifiedStateConverter == undefined) {
-            this._taskSimplifiedStateConverter = new TaskSimplifiedStateConverter()
+
+    private get evitaValueConverter(): EvitaValueConverter {
+        if (this._evitaValueConverter == undefined) {
+            this._evitaValueConverter = new EvitaValueConverter()
+        }
+        return this._evitaValueConverter
+    }
+
+    private get entityConverter(): EntityConverter {
+        if (this._entityConverter == undefined) {
+            this._entityConverter = new EntityConverter(this.evitaValueConverter)
+        }
+        return this._entityConverter
+    }
+
+    private get extraResultConverter(): ExtraResultConverter {
+        if (this._extraResultConverter == undefined) {
+            this._extraResultConverter = new ExtraResultConverter(this.entityConverter)
+        }
+        return this._extraResultConverter
+    }
+
+    private get catalogSchemaConverter(): CatalogSchemaConverter {
+        if (this._catalogSchemaConverter == undefined) {
+            this._catalogSchemaConverter = new CatalogSchemaConverter(this.evitaValueConverter)
+        }
+        return this._catalogSchemaConverter
+    }
+
+    private get catalogConverter(): CatalogConverter {
+        if (this._catalogConverter == undefined) {
+            this._catalogConverter = new CatalogConverter()
+        }
+        return this._catalogConverter
+    }
+
+    private get responseConverter(): ResponseConverter {
+        if (this._responseConverter == undefined) {
+            this._responseConverter = new ResponseConverter(this.entityConverter, this.extraResultConverter)
+        }
+        return this._responseConverter
+    }
+
+    private get serverStatusConverter(): ServerStatusConverter {
+        if (this._serverStatusConverter == undefined) {
+            this._serverStatusConverter = new ServerStatusConverter()
+        }
+        return this._serverStatusConverter
+    }
+
+    private get clientProvider(): ClientProvider {
+        if (this._clientProvider == undefined) {
+            this._clientProvider = new ClientProvider()
+        }
+        return this._clientProvider
+    }
+
+    private get evitaSessionProvider(): EvitaSessionProvider {
+        if (this._evitaSessionProvider == undefined) {
+            this._evitaSessionProvider = new EvitaSessionProvider(this.clientProvider)
+        }
+        return this._evitaSessionProvider
+    }
+
+    private get reservedKeywordsConverter(): ReservedKeywordsConverter {
+        if (this._reservedKeywordsConverter == undefined) {
+            this._reservedKeywordsConverter = new ReservedKeywordsConverter()
+        }
+        return this._reservedKeywordsConverter
+    }
+
+    private get taskStateConverter(): TaskStateConverter {
+        if (this._taskStateConverter == undefined) {
+            this._taskStateConverter = new TaskStateConverter()
         }
-        return this._taskSimplifiedStateConverter
+        return this._taskStateConverter
     }
 
     private get backupConverter(): BackupConverter {
         if (this._backupConverter == undefined) {
             this._backupConverter = new BackupConverter(
-                this.taskSimplifiedStateConverter
+                this.taskStateConverter
             )
         }
         return this._backupConverter
     }
-    private get jobsConverter(): JobsConverter {
-        if (this._jobsConverter == undefined) {
-            this._jobsConverter = new JobsConverter(
-                this.taskSimplifiedStateConverter
+    private get taskStatusConverter(): TaskStatusConverter {
+        if (this._taskStatusConverter == undefined) {
+            this._taskStatusConverter = new TaskStatusConverter(
+                this.taskStateConverter
             )
         }
-        return this._jobsConverter
+        return this._taskStatusConverter
     }
 
     private handleCallError(e: any, connection?: Connection): LabError {
diff --git a/src/modules/connection/driver/grpc/service/BackupConverter.ts b/src/modules/connection/driver/grpc/service/BackupConverter.ts
index 32d75e15..f92069c3 100644
--- a/src/modules/connection/driver/grpc/service/BackupConverter.ts
+++ b/src/modules/connection/driver/grpc/service/BackupConverter.ts
@@ -1,21 +1,22 @@
 import { Uuid } from "@/modules/connection/model/data-type/Uuid"
 import { GrpcFilesToFetchResponse } from "../gen/GrpcEvitaManagementAPI_pb"
 import Immutable from "immutable"
-import { FilesToFetch } from "@/modules/connection/model/data/FilesToFetch"
-import { File } from "@/modules/connection/model/data/File"
 import { OffsetDateTime } from "@/modules/connection/model/data-type/OffsetDateTime"
 import { GrpcBackupCatalogResponse } from "../gen/GrpcEvitaSessionAPI_pb"
-import { TaskStatus } from "@/modules/connection/model/data/TaskStatus"
-import { TaskSimplifiedStateConverter } from "./TaskSimplifiedStateConverter"
+import { TaskStateConverter } from "./TaskStateConverter"
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { File } from '@/modules/connection/model/file/File'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
 
+// todo lho revise and refactor
 export class BackupConverter {
-    readonly taskConverter: TaskSimplifiedStateConverter
+    readonly taskConverter: TaskStateConverter
 
-    constructor(taskConverter: TaskSimplifiedStateConverter) {
+    constructor(taskConverter: TaskStateConverter) {
         this.taskConverter = taskConverter
     }
 
-    convertFilesTofetch(result: GrpcFilesToFetchResponse) {
+    convertFilesToFetch(result: GrpcFilesToFetchResponse) {
         const files: File[] = []
         for (const file of result.filesToFetch) {
             files.push(
@@ -44,7 +45,7 @@ export class BackupConverter {
 
     convertBackupCatalog(result: GrpcBackupCatalogResponse){
         const status = result.taskStatus?.result
-        let value: File | string
+        let value: File | string | undefined
         if (status?.case === 'text') {
             value = status.value.value
         } else {
@@ -92,4 +93,4 @@ export class BackupConverter {
             this.taskConverter.convertTaskState(taskStatus?.simplifiedState!)
         )
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/connection/driver/grpc/service/CatalogSchemaConverter.ts b/src/modules/connection/driver/grpc/service/CatalogSchemaConverter.ts
index c227efa3..06d1a7fb 100644
--- a/src/modules/connection/driver/grpc/service/CatalogSchemaConverter.ts
+++ b/src/modules/connection/driver/grpc/service/CatalogSchemaConverter.ts
@@ -12,8 +12,7 @@ import { AttributeSchema } from '@/modules/connection/model/schema/AttributeSche
 import {
     GrpcAttributeSchemaType,
     GrpcAttributeUniquenessType,
-    GrpcCardinality, GrpcEvitaAssociatedDataDataType, GrpcEvitaAssociatedDataDataType_GrpcEvitaDataType,
-    GrpcEvitaDataType,
+    GrpcCardinality,
     GrpcEvolutionMode,
     GrpcGlobalAttributeUniquenessType,
     GrpcOrderBehaviour,
@@ -46,11 +45,11 @@ import {
     SortableAttributeCompoundSchema
 } from '@/modules/connection/model/schema/SortableAttributeCompoundSchema'
 import { AssociatedDataSchema } from '@/modules/connection/model/schema/AssociatedDataSchema'
-import { Currency } from '@/modules/connection/model/data/Currency'
 import { Locale } from '@/modules/connection/model/data-type/Locale'
 import { ScalarConverter } from './ScalarConverter'
 import { MapUtil } from '../utils/MapUtil'
 import { EvitaValueConverter } from './EvitaValueConverter'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 //TODO: Add documentation
 export class CatalogSchemaConverter {
diff --git a/src/modules/connection/driver/grpc/service/EntityConverter.ts b/src/modules/connection/driver/grpc/service/EntityConverter.ts
index 940ce3dd..4f569ad5 100644
--- a/src/modules/connection/driver/grpc/service/EntityConverter.ts
+++ b/src/modules/connection/driver/grpc/service/EntityConverter.ts
@@ -29,10 +29,10 @@ import { PriceInnerRecordHandling } from '@/modules/connection/model/data-type/P
 import { EntityReference } from '@/modules/connection/model/data/EntityReference'
 import { Cardinality } from '@/modules/connection/model/schema/Cardinality'
 import Immutable from 'immutable'
-import { Currency } from '@/modules/connection/model/data/Currency'
 import { EvitaValueConverter } from './EvitaValueConverter'
 import { AssociatedData } from '@/modules/connection/model/data/AssociatedData'
 import { UnexpectedError } from '@/modules/base/exception/UnexpectedError'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 //TODO: Add documentation
 export class EntityConverter {
diff --git a/src/modules/connection/driver/grpc/service/EvitaValueConverter.ts b/src/modules/connection/driver/grpc/service/EvitaValueConverter.ts
index 1226a457..0502e815 100644
--- a/src/modules/connection/driver/grpc/service/EvitaValueConverter.ts
+++ b/src/modules/connection/driver/grpc/service/EvitaValueConverter.ts
@@ -10,7 +10,6 @@ import { LocalTime } from '@/modules/connection/model/data-type/LocalTime'
 import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
 import { Predecessor } from '@/modules/connection/model/data-type/Predecessor'
 import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import { Currency } from '@/modules/connection/model/data/Currency'
 import Immutable from 'immutable'
 import {
     GrpcBigDecimal,
@@ -41,6 +40,7 @@ import {
 import { DateTime } from 'luxon'
 import { Range } from '@/modules/connection/model/data-type/Range'
 import { GrpcEvitaDataType } from '../gen/GrpcEnums_pb'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 /**
  * Convert gRPC evita value server representation into local evitaLab typescript representation
diff --git a/src/modules/connection/driver/grpc/service/ServerStatusConverter.ts b/src/modules/connection/driver/grpc/service/ServerStatusConverter.ts
index befd9fdc..822c8f44 100644
--- a/src/modules/connection/driver/grpc/service/ServerStatusConverter.ts
+++ b/src/modules/connection/driver/grpc/service/ServerStatusConverter.ts
@@ -1,7 +1,7 @@
-import { ServerStatus } from "@/modules/connection/model/data/ServerStatus";
 import { GrpcEvitaServerStatusResponse } from "../gen/GrpcEvitaManagementAPI_pb";
 import { OffsetDateTime } from "@/modules/connection/model/data-type/OffsetDateTime";
 import { GrpcOffsetDateTime } from "../gen/GrpcEvitaDataTypes_pb";
+import { ServerStatus } from '@/modules/connection/model/status/ServerStatus'
 
 export class ServerStatusConverter {
     convert(serverStatus: GrpcEvitaServerStatusResponse):ServerStatus{
@@ -21,4 +21,4 @@ export class ServerStatusConverter {
             offsetDateTime.offset
         )
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/connection/driver/grpc/service/TaskSimplifiedStateConverter.ts b/src/modules/connection/driver/grpc/service/TaskStateConverter.ts
similarity index 53%
rename from src/modules/connection/driver/grpc/service/TaskSimplifiedStateConverter.ts
rename to src/modules/connection/driver/grpc/service/TaskStateConverter.ts
index e21b6eed..f5039bd5 100644
--- a/src/modules/connection/driver/grpc/service/TaskSimplifiedStateConverter.ts
+++ b/src/modules/connection/driver/grpc/service/TaskStateConverter.ts
@@ -1,16 +1,17 @@
-import { TaskSimplifiedState } from "@/modules/connection/model/data/TaskSimplifiedState"
 import { GrpcTaskSimplifiedState } from "../gen/GrpcEnums_pb"
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+// todo lho refactor
+export class TaskStateConverter {
 
-export class TaskSimplifiedStateConverter {
-    convertTaskStates(taskStates: GrpcTaskSimplifiedState[]):TaskSimplifiedState[] {
-        const statuses: TaskSimplifiedState[] = []
+    convertTaskStates(taskStates: GrpcTaskSimplifiedState[]):TaskState[] {
+        const statuses: TaskState[] = []
         for(const status of taskStates) {
             statuses.push(this.convertTaskState(status))
-        } 
+        }
         return statuses
     }
 
-    convertTaskStatesToGrpc(taskStates: TaskSimplifiedState[]): GrpcTaskSimplifiedState[] {
+    convertTaskStatesToGrpc(taskStates: TaskState[]): GrpcTaskSimplifiedState[] {
         const statuses: GrpcTaskSimplifiedState[] = [];
         for (const status of taskStates) {
             statuses.push(this.convertTaskStateToGrpc(status))
@@ -18,29 +19,29 @@ export class TaskSimplifiedStateConverter {
         return statuses;
     }
 
-    convertTaskStateToGrpc(status: TaskSimplifiedState):GrpcTaskSimplifiedState{
+    convertTaskStateToGrpc(status: TaskState):GrpcTaskSimplifiedState{
         switch (status) {
-            case TaskSimplifiedState.TaskFailed:
+            case TaskState.Failed:
                 return GrpcTaskSimplifiedState.TASK_FAILED
-            case TaskSimplifiedState.TaskFinished:
+            case TaskState.Finished:
                 return GrpcTaskSimplifiedState.TASK_FINISHED
-            case TaskSimplifiedState.TaskQueued:
+            case TaskState.Queued:
                 return GrpcTaskSimplifiedState.TASK_QUEUED
-            case TaskSimplifiedState.TaskRunning:
+            case TaskState.Running:
                 return GrpcTaskSimplifiedState.TASK_RUNNING
         }
     }
 
-    convertTaskState(status: GrpcTaskSimplifiedState):TaskSimplifiedState{
+    convertTaskState(status: GrpcTaskSimplifiedState):TaskState{
         switch(status){
             case GrpcTaskSimplifiedState.TASK_FAILED:
-                return TaskSimplifiedState.TaskFailed
+                return TaskState.Failed
             case GrpcTaskSimplifiedState.TASK_FINISHED:
-                return TaskSimplifiedState.TaskFinished
+                return TaskState.Finished
             case GrpcTaskSimplifiedState.TASK_QUEUED:
-                return TaskSimplifiedState.TaskQueued
+                return TaskState.Queued
             case GrpcTaskSimplifiedState.TASK_RUNNING:
-                return TaskSimplifiedState.TaskRunning
+                return TaskState.Running
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/connection/driver/grpc/service/JobsConverter.ts b/src/modules/connection/driver/grpc/service/TaskStatusConverter.ts
similarity index 85%
rename from src/modules/connection/driver/grpc/service/JobsConverter.ts
rename to src/modules/connection/driver/grpc/service/TaskStatusConverter.ts
index c371955e..05ef9cd2 100644
--- a/src/modules/connection/driver/grpc/service/JobsConverter.ts
+++ b/src/modules/connection/driver/grpc/service/TaskStatusConverter.ts
@@ -1,19 +1,19 @@
-import { TaskStatuses } from '@/modules/connection/model/data/TaskStatuses'
 import { GrpcFilesToFetchResponse, GrpcTaskStatusesResponse } from '../gen/GrpcEvitaManagementAPI_pb'
-import { TaskStatus } from '@/modules/connection/model/data/TaskStatus'
 import { GrpcFile, GrpcTaskStatus } from '../gen/GrpcEvitaDataTypes_pb'
 import { Uuid } from '@/modules/connection/model/data-type/Uuid'
 import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
 import { List } from 'immutable'
-import { File } from '@/modules/connection/model/data/File'
 import { StringValue } from '@bufbuild/protobuf'
-import { TaskSimplifiedStateConverter } from './TaskSimplifiedStateConverter'
-import { UnexpectedError } from '@/modules/base/exception/UnexpectedError'
+import { TaskStateConverter } from './TaskStateConverter'
+import { TaskStatuses } from '@/modules/connection/model/task/TaskStatuses'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
+import { File } from '@/modules/connection/model/file/File'
 
-export class JobsConverter {
-    private readonly taskConverter: TaskSimplifiedStateConverter
+// todo lho refactor
+export class TaskStatusConverter {
+    private readonly taskConverter: TaskStateConverter
 
-    constructor(taskConverter: TaskSimplifiedStateConverter) {
+    constructor(taskConverter: TaskStateConverter) {
         this.taskConverter = taskConverter
     }
 
diff --git a/src/modules/connection/explorer/component/CatalogItem.vue b/src/modules/connection/explorer/component/CatalogItem.vue
index b6bee0d3..847f5d4f 100644
--- a/src/modules/connection/explorer/component/CatalogItem.vue
+++ b/src/modules/connection/explorer/component/CatalogItem.vue
@@ -38,16 +38,16 @@ import CreateCollectionDialog from '@/modules/connection/explorer/component/Crea
 import SwitchCatalogToAliveStateDialog
     from '@/modules/connection/explorer/component/SwitchCatalogToAliveStateDialog.vue'
 import {
-    BackupsTabFactory,
+    BackupViewerTabFactory,
     useBackupsTabFactory,
-} from '@/modules/backups/service/BackupsTabFactory'
+} from '@/modules/backup-viewer/service/BackupViewerTabFactory'
 
 const evitaLabConfig: EvitaLabConfig = useEvitaLabConfig()
 const workspaceService: WorkspaceService = useWorkspaceService()
 const evitaQLConsoleTabFactory: EvitaQLConsoleTabFactory = useEvitaQLConsoleTabFactory()
 const graphQLConsoleTabFactory: GraphQLConsoleTabFactory = useGraphQLConsoleTabFactory()
 const schemaViewerTabFactory: SchemaViewerTabFactory = useSchemaViewerTabFactory()
-const backupsService: BackupsTabFactory = useBackupsTabFactory()
+const backupsService: BackupViewerTabFactory = useBackupsTabFactory()
 const { t } = useI18n()
 
 const props = defineProps<{
diff --git a/src/modules/connection/explorer/component/ConnectionItem.vue b/src/modules/connection/explorer/component/ConnectionItem.vue
index dbc35d1c..1f3f3bd7 100644
--- a/src/modules/connection/explorer/component/ConnectionItem.vue
+++ b/src/modules/connection/explorer/component/ConnectionItem.vue
@@ -30,16 +30,16 @@ import {
     useServerStatusTabFactory
 } from '@/modules/server-status/service/ServerStatusTabFactory'
 import CreateCatalogDialog from '@/modules/connection/explorer/component/CreateCatalogDialog.vue'
-import { JobTabFactory, useJobTabFactory } from '@/modules/jobs/services/JobTabFactory'
-import { JfrTabFactory, useJfrTabFactory } from '@/modules/jfr-recording/service/JfrTabFactory'
+import { TaskViewerTabFactory, useTaskViewerTabFactory } from '@/modules/task-viewer/services/TaskViewerTabFactory'
+import { JfrViewerTabFactory, useJfrViewerTabFactory } from '@/modules/jfr-viewer/service/JfrViewerTabFactory'
 
 const evitaLabConfig: EvitaLabConfig = useEvitaLabConfig()
 const workspaceService: WorkspaceService = useWorkspaceService()
 const connectionService: ConnectionService = useConnectionService()
 const graphQLConsoleTabFactory: GraphQLConsoleTabFactory = useGraphQLConsoleTabFactory()
 const serverStatusTabFactory: ServerStatusTabFactory = useServerStatusTabFactory()
-const jobTabFactory: JobTabFactory = useJobTabFactory()
-const jfrTabFactory: JfrTabFactory = useJfrTabFactory()
+const taskViewerTabFactory: TaskViewerTabFactory = useTaskViewerTabFactory()
+const jfrViewerTabFactory: JfrViewerTabFactory = useJfrViewerTabFactory()
 
 const toaster: Toaster = useToaster()
 const { t } = useI18n()
@@ -119,12 +119,12 @@ function createActions(): Map<ConnectionActionType, MenuItem<ConnectionActionTyp
                 )
         )
     )
-    actions.set(ConnectionActionType.Jobs, createMenuAction(
-        ConnectionActionType.Jobs,
+    actions.set(ConnectionActionType.Tasks, createMenuAction(
+        ConnectionActionType.Tasks,
         'mdi-chart-gantt',
         () => {
             workspaceService.createTab(
-                jobTabFactory.createNew(
+                taskViewerTabFactory.createNew(
                     props.connection
                 )
             )
@@ -135,7 +135,7 @@ function createActions(): Map<ConnectionActionType, MenuItem<ConnectionActionTyp
         'mdi-chart-timeline',
         () => {
             workspaceService.createTab(
-                jfrTabFactory.createNew(
+                jfrViewerTabFactory.createNew(
                     props.connection
                 )
             )
diff --git a/src/modules/connection/explorer/model/ConnectionActionType.ts b/src/modules/connection/explorer/model/ConnectionActionType.ts
index 1f905b63..b41ebea2 100644
--- a/src/modules/connection/explorer/model/ConnectionActionType.ts
+++ b/src/modules/connection/explorer/model/ConnectionActionType.ts
@@ -5,7 +5,7 @@ export enum ConnectionActionType {
     Edit = 'edit',
     Remove = 'remove',
     Detail = 'detail',
-    Jobs = 'jobs',
+    Tasks = 'tasks',
     JfrRecordings = 'jfrRecordings',
     CatalogsSubheader = 'catalogsSubheader',
     CreateCatalog = 'createCatalog'
diff --git a/src/modules/connection/model/data/CatalogVersionAtResponse.ts b/src/modules/connection/model/CatalogVersionAtResponse.ts
similarity index 74%
rename from src/modules/connection/model/data/CatalogVersionAtResponse.ts
rename to src/modules/connection/model/CatalogVersionAtResponse.ts
index cf39aa04..bae2b473 100644
--- a/src/modules/connection/model/data/CatalogVersionAtResponse.ts
+++ b/src/modules/connection/model/CatalogVersionAtResponse.ts
@@ -1,4 +1,4 @@
-import { OffsetDateTime } from "../data-type/OffsetDateTime"
+import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
 
 export class CatalogVersionAtResponse {
     readonly version: bigint
@@ -8,4 +8,4 @@ export class CatalogVersionAtResponse {
         this.version = version
         this.introducedAt = introducedAt
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/connection/model/data/Currency.ts b/src/modules/connection/model/data-type/Currency.ts
similarity index 100%
rename from src/modules/connection/model/data/Currency.ts
rename to src/modules/connection/model/data-type/Currency.ts
diff --git a/src/modules/connection/model/data/Price.ts b/src/modules/connection/model/data/Price.ts
index 41aae900..bdc62eee 100644
--- a/src/modules/connection/model/data/Price.ts
+++ b/src/modules/connection/model/data/Price.ts
@@ -1,7 +1,6 @@
 import { BigDecimal } from "../data-type/BigDecimal";
 import { DateTimeRange } from "../data-type/DateTimeRange";
-import { Value } from "../Value";
-import { Currency } from "./Currency";
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 //TODO: Add documentation
 export class Price {
diff --git a/src/modules/connection/model/data/TaskSimplifiedState.ts b/src/modules/connection/model/data/TaskSimplifiedState.ts
deleted file mode 100644
index e1f4aaa6..00000000
--- a/src/modules/connection/model/data/TaskSimplifiedState.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export enum TaskSimplifiedState {
-    TaskQueued = 0,
-    TaskRunning = 1,
-    TaskFinished = 2,
-    TaskFailed = 3
-}
\ No newline at end of file
diff --git a/src/modules/connection/model/data/File.ts b/src/modules/connection/model/file/File.ts
similarity index 100%
rename from src/modules/connection/model/data/File.ts
rename to src/modules/connection/model/file/File.ts
diff --git a/src/modules/connection/model/data/FilesToFetch.ts b/src/modules/connection/model/file/FilesToFetch.ts
similarity index 92%
rename from src/modules/connection/model/data/FilesToFetch.ts
rename to src/modules/connection/model/file/FilesToFetch.ts
index da5f6ae7..f3ed1f2d 100644
--- a/src/modules/connection/model/data/FilesToFetch.ts
+++ b/src/modules/connection/model/file/FilesToFetch.ts
@@ -1,5 +1,5 @@
-import { Immutable } from "@babel/types"
 import { File } from "./File"
+import Immutable from 'immutable'
 
 export class FilesToFetch {
     readonly pageSize: number
@@ -13,4 +13,4 @@ export class FilesToFetch {
         this.filesToFetch = filesToFetch
         this.totalNumberOfRecords = totalNumberOfRecords
     }
-}
\ No newline at end of file
+}
diff --git a/src/modules/connection/model/data/EventType.ts b/src/modules/connection/model/jfr/EventType.ts
similarity index 92%
rename from src/modules/connection/model/data/EventType.ts
rename to src/modules/connection/model/jfr/EventType.ts
index ea96be7f..7fa23883 100644
--- a/src/modules/connection/model/data/EventType.ts
+++ b/src/modules/connection/model/jfr/EventType.ts
@@ -1,4 +1,4 @@
-export  class EventType {
+export class EventType {
     readonly id: string
     readonly name: string
     readonly description: string
diff --git a/src/modules/connection/model/schema/EntitySchema.ts b/src/modules/connection/model/schema/EntitySchema.ts
index 8e1ccdc0..08fc108a 100644
--- a/src/modules/connection/model/schema/EntitySchema.ts
+++ b/src/modules/connection/model/schema/EntitySchema.ts
@@ -1,4 +1,3 @@
-import { Schema } from '@/modules/connection/model/schema/Schema'
 import { List, Map } from 'immutable'
 import { NamingConvention } from '../NamingConvetion'
 import { AssociatedDataSchema } from '@/modules/connection/model/schema/AssociatedDataSchema'
@@ -8,8 +7,8 @@ import { EntityAttributeSchema } from '@/modules/connection/model/schema/EntityA
 import { Value } from '@/modules/connection/model/Value'
 import { EvolutionMode } from '@/modules/connection/model/schema/EvolutionMode'
 import { AbstractSchema } from '@/modules/connection/model/schema/AbstractSchema'
-import { Currency } from '../data/Currency'
 import { Locale } from '../data-type/Locale'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 /**
  * evitaLab's representation of a single evitaDB entity schema independent of specific evitaDB version
diff --git a/src/modules/connection/model/data/ApiEndpoint.ts b/src/modules/connection/model/status/ApiEndpoint.ts
similarity index 100%
rename from src/modules/connection/model/data/ApiEndpoint.ts
rename to src/modules/connection/model/status/ApiEndpoint.ts
diff --git a/src/modules/connection/model/data/ApiReadiness.ts b/src/modules/connection/model/status/ApiReadiness.ts
similarity index 100%
rename from src/modules/connection/model/data/ApiReadiness.ts
rename to src/modules/connection/model/status/ApiReadiness.ts
diff --git a/src/modules/connection/model/data/ApiServerStatus.ts b/src/modules/connection/model/status/ApiServerStatus.ts
similarity index 100%
rename from src/modules/connection/model/data/ApiServerStatus.ts
rename to src/modules/connection/model/status/ApiServerStatus.ts
diff --git a/src/modules/connection/model/data/ServerStatus.ts b/src/modules/connection/model/status/ServerStatus.ts
similarity index 100%
rename from src/modules/connection/model/data/ServerStatus.ts
rename to src/modules/connection/model/status/ServerStatus.ts
diff --git a/src/modules/connection/model/task/TaskState.ts b/src/modules/connection/model/task/TaskState.ts
new file mode 100644
index 00000000..fa377027
--- /dev/null
+++ b/src/modules/connection/model/task/TaskState.ts
@@ -0,0 +1,6 @@
+export enum TaskState {
+    Queued = 'queued',
+    Running = 'running',
+    Finished = 'finished',
+    Failed = 'failed'
+}
diff --git a/src/modules/connection/model/data/TaskStatus.ts b/src/modules/connection/model/task/TaskStatus.ts
similarity index 50%
rename from src/modules/connection/model/data/TaskStatus.ts
rename to src/modules/connection/model/task/TaskStatus.ts
index 006709a7..3feb98aa 100644
--- a/src/modules/connection/model/data/TaskStatus.ts
+++ b/src/modules/connection/model/task/TaskStatus.ts
@@ -1,7 +1,7 @@
 import { OffsetDateTime } from "../data-type/OffsetDateTime"
 import { Uuid } from "../data-type/Uuid"
-import { File } from "./File"
-import { TaskSimplifiedState } from "./TaskSimplifiedState"
+import { TaskState } from "./TaskState"
+import { File } from '@/modules/connection/model/file/File'
 
 export class TaskStatus {
     readonly taskType: string
@@ -15,9 +15,22 @@ export class TaskStatus {
     readonly settings: string
     readonly result: string | File | undefined
     readonly exception: string
-    readonly simplifiedState: TaskSimplifiedState
+    readonly state: TaskState
 
-    constructor(taskType: string, taskName: string, taskId: Uuid, catalogName: string, issued: OffsetDateTime, started: OffsetDateTime, finished: OffsetDateTime, progress: number, settings: string, result: string | File | undefined, exception: string, simplifiedState: TaskSimplifiedState){
+    private _cancelRequested: boolean = false
+
+    constructor(taskType: string,
+                taskName: string,
+                taskId: Uuid,
+                catalogName: string,
+                issued: OffsetDateTime,
+                started: OffsetDateTime,
+                finished: OffsetDateTime,
+                progress: number,
+                settings: string,
+                result: string | File | undefined,
+                exception: string,
+                state: TaskState){
         this.taskType = taskType
         this.taskName = taskName
         this.taskId = taskId
@@ -29,6 +42,16 @@ export class TaskStatus {
         this.settings = settings
         this.result = result
         this.exception = exception
-        this.simplifiedState = simplifiedState
+        this.state = state
+    }
+
+    get isCancelRequested(): boolean {
+        return this._cancelRequested
+    }
+
+    cancelRequested(): void {
+        if (!this._cancelRequested) {
+            this._cancelRequested = true
+        }
     }
 }
diff --git a/src/modules/connection/model/data/TaskStatuses.ts b/src/modules/connection/model/task/TaskStatuses.ts
similarity index 79%
rename from src/modules/connection/model/data/TaskStatuses.ts
rename to src/modules/connection/model/task/TaskStatuses.ts
index 39121bc6..e84ac703 100644
--- a/src/modules/connection/model/data/TaskStatuses.ts
+++ b/src/modules/connection/model/task/TaskStatuses.ts
@@ -4,18 +4,18 @@ import { TaskStatus } from './TaskStatus'
 export class TaskStatuses {
     readonly pageSize: number
     readonly pageNumber: number
-    readonly taskStatus: List<TaskStatus>
+    readonly statuses: List<TaskStatus>
     readonly totalNumberOfRecords: number
 
     constructor(
         pageSize: number,
         pageNumber: number,
-        taskStatus: List<TaskStatus>,
+        statuses: List<TaskStatus>,
         totalNumberOfRecords: number
     ) {
         this.pageNumber = pageNumber
         this.pageSize = pageSize
-        this.taskStatus = taskStatus
+        this.statuses = statuses
         this.totalNumberOfRecords = totalNumberOfRecords
     }
 }
diff --git a/src/modules/entity-viewer/viewer/model/entity-property-value/EntityPrice.ts b/src/modules/entity-viewer/viewer/model/entity-property-value/EntityPrice.ts
index b7f84b3e..fc2c399d 100644
--- a/src/modules/entity-viewer/viewer/model/entity-property-value/EntityPrice.ts
+++ b/src/modules/entity-viewer/viewer/model/entity-property-value/EntityPrice.ts
@@ -5,8 +5,8 @@ import {
 } from '@/modules/entity-viewer/viewer/model/entity-property-value/EntityPropertyValuePreviewStringContext'
 import { QueryPriceMode } from '@/modules/entity-viewer/viewer/model/QueryPriceMode'
 import { DateTimeRange } from '@/modules/connection/model/data-type/DateTimeRange'
-import { Currency } from '@/modules/connection/model/data/Currency'
 import { Price } from '@/modules/connection/model/data/Price'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 /**
  * Represents a single entity price.
diff --git a/src/modules/entity-viewer/viewer/model/entity-property-value/NativeValue.ts b/src/modules/entity-viewer/viewer/model/entity-property-value/NativeValue.ts
index 8d0dd37f..e28974f9 100644
--- a/src/modules/entity-viewer/viewer/model/entity-property-value/NativeValue.ts
+++ b/src/modules/entity-viewer/viewer/model/entity-property-value/NativeValue.ts
@@ -3,7 +3,6 @@ import { BigDecimal } from '@/modules/connection/model/data-type/BigDecimal'
 import { LocalDateTime } from '@/modules/connection/model/data-type/LocalDateTime'
 import { Range } from '@/modules/connection/model/data-type/Range'
 import { Locale } from '@/modules/connection/model/data-type/Locale'
-import { Currency } from '@/modules/connection/model/data/Currency'
 import { OffsetDateTime } from '@/modules/connection/model/data-type/OffsetDateTime'
 import { LocalDate } from '@/modules/connection/model/data-type/LocalDate'
 import { LocalTime } from '@/modules/connection/model/data-type/LocalTime'
@@ -11,6 +10,7 @@ import { Predecessor } from '@/modules/connection/model/data-type/Predecessor'
 import { DateTimeRange } from '@/modules/connection/model/data-type/DateTimeRange'
 import { PrettyPrintable } from '@/modules/connection/model/data-type/PrettyPrintable'
 import { Attributes } from '@/modules/connection/model/data/Attributes'
+import { Currency } from '@/modules/connection/model/data-type/Currency'
 
 /**
  * Represents a single entity property value that is a scalar (native to JavaScript). Cannot be an array, each array item
diff --git a/src/modules/global/components/TabWindowBody.vue b/src/modules/global/components/TabWindowBody.vue
deleted file mode 100644
index d5dfb3ce..00000000
--- a/src/modules/global/components/TabWindowBody.vue
+++ /dev/null
@@ -1,55 +0,0 @@
-<template>
-    <div class="main">
-        <VTabToolbar :prepend-icon="icon" :path="path">
-            <template #append>
-                <VBtn
-                    v-if="visibleButton"
-                    density="compact"
-                    variant="outlined"
-                    class="me-4"
-                    @click="
-                        () => {
-                            emit('topButtonClick')
-                        }
-                    "
-                >
-                    <VIcon>{{ icon }}</VIcon>
-                    {{ buttonText }}
-                </VBtn>
-            </template>
-        </VTabToolbar>
-        <VSheet>
-            <slot />
-        </VSheet>
-    </div>
-</template>
-
-<script setup lang="ts">
-import VTabToolbar from '@/modules/base/component/VTabToolbar.vue';
-import { List } from 'immutable';
-
-const props = defineProps<{
-    path: List<string>
-    icon: string
-    visibleButton: boolean,
-    buttonText?: string
-}>()
-const emit = defineEmits<{
-    (e: 'topButtonClick'): void
-}>()
-</script>
-
-<style scoped>
-.main {
-    display: grid;
-    grid-template-rows: 3rem 1fr;
-
-    &__header {
-        z-index: 100;
-    }
-
-    &__body {
-        position: relative;
-    }
-}
-</style>
diff --git a/src/modules/graphql-console/console/component/GraphQLConsole.vue b/src/modules/graphql-console/console/component/GraphQLConsole.vue
index b36292b6..eee5a761 100644
--- a/src/modules/graphql-console/console/component/GraphQLConsole.vue
+++ b/src/modules/graphql-console/console/component/GraphQLConsole.vue
@@ -249,14 +249,8 @@ function focusResultVisualiser(): void {
 </script>
 
 <template>
-    <div
-        v-if="initialized"
-        class="graphql-editor"
-    >
-        <VTabToolbar
-            prepend-icon="mdi-graphql"
-            :path="immutablePath"
-        >
+    <div v-if="initialized" class="graphql-editor">
+        <VTabToolbar prepend-icon="mdi-graphql" :path="immutablePath">
             <template #append>
                 <ShareTabButton
                     ref="shareTabButtonRef"
diff --git a/src/modules/i18n/en.json b/src/modules/i18n/en.json
index 1ac64072..3fdc8fb8 100644
--- a/src/modules/i18n/en.json
+++ b/src/modules/i18n/en.json
@@ -25,11 +25,7 @@
       "confirm": "Confirm",
       "rename": "Rename",
       "replace": "Replace",
-      "switch": "Switch",
-      "backup": "Backup",
-      "restore": "Restore",
-      "startRecording": "Start recording",
-      "stopRecording": "Stop recording"
+      "switch": "Switch"
     },
     "notification": {
       "copiedToClipboard": "Copied to clipboard",
@@ -272,7 +268,7 @@
         "remove": "Remove connection",
         "detail": "Status",
         "createCatalog": "Create catalog",
-        "jobs": "Jobs",
+        "tasks": "Tasks",
         "jfrRecordings": "JFR recordings"
       },
       "subheader": {
@@ -953,27 +949,128 @@
       }
     }
   },
-  "backups": {
+  "backupViewer": {
     "path": "Backups",
-    "createDialog": {
-      "titleFirst": "Back up ",
-      "titleSecond": " catalog",
-      "includeWal": "Will apply all mutations from WAL during restoration resulting in the latest version of catalog",
-      "information": "The back up process may take a while. Therefore it will be started asynchronously. You can find it’s progress and backup file to download in job listing."
-    },
-    "restoreDialog": {
-      "catalogName": "New catalog name"
+    "button": {
+      "backupCatalog": "Backup catalog"
+    },
+    "tasks": {
+      "title": "Backups in preparation"
+    },
+    "list": {
+      "title": "Finished backups"
+    },
+    "notification": {
+      "couldNotLoadBackupFiles": "Could not load backup files: {reason}",
+      "couldNotDownloadBackupFile": "Could not download backup file {fileName}: {reason}"
+    },
+    "backup": {
+      "title": "Backup catalog",
+      "description": "Request a new backup for the {catalogName} catalog:",
+      "info": "The back up process may take a while. Therefore it will be started asynchronously. You can find it’s progress and backup file to download in task listing.",
+      "form": {
+        "pastMoment": {
+          "label": "Past moment",
+          "validations": {
+            "required": "Past moment is required."
+          }
+        },
+        "includeWal": {
+          "label": "Include WAL",
+          "description": "Will apply all mutations from WAL during restoration resulting in the latest version of catalog"
+        }
+      },
+      "button": {
+        "backup": "Backup"
+      },
+      "notification": {
+        "backupRequested": "A backup for the {catalogName} catalog requested.",
+        "couldNotRequestBackup": "Could not request a backup for the {catalogName} catalog: {reason}"
+      }
+    },
+    "restore": {
+      "title": "Restore catalog",
+      "description": "Restore the {fileName} backup file into catalog:",
+      "info": "The restore process may take a while. Therefore, it will be started asynchronously. You can find it's progress in backups or tasks.",
+      "button": {
+        "restore": "Restore"
+      },
+      "form": {
+        "catalogName": {
+          "label": "Catalog name",
+          "validations": {
+            "required": "Catalog name is required.",
+            "empty": "Catalog name is required.",
+            "leadingTrailingWhiteSpace": "Catalog name cannot have leading or trailing whitespace characters.",
+            "keyword": "Catalog name is same as a reserved keyword.",
+            "format": "Catalog name doesn't match supported format.",
+            "notAvailable": "Catalog with this name already exists."
+          }
+        }
+      },
+      "notification": {
+        "restoreRequested": "A restoration of the {fileName} backup file has been requested.",
+        "couldNotRestoreBackupFile": "Could not restore backup file {fileName}: {reason}"
+      }
     }
   },
-  "jobs": {
-    "path": "Jobs"
+  "taskViewer": {
+    "path": "Tasks",
+    "tasksVisualizer": {
+      "notification": {
+        "couldNotLoadTaskStatuses": "Could not load task statuses: {reason}",
+        "taskCancelled": "The {taskName} task has been cancelled.",
+        "taskNotCancelled": "The {taskName} task has not been cancelled. Probably because it is already finished",
+        "couldNotCancelTask": "Could not cancel the {taskName} task: {reason}"
+      }
+    }
   },
-  "jfr": {
+  "jfrViewer": {
     "path": "JFR Recordings",
-    "startRecordingDialog": {
+    "button": {
+      "startRecording": "Start recording"
+    },
+    "tasks": {
+      "title": "Running recordings"
+    },
+    "list": {
+      "title": "Finished recordings"
+    },
+    "notification": {
+      "couldNotDownloadRecordingFile": "Could not download recording file {fileName}: {reason}"
+    },
+    "startRecording": {
       "title": "Start JFR recording",
-      "input": "Events to record",
-      "info": "This will start recording process in background which will be active until you stop it manually. Note that there can be only one recording active at the same time."
+      "info": "This will start recording process in background which will be active until you stop it manually. Note that there can be only one recording active at the same time.",
+      "form": {
+        "events": {
+          "label": "Events to record",
+          "validations": {
+            "required": "Events are required."
+          }
+        }
+      },
+      "button": {
+        "startRecording": "Start recording"
+      },
+      "notification": {
+        "couldNotLoadEventTypes": "Could not load available event types for JFR recording: {reason}",
+        "couldNotStartRecording": "Could not start JFR recording: {reason}",
+        "recordingStarted": "JFR recording has been started.",
+        "recordingNotStarted": "JFR recording has not been started."
+      }
+    },
+    "stopRecording": {
+      "title": "Stop JFR recording",
+      "info": "This will stop the active recording process. The final recording will be available in the JFR recording listing.",
+      "button": {
+        "stopRecording": "Stop recording"
+      },
+      "notification": {
+        "couldNotStopRecording": "Could not stop JFR recording: {reason}",
+        "recordingStopped": "JFR recording has been stopped.",
+        "recordingNotStopped": "JFR recording has not been stopped."
+      }
     }
   }
 }
\ No newline at end of file
diff --git a/src/modules/jfr-recording/JfrModuleRegistrar.ts b/src/modules/jfr-recording/JfrModuleRegistrar.ts
deleted file mode 100644
index 6ddc19d3..00000000
--- a/src/modules/jfr-recording/JfrModuleRegistrar.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { ModuleRegistrar } from '@/ModuleRegistrar'
-import { ModuleContextBuilder } from '@/ModuleContextBuilder'
-import {
-    EvitaDBDriverResolver,
-    evitaDBDriverResolverInjectionKey
-} from '@/modules/connection/driver/EvitaDBDriverResolver'
-import { JfrService, jfrServiceInjectionKey } from '@/modules/jfr-recording/service/JfrService'
-
-export class JfrModuleRegistrar implements ModuleRegistrar {
-    register(builder: ModuleContextBuilder): void {
-        const evitaDBDriverResolver: EvitaDBDriverResolver = builder.inject(evitaDBDriverResolverInjectionKey)
-        const jfrService: JfrService = new JfrService(evitaDBDriverResolver)
-        builder.provide(jfrServiceInjectionKey, jfrService)
-    }
-}
diff --git a/src/modules/jfr-recording/components/JfrEndRecord.vue b/src/modules/jfr-recording/components/JfrEndRecord.vue
deleted file mode 100644
index 77904cc0..00000000
--- a/src/modules/jfr-recording/components/JfrEndRecord.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-    <VDialog v-model="visible" class="w-25">
-        <VCard>
-            <VCardTitleWithActions>
-
-            </VCardTitleWithActions>
-            <VCardText>
-
-            </VCardText>
-        </VCard>
-    </VDialog>
-</template>
-
-<script setup lang="ts">
-import { ref } from 'vue';
-
-const visible = ref<boolean>(true)
-
-</script>
-
-<style scoped>
-
-</style>
diff --git a/src/modules/jfr-recording/components/JfrStartRecord.vue b/src/modules/jfr-recording/components/JfrStartRecord.vue
deleted file mode 100644
index 974bd228..00000000
--- a/src/modules/jfr-recording/components/JfrStartRecord.vue
+++ /dev/null
@@ -1,85 +0,0 @@
-<template>
-    <VDialog v-model="visible" class="w-50">
-        <VCard>
-            <VCardTitleWithActions>
-                <template #default>
-                    {{ t('jfr.startRecordingDialog.title') }}
-                </template>
-            </VCardTitleWithActions>
-            <VCardText>
-                <VCombobox
-                    v-model="selectedTypes"
-                    :items="eventTypes"
-                    item-title="name"
-                    multiple
-                    chips
-                >
-                </VCombobox>
-                <div class="mt-4 buttons">
-                    <VBtn
-                        variant="elevated"
-                        :text="t('common.button.cancel')"
-                        @click="close"
-                    ></VBtn>
-                    <VBtn variant="outlined" @click="startRecording">
-                        <VIcon>mdi-record-circle-outline</VIcon>
-                        {{ t('common.button.startRecording') }}
-                    </VBtn>
-                </div>
-            </VCardText>
-        </VCard>
-    </VDialog>
-</template>
-
-<script setup lang="ts">
-import VCardTitleWithActions from '@/modules/base/component/VCardTitleWithActions.vue'
-import { JfrService } from '../service/JfrService'
-import { useI18n } from 'vue-i18n'
-import { Connection } from '@/modules/connection/model/Connection'
-import { EventType } from '@/modules/connection/model/data/EventType'
-import { ref } from 'vue'
-
-const { t } = useI18n()
-
-const visible = ref<boolean>(true)
-const eventTypes = ref<EventType[]>()
-const selectedTypes = ref<EventType[]>()
-
-const props = defineProps<{
-    jfrService: JfrService
-    connection: Connection
-}>()
-
-const emit = defineEmits<{
-    (e: 'exit'): void
-}>()
-
-getRecordingEventTypes().then()
-
-async function getRecordingEventTypes() {
-    eventTypes.value = await props.jfrService.downloadRecordingEventTypes(
-        props.connection
-    )
-    selectedTypes.value = eventTypes.value
-}
-
-function close() {
-    emit('exit')
-}
-
-async function startRecording() {
-    const res = await props.jfrService.startRecording(
-        props.connection,
-        selectedTypes.value!.map((x) => x.id)
-    )
-    if (res) emit('exit')
-}
-</script>
-
-<style scoped lang="scss">
-.buttons {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-}
-</style>
diff --git a/src/modules/jfr-recording/components/JfrVisualizer.vue b/src/modules/jfr-recording/components/JfrVisualizer.vue
deleted file mode 100644
index 52ab44f9..00000000
--- a/src/modules/jfr-recording/components/JfrVisualizer.vue
+++ /dev/null
@@ -1,135 +0,0 @@
-<template>
-    <TabWindowBody
-        :path="path"
-        icon="mdi-record-circle-outline"
-        :visible-button="true"
-        button-text="Start recording"
-        @top-button-click="showStartRecording"
-    >
-        <JobVisualizer
-            :connection="props.params.connection"
-            task-type="JfrRecorderTask"
-            :simplified-state="[
-                TaskSimplifiedState.TaskRunning,
-                TaskSimplifiedState.TaskQueued,
-            ]"
-            @stop-jfr="stopJfrRecording"
-        />
-        <VList>
-            <VListItem
-                v-for="(item, index) in result?.filesToFetch"
-                :key="index"
-            >
-                <VRow class="align-center">
-                    <VCol>
-                        <div class="d-flex align-center">
-                            <VListItemTitle>{{ item.name }}</VListItemTitle>
-                            <VChip
-                                color="grey"
-                                text-color="white"
-                                class="ml-2 small-chip"
-                                >finished</VChip
-                            >
-                        </div>
-                    </VCol>
-                    <VCol
-                        class="d-flex justify-end"
-                        cols="auto"
-                        v-if="item.created"
-                    >
-                        <VBtn
-                            icon
-                            variant="flat"
-                            @click="downloadFile(item.fileId, item.name)"
-                        >
-                            <VIcon>mdi-download</VIcon>
-                        </VBtn>
-                        <!--
-                        TODO: Implement
-                        <VBtn icon variant="flat">
-                            <VIcon>mdi-delete-outline</VIcon>
-                        </VBtn>
-                        -->
-                    </VCol>
-                </VRow>
-            </VListItem>
-        </VList>
-        <JfrStartRecord
-            :connection="params.connection"
-            :jfr-service="jfrService"
-            @exit="closeStartRecording"
-            v-if="visibleStartRecording"
-        />
-        <JfrEndRecord v-if="visibleEndRecording" />
-    </TabWindowBody>
-</template>
-
-<script setup lang="ts">
-import TabWindowBody from '@/modules/global/components/TabWindowBody.vue'
-import { List } from 'immutable'
-import { useI18n } from 'vue-i18n'
-import { ref } from 'vue'
-import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
-import JobVisualizer from '@/modules/jobs/components/JobVisualizer.vue'
-import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
-import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
-import { JfrVisualizerTabParams } from '@/modules/jfr-recording/model/JfrVisualizerTabParams'
-import { TaskSimplifiedState } from '@/modules/connection/model/data/TaskSimplifiedState'
-import {
-    JfrService,
-    useJfrService,
-} from '@/modules/jfr-recording/service/JfrService'
-import { VBtn, VIcon, VList } from 'vuetify/components'
-import { FilesToFetch } from '@/modules/connection/model/data/FilesToFetch'
-import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import JfrStartRecord from './JfrStartRecord.vue'
-import JfrEndRecord from '@/modules/jfr-recording/components/JfrEndRecord.vue'
-import { onUnmounted } from 'vue'
-
-const emit = defineEmits<TabComponentEvents>()
-const props =
-    defineProps<TabComponentProps<JfrVisualizerTabParams, VoidTabData>>()
-const jfrService: JfrService = useJfrService()
-const result = ref<FilesToFetch>()
-const visibleStartRecording = ref<boolean>(false)
-const visibleEndRecording = ref<boolean>(false)
-
-const { t } = useI18n()
-const path: List<string> = List([t('jfr.path')])
-
-getAllJfrs().then(() => emit('ready'))
-
-async function getAllJfrs() {
-    result.value = await jfrService.getAllJfrs(props.params.connection)
-}
-
-async function stopJfrRecording(){
-    await jfrService.stopRecording(props.params.connection)
-}
-
-function showStartRecording() {
-    visibleStartRecording.value = true
-}
-
-async function downloadFile(fileId: Uuid, name: string) {
-    const blob = await jfrService.downloadFile(props.params.connection, fileId)
-    const downloadUrl = URL.createObjectURL(blob)
-    const link = document.createElement('a')
-    link.href = downloadUrl
-    link.download = name
-    document.body.appendChild(link)
-    link.click()
-}
-
-function closeStartRecording() {
-    visibleStartRecording.value = false
-}
-
-const jfrIntervalId = setInterval(getAllJfrs, 2000)
-
-onUnmounted(() => {
-    clearInterval(jfrIntervalId)
-})
-</script>
-
-<style scoped></style>
diff --git a/src/modules/jfr-recording/model/JfrVisualizerDefinition.ts b/src/modules/jfr-recording/model/JfrVisualizerDefinition.ts
deleted file mode 100644
index 570d0b34..00000000
--- a/src/modules/jfr-recording/model/JfrVisualizerDefinition.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { TabDefinition } from "@/modules/workspace/tab/model/TabDefinition";
-import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
-import { JfrVisualizerTabParams } from '@/modules/jfr-recording/model/JfrVisualizerTabParams'
-import { DefineComponent, markRaw } from 'vue'
-import JfrVisualizer from '@/modules/jfr-recording/components/JfrVisualizer.vue'
-
-export class JfrVisualizerDefinition extends TabDefinition<JfrVisualizerTabParams, VoidTabData>{
-    constructor(title: string, params: JfrVisualizerTabParams) {
-        super(undefined, title, 'mdi-record-circle-outline', markRaw(JfrVisualizer as DefineComponent<any, any, any>), params, new VoidTabData())
-    }
-}
diff --git a/src/modules/jfr-recording/service/JfrService.ts b/src/modules/jfr-recording/service/JfrService.ts
deleted file mode 100644
index eef8d207..00000000
--- a/src/modules/jfr-recording/service/JfrService.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { EvitaDBDriverResolver } from '@/modules/connection/driver/EvitaDBDriverResolver'
-import { InjectionKey } from 'vue'
-import { mandatoryInject } from '@/utils/reactivity'
-import { Connection } from '@/modules/connection/model/Connection'
-import { FilesToFetch } from '@/modules/connection/model/data/FilesToFetch'
-import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import { EventType } from '@/modules/connection/model/data/EventType'
-
-export const jfrServiceInjectionKey: InjectionKey<JfrService> = Symbol('jfrService')
-
-export class JfrService {
-    private  readonly evitaDBDriverResolver: EvitaDBDriverResolver
-
-    constructor(evitaDBDriverResolver: EvitaDBDriverResolver) {
-        this.evitaDBDriverResolver = evitaDBDriverResolver
-    }
-
-    async getAllJfrs(connection: Connection):Promise<FilesToFetch>{
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.getJfrRecords(connection, 1,20)
-    }
-
-    async downloadFile(connection: Connection, fileId: Uuid):Promise<Blob> {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.downloadFile(connection, fileId)
-    }
-
-    async downloadRecordingEventTypes(connection: Connection):Promise<EventType[]>{
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.downloadRecordingEventTypes(connection)
-    }
-
-    async startRecording(connection: Connection, entityTypes: string[]):Promise<boolean> {
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.startJrfRecording(connection, entityTypes)
-    }
-
-    async stopRecording(connection: Connection){
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.stopJfrRecording(connection)
-    }
-}
-
-export const useJfrService = (): JfrService => {
-    return mandatoryInject(jfrServiceInjectionKey) as JfrService
-}
diff --git a/src/modules/jfr-recording/service/JfrTabFactory.ts b/src/modules/jfr-recording/service/JfrTabFactory.ts
deleted file mode 100644
index b69a73d4..00000000
--- a/src/modules/jfr-recording/service/JfrTabFactory.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { InjectionKey } from 'vue'
-import { JfrService } from '@/modules/jfr-recording/service/JfrService'
-import { ConnectionService } from '@/modules/connection/service/ConnectionService'
-import { Connection } from '@/modules/connection/model/Connection'
-import { SchemaViewerTabDefinition } from '@/modules/schema-viewer/viewer/workspace/model/SchemaViewerTabDefinition'
-import { JfrVisualizerDefinition } from '@/modules/jfr-recording/model/JfrVisualizerDefinition'
-import { JfrVisualizerTabParams } from '@/modules/jfr-recording/model/JfrVisualizerTabParams'
-import { mandatoryInject } from '@/utils/reactivity'
-import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
-import { JfrVisualizerTabParamsDto } from '@/modules/jfr-recording/model/JfrVisualizerTabParamsDto'
-
-export const jfrTabFactoryInjectionKey: InjectionKey<JfrTabFactory> = Symbol('JfrTabFactory');
-
-export class JfrTabFactory {
-    private readonly connectionService: ConnectionService
-
-    constructor(connectionService: ConnectionService) {
-        this.connectionService = connectionService
-    }
-
-    createNew(connection: Connection, excutableOnOpen: boolean = false): JfrVisualizerDefinition {
-        return new JfrVisualizerDefinition('JFR Recordings', this.createTabParams(connection, excutableOnOpen))
-    }
-
-    private createTabParams(connection: Connection, executeOnOpen: boolean = false) {
-        return new JfrVisualizerTabParams(connection, executeOnOpen)
-    }
-
-    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabParamsDto):JfrVisualizerDefinition {
-        const params: JfrVisualizerTabParamsDto = paramsJson as JfrVisualizerTabParamsDto
-        return new JfrVisualizerDefinition('JFR Recordings', this.createTabParams(this.connectionService.getConnection(params.connection.id)))
-    }
-}
-
-export const useJfrTabFactory = ():JfrTabFactory => {
-    return mandatoryInject(jfrTabFactoryInjectionKey) as JfrTabFactory
-}
diff --git a/src/modules/jfr-viewer/JfrViewerModuleRegistrar.ts b/src/modules/jfr-viewer/JfrViewerModuleRegistrar.ts
new file mode 100644
index 00000000..702d7357
--- /dev/null
+++ b/src/modules/jfr-viewer/JfrViewerModuleRegistrar.ts
@@ -0,0 +1,12 @@
+import { ModuleRegistrar } from '@/ModuleRegistrar'
+import { ModuleContextBuilder } from '@/ModuleContextBuilder'
+import { JfrViewerService, jfrViewerServiceInjectionKey } from '@/modules/jfr-viewer/service/JfrViewerService'
+import { ConnectionService, connectionServiceInjectionKey } from '@/modules/connection/service/ConnectionService'
+
+export class JfrViewerModuleRegistrar implements ModuleRegistrar {
+    register(builder: ModuleContextBuilder): void {
+        const connectionService: ConnectionService = builder.inject(connectionServiceInjectionKey)
+        const jfrService: JfrViewerService = new JfrViewerService(connectionService)
+        builder.provide(jfrViewerServiceInjectionKey, jfrService)
+    }
+}
diff --git a/src/modules/jfr-viewer/components/EndJfrRecordingDialog.vue b/src/modules/jfr-viewer/components/EndJfrRecordingDialog.vue
new file mode 100644
index 00000000..e8a1bc1f
--- /dev/null
+++ b/src/modules/jfr-viewer/components/EndJfrRecordingDialog.vue
@@ -0,0 +1,67 @@
+<script setup lang="ts">
+import VFormDialog from '@/modules/base/component/VFormDialog.vue'
+import { Connection } from '@/modules/connection/model/Connection'
+import { JfrViewerService, useJfrViewerService } from '@/modules/jfr-viewer/service/JfrViewerService'
+import { useI18n } from 'vue-i18n'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+
+const jfrViewerService: JfrViewerService = useJfrViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = defineProps<{
+    modelValue: boolean,
+    connection: Connection
+}>()
+const emit = defineEmits<{
+    (e: 'update:modelValue', value: boolean): void
+}>()
+
+async function stopRecording(): Promise<boolean> {
+    try {
+        // todo lho revise driver logic
+        const stopped: boolean = await jfrViewerService.stopRecording(props.connection)
+        if (stopped) {
+            toaster.success(t('jfrViewer.stopRecording.notification.recordingStopped'))
+        } else {
+            toaster.info(t('jfrViewer.stopRecording.notification.recordingNotStopped'))
+        }
+        return true
+    } catch (e: any) {
+        toaster.error(t(
+            'jfrViewer.stopRecording.notification.couldNotStopRecording',
+            { reason: e.message }
+        ))
+        return false
+    }
+}
+
+</script>
+
+<template>
+    <VFormDialog
+        :model-value="modelValue"
+        changed
+        confirm-button-icon="mdi-stop-circle-outline"
+        :confirm="stopRecording"
+        @update:model-value="emit('update:modelValue', $event)"
+    >
+        <template #title>
+            {{ t('jfrViewer.stopRecording.title') }}
+        </template>
+
+        <template #default>
+            <VAlert type="info" icon="mdi-information-outline">
+                {{ t('jfrViewer.stopRecording.info') }}
+            </VAlert>
+        </template>
+
+        <template #confirm-button-body>
+            {{ t('jfrViewer.stopRecording.button.stopRecording') }}
+        </template>
+    </VFormDialog>
+</template>
+
+<style scoped>
+
+</style>
diff --git a/src/modules/jfr-viewer/components/JfrViewer.vue b/src/modules/jfr-viewer/components/JfrViewer.vue
new file mode 100644
index 00000000..e27af6b1
--- /dev/null
+++ b/src/modules/jfr-viewer/components/JfrViewer.vue
@@ -0,0 +1,206 @@
+<script setup lang="ts">
+import { List } from 'immutable'
+import { useI18n } from 'vue-i18n'
+import { computed, ref } from 'vue'
+import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
+import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
+import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
+import { JfrViewerTabParams } from '@/modules/jfr-viewer/model/JfrViewerTabParams'
+import {
+    jfrRecorderTaskName,
+    JfrViewerService,
+    useJfrViewerService,
+} from '@/modules/jfr-viewer/service/JfrViewerService'
+import { VBtn, VIcon, VList } from 'vuetify/components'
+import { onUnmounted } from 'vue'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { File } from '@/modules/connection/model/file/File'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import VTabToolbar from '@/modules/base/component/VTabToolbar.vue'
+import TasksVisualizer from '@/modules/task-viewer/components/TasksVisualizer.vue'
+import VTabMainActionButton from '@/modules/base/component/VTabMainActionButton.vue'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+import StartJfrRecordingDialog from '@/modules/jfr-viewer/components/StartJfrRecordingDialog.vue'
+import EndJfrRecordingDialog from '@/modules/jfr-viewer/components/EndJfrRecordingDialog.vue'
+
+const jfrViewerService: JfrViewerService = useJfrViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = defineProps<TabComponentProps<JfrViewerTabParams, VoidTabData>>()
+const emit = defineEmits<TabComponentEvents>()
+
+const jfrRecordingsReloadIntervalId = setInterval(loadJfrRecordings, 2000)
+
+onUnmounted(() => {
+    clearInterval(jfrRecordingsReloadIntervalId)
+})
+
+const path: List<string> = List([t('jfrViewer.path')])
+
+const initialized = ref<boolean>(false)
+const jfrRecordings = ref<FilesToFetch | undefined>()
+const jfrRecordingsLoaded = ref<boolean>(false)
+const jfrRecordingItems = computed<File[]>(() => {
+    if (jfrRecordings.value == undefined) {
+        return []
+    }
+    return jfrRecordings.value.filesToFetch.toArray()
+})
+const runningRecordingsPresent = ref<boolean>(false)
+const pageNumber = ref<number>(1)
+const pageCount = computed<number>(() => {
+    if (jfrRecordings.value == undefined) {
+        return 1
+    }
+    return Math.ceil(jfrRecordings.value.totalNumberOfRecords / pageSize.value)
+})
+const pageSize = ref<number>(20)
+
+const showStartRecordingDialog = ref<boolean>(false)
+const showEndRecordingDialog = ref<boolean>(false)
+
+loadJfrRecordings().then(() => {
+    initialized.value = true
+    emit('ready')
+})
+
+async function loadJfrRecordings() {
+    jfrRecordings.value = await jfrViewerService.getRecordings(props.params.connection)
+    jfrRecordingsLoaded.value = true
+}
+
+async function downloadRecording(file: File) {
+    try {
+        const blob = await jfrViewerService.downloadFile(props.params.connection, file.fileId)
+
+        console.log('hej')
+        const downloadUrl = URL.createObjectURL(blob)
+        const link = document.createElement('a')
+        link.href = downloadUrl
+        link.download = file.name
+        document.body.appendChild(link)
+        link.click()
+    } catch (e: any) {
+        toaster.error(t(
+            'jfrViewer.notification.couldNotDownloadRecordingFile',
+            {
+                fileName: file.name,
+                reason: e.message
+            }
+        ))
+    }
+}
+</script>
+
+<template>
+    <div v-if="initialized" class="jfr-viewer">
+        <VTabToolbar prepend-icon="mdi-record-circle-outline" :path="path">
+            <template #append>
+                <VTabMainActionButton @click="showStartRecordingDialog = true">
+                    <VIcon>mdi-record-circle-outline</VIcon>
+
+                    {{ t('jfrViewer.button.startRecording') }}
+                </VTabMainActionButton>
+            </template>
+        </VTabToolbar>
+
+        <div>
+            <TasksVisualizer
+                v-show="runningRecordingsPresent"
+                :connection="params.connection"
+                :subheader="t('jfrViewer.tasks.title')"
+                :states="[TaskState.Running, TaskState.Queued]"
+                :task-type="jfrRecorderTaskName"
+                :page-size="5"
+                hideable-pagination
+                @update:active-jobs-present="runningRecordingsPresent = $event"
+            >
+                <template #cancel-action="{ taskStatus }">
+                    <VBtn
+                        icon="mdi-stop-circle-outline"
+                        density="compact"
+                        variant="flat"
+                        @click="showEndRecordingDialog = true"
+                    />
+                </template>
+            </TasksVisualizer>
+
+            <VList v-if="jfrRecordingsLoaded">
+                <VListSubheader v-if="runningRecordingsPresent">
+                    {{ t('jfrViewer.list.title') }}
+                </VListSubheader>
+
+                <VDataIterator :items="jfrRecordingItems" :page="pageNumber">
+                    <template #default="{ items }">
+                        <VListItem
+                            v-for="item in items"
+                            :key="item.raw.fileId.code"
+                        >
+                            <VRow class="align-center">
+                                <!--                            todo lho revise -->
+                                <VCol>
+                                    <div class="d-flex align-center">
+                                        <VListItemTitle>{{ item.raw.name }}</VListItemTitle>
+                                        <VChip
+                                            color="grey"
+                                            text-color="white"
+                                            class="ml-2 small-chip"
+                                        >finished</VChip
+                                        >
+                                    </div>
+                                </VCol>
+                                <VCol
+                                    class="d-flex justify-end"
+                                    cols="auto"
+                                    v-if="item.raw.created"
+                                >
+                                    <VBtn
+                                        icon
+                                        density="compact"
+                                        variant="flat"
+                                        @click="downloadRecording(item.raw)"
+                                    >
+                                        <VIcon>mdi-download</VIcon>
+                                    </VBtn>
+                                    <!--
+                                    TODO: Implement
+                                    <VBtn icon variant="flat">
+                                        <VIcon>mdi-delete-outline</VIcon>
+                                    </VBtn>
+                                    -->
+                                </VCol>
+                            </VRow>
+                        </VListItem>
+                    </template>
+
+                    <template #footer>
+                        <VPagination v-model="pageNumber" :length="pageCount" />
+                    </template>
+                </VDataIterator>
+            </VList>
+        </div>
+
+        <StartJfrRecordingDialog
+            v-if="showStartRecordingDialog"
+            v-model="showStartRecordingDialog"
+            :connection="params.connection"
+        />
+        <EndJfrRecordingDialog
+            v-if="showEndRecordingDialog"
+            v-model="showEndRecordingDialog"
+            :connection="params.connection"
+        />
+    </div>
+</template>
+
+<style lang="scss" scoped>
+.jfr-viewer {
+    display: grid;
+    grid-template-rows: 3rem 1fr;
+
+    &__body {
+        position: relative;
+    }
+}
+</style>
diff --git a/src/modules/jfr-viewer/components/StartJfrRecordingDialog.vue b/src/modules/jfr-viewer/components/StartJfrRecordingDialog.vue
new file mode 100644
index 00000000..d0242a9a
--- /dev/null
+++ b/src/modules/jfr-viewer/components/StartJfrRecordingDialog.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import VCardTitleWithActions from '@/modules/base/component/VCardTitleWithActions.vue'
+import { JfrViewerService, useJfrViewerService } from '../service/JfrViewerService'
+import { useI18n } from 'vue-i18n'
+import { Connection } from '@/modules/connection/model/Connection'
+import { computed, ref } from 'vue'
+import { EventType } from '@/modules/connection/model/jfr/EventType'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import VFormDialog from '@/modules/base/component/VFormDialog.vue'
+
+const jfrViewerService: JfrViewerService = useJfrViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = defineProps<{
+    modelValue: boolean,
+    connection: Connection
+}>()
+const emit = defineEmits<{
+    (e: 'update:modelValue', value: boolean): void
+}>()
+
+const selectedTypesRules = [
+    (value: EventType[]): any => {
+        if (value != undefined && value.length > 0) return true
+        return t('jfrViewer.startRecording.form.events.validations.required')
+    }
+]
+
+const eventTypes = ref<EventType[]>()
+const eventTypesLoaded = ref<boolean>(false)
+const selectedTypes = ref<EventType[]>()
+const changed = computed<boolean>(() =>
+    selectedTypes.value != undefined && selectedTypes.value.length > 0)
+
+loadEventTypes().then()
+
+async function loadEventTypes() {
+    try {
+        eventTypes.value = await jfrViewerService.getEventTypes(props.connection)
+        selectedTypes.value = eventTypes.value
+        eventTypesLoaded.value = true
+    } catch (e: any) {
+        toaster.error(t(
+            'jfrViewer.startRecording.notification.couldNotLoadEventTypes',
+            { reason: e.message }
+        ))
+    }
+}
+
+function reset(): void {
+    selectedTypes.value = eventTypes.value
+}
+
+async function startRecording(): Promise<boolean> {
+    try {
+        // todo lho revise driver logic
+        const started: boolean = await jfrViewerService.startRecording(
+           props.connection,
+           selectedTypes.value!.map((x) => x.id)
+        )
+        if (started) {
+            toaster.success(t('jfrViewer.startRecording.notification.recordingStarted'))
+        } else {
+            toaster.info(t('jfrViewer.startRecording.notification.recordingNotStarted'))
+        }
+        return true
+    } catch (e: any) {
+        toaster.error(t(
+            'jfrViewer.startRecording.notification.couldNotStartRecording',
+            { reason: e.message }
+        ))
+        return false
+    }
+}
+</script>
+
+<template>
+    <VFormDialog
+        :model-value="modelValue"
+        :changed="changed"
+        scrollable
+        confirm-button-icon="mdi-record-circle-outline"
+        :confirm="startRecording"
+        :reset="reset"
+        @update:model-value="emit('update:modelValue', $event)"
+    >
+        <template #title>
+            {{ t('jfrViewer.startRecording.title') }}
+        </template>
+
+<!--        todo lho singleline? -->
+        <template #default>
+            <VAutocomplete
+                v-model="selectedTypes"
+                :items="eventTypes"
+                :rules="selectedTypesRules"
+                item-title="name"
+                multiple
+                chips
+            />
+        </template>
+
+        <template #append-form>
+            <VAlert type="info" icon="mdi-information-outline">
+                {{ t('jfrViewer.startRecording.info') }}
+            </VAlert>
+        </template>
+
+        <template #confirm-button-content>
+            {{ t('jfrViewer.startRecording.button.startRecording') }}
+        </template>
+    </VFormDialog>
+</template>
+
+<style scoped lang="scss">
+
+</style>
diff --git a/src/modules/jfr-viewer/model/JfrViewerDefinition.ts b/src/modules/jfr-viewer/model/JfrViewerDefinition.ts
new file mode 100644
index 00000000..b4e74a9f
--- /dev/null
+++ b/src/modules/jfr-viewer/model/JfrViewerDefinition.ts
@@ -0,0 +1,18 @@
+import { TabDefinition } from "@/modules/workspace/tab/model/TabDefinition";
+import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
+import { JfrViewerTabParams } from '@/modules/jfr-viewer/model/JfrViewerTabParams'
+import { DefineComponent, markRaw } from 'vue'
+import JfrViewer from '@/modules/jfr-viewer/components/JfrViewer.vue'
+
+export class JfrViewerDefinition extends TabDefinition<JfrViewerTabParams, VoidTabData>{
+    constructor(title: string, params: JfrViewerTabParams) {
+        super(
+            undefined,
+            title,
+            'mdi-record-circle-outline',
+            markRaw(JfrViewer as DefineComponent<any, any, any>),
+            params,
+            new VoidTabData()
+        )
+    }
+}
diff --git a/src/modules/jfr-recording/model/JfrVisualizerTabParams.ts b/src/modules/jfr-viewer/model/JfrViewerTabParams.ts
similarity index 62%
rename from src/modules/jfr-recording/model/JfrVisualizerTabParams.ts
rename to src/modules/jfr-viewer/model/JfrViewerTabParams.ts
index 1b308c85..dbe27bc4 100644
--- a/src/modules/jfr-recording/model/JfrVisualizerTabParams.ts
+++ b/src/modules/jfr-viewer/model/JfrViewerTabParams.ts
@@ -1,10 +1,10 @@
 import { TabParams } from '@/modules/workspace/tab/model/TabParams'
 import { ExecutableTabRequest } from '@/modules/workspace/tab/model/ExecutableTabRequest'
-import { JfrVisualizerTabParamsDto } from '@/modules/jfr-recording/model/JfrVisualizerTabParamsDto'
+import { JfrViewerTabParamsDto } from '@/modules/jfr-viewer/model/JfrViewerTabParamsDto'
 import { Connection } from '@/modules/connection/model/Connection'
 
-export class JfrVisualizerTabParams implements TabParams<JfrVisualizerTabParamsDto>, ExecutableTabRequest {
-    readonly  executeOnOpen: boolean
+export class JfrViewerTabParams implements TabParams<JfrViewerTabParamsDto>, ExecutableTabRequest {
+    readonly executeOnOpen: boolean
     readonly connection: Connection
 
     constructor(connection: Connection, executeOnOpen: boolean = false) {
@@ -12,7 +12,7 @@ export class JfrVisualizerTabParams implements TabParams<JfrVisualizerTabParamsD
         this.connection = connection
     }
 
-    toSerializable(): JfrVisualizerTabParamsDto {
+    toSerializable(): JfrViewerTabParamsDto {
         return {
             connection: this.connection,
         }
diff --git a/src/modules/jobs/model/JobTabParamsDto.ts b/src/modules/jfr-viewer/model/JfrViewerTabParamsDto.ts
similarity index 74%
rename from src/modules/jobs/model/JobTabParamsDto.ts
rename to src/modules/jfr-viewer/model/JfrViewerTabParamsDto.ts
index 47e51742..f3343fa0 100644
--- a/src/modules/jobs/model/JobTabParamsDto.ts
+++ b/src/modules/jfr-viewer/model/JfrViewerTabParamsDto.ts
@@ -1,6 +1,6 @@
-import { Connection } from '@/modules/connection/model/Connection'
 import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
+import { Connection } from '@/modules/connection/model/Connection'
 
-export interface JobTabParamsDto extends TabParamsDto{
+export interface JfrViewerTabParamsDto extends TabParamsDto {
     readonly connection: Connection
 }
diff --git a/src/modules/jfr-viewer/service/JfrViewerService.ts b/src/modules/jfr-viewer/service/JfrViewerService.ts
new file mode 100644
index 00000000..72479db8
--- /dev/null
+++ b/src/modules/jfr-viewer/service/JfrViewerService.ts
@@ -0,0 +1,48 @@
+import { InjectionKey } from 'vue'
+import { mandatoryInject } from '@/utils/reactivity'
+import { Connection } from '@/modules/connection/model/Connection'
+import { Uuid } from '@/modules/connection/model/data-type/Uuid'
+import { FilesToFetch } from '@/modules/connection/model/file/FilesToFetch'
+import { EventType } from '@/modules/connection/model/jfr/EventType'
+import { ConnectionService } from '@/modules/connection/service/ConnectionService'
+
+export const jfrViewerServiceInjectionKey: InjectionKey<JfrViewerService> = Symbol('jfrViewerService')
+
+export const jfrRecorderTaskName: string = 'JfrRecorderTask'
+
+export class JfrViewerService {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService) {
+        this.connectionService = connectionService
+    }
+
+    async getRecordings(connection: Connection):Promise<FilesToFetch>{
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.getJfrRecords(connection, 1,20)
+    }
+
+    async downloadFile(connection: Connection, fileId: Uuid):Promise<Blob> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.downloadFile(connection, fileId)
+    }
+
+    async getEventTypes(connection: Connection):Promise<EventType[]>{
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.downloadRecordingEventTypes(connection)
+    }
+
+    async startRecording(connection: Connection, entityTypes: string[]): Promise<boolean> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.startJrfRecording(connection, entityTypes)
+    }
+
+    async stopRecording(connection: Connection): Promise<boolean>{
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.stopJfrRecording(connection)
+    }
+}
+
+export const useJfrViewerService = (): JfrViewerService => {
+    return mandatoryInject(jfrViewerServiceInjectionKey) as JfrViewerService
+}
diff --git a/src/modules/jfr-viewer/service/JfrViewerTabFactory.ts b/src/modules/jfr-viewer/service/JfrViewerTabFactory.ts
new file mode 100644
index 00000000..3cbe8b24
--- /dev/null
+++ b/src/modules/jfr-viewer/service/JfrViewerTabFactory.ts
@@ -0,0 +1,38 @@
+import { InjectionKey } from 'vue'
+import { JfrViewerService } from '@/modules/jfr-viewer/service/JfrViewerService'
+import { ConnectionService } from '@/modules/connection/service/ConnectionService'
+import { Connection } from '@/modules/connection/model/Connection'
+import { SchemaViewerTabDefinition } from '@/modules/schema-viewer/viewer/workspace/model/SchemaViewerTabDefinition'
+import { JfrViewerDefinition } from '@/modules/jfr-viewer/model/JfrViewerDefinition'
+import { JfrViewerTabParams } from '@/modules/jfr-viewer/model/JfrViewerTabParams'
+import { mandatoryInject } from '@/utils/reactivity'
+import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
+import { JfrViewerTabParamsDto } from '@/modules/jfr-viewer/model/JfrViewerTabParamsDto'
+
+export const jfrViewerTabFactoryInjectionKey: InjectionKey<JfrViewerTabFactory> = Symbol('jfrViewerTabFactory');
+
+export class JfrViewerTabFactory {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService) {
+        this.connectionService = connectionService
+    }
+
+    // todo lho i18n
+    createNew(connection: Connection, excutableOnOpen: boolean = false): JfrViewerDefinition {
+        return new JfrViewerDefinition('JFR Recordings', this.createTabParams(connection, excutableOnOpen))
+    }
+
+    private createTabParams(connection: Connection, executeOnOpen: boolean = false) {
+        return new JfrViewerTabParams(connection, executeOnOpen)
+    }
+
+    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabParamsDto):JfrViewerDefinition {
+        const params: JfrViewerTabParamsDto = paramsJson as JfrViewerTabParamsDto
+        return new JfrViewerDefinition('JFR Recordings', this.createTabParams(this.connectionService.getConnection(params.connection.id)))
+    }
+}
+
+export function useJfrViewerTabFactory(): JfrViewerTabFactory {
+    return mandatoryInject(jfrViewerTabFactoryInjectionKey) as JfrViewerTabFactory
+}
diff --git a/src/modules/jobs/JobModuleRegistrar.ts b/src/modules/jobs/JobModuleRegistrar.ts
deleted file mode 100644
index c177d715..00000000
--- a/src/modules/jobs/JobModuleRegistrar.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { ModuleContextBuilder } from "@/ModuleContextBuilder";
-import { ModuleRegistrar } from "@/ModuleRegistrar";
-import { EvitaDBDriverResolver, evitaDBDriverResolverInjectionKey } from "../connection/driver/EvitaDBDriverResolver";
-import { JobService, jobServiceInjectionKey } from "./services/JobService";
-
-export class JobModuleRegistrar implements ModuleRegistrar {
-    register(builder: ModuleContextBuilder): void {
-        const evitaDBDriverResolver: EvitaDBDriverResolver = builder.inject(evitaDBDriverResolverInjectionKey)
-        const jobService: JobService = new JobService(evitaDBDriverResolver)
-        builder.provide(jobServiceInjectionKey, jobService)
-    }
-}
\ No newline at end of file
diff --git a/src/modules/jobs/components/JobVisualizer.vue b/src/modules/jobs/components/JobVisualizer.vue
deleted file mode 100644
index eedd224d..00000000
--- a/src/modules/jobs/components/JobVisualizer.vue
+++ /dev/null
@@ -1,209 +0,0 @@
-<template>
-    <div>
-        <VList>
-            <VListItem v-for="item in jobs" :key="item.taskId.code">
-                <VRow class="align-center">
-                    <VCol>
-                        <div class="d-flex align-center">
-                            <div
-                                :class="[
-                                    'circle',
-                                    item.progress < 100 ? 'processing' : 'done',
-                                ]"
-                            ></div>
-                            <template v-if="item.taskType === 'BackupTask'">
-                                <VIcon
-                                    class="mx-4"
-                                    icon="mdi-cloud-download-outline"
-                                ></VIcon>
-                            </template>
-                            <template
-                                v-else-if="item.taskType === 'JfrRecorderTask'"
-                            >
-                                <VIcon
-                                    class="mx-4"
-                                    icon="mdi-chart-timeline"
-                                ></VIcon>
-                            </template>
-                            <template
-                                v-else-if="item.taskType === 'MetricTask'"
-                            >
-                                <VIcon
-                                    class="mx-4"
-                                    icon="mdi-folder-information-outline"
-                                ></VIcon>
-                            </template>
-                            <VListItemTitle>{{ item.taskName }}</VListItemTitle>
-                        </div>
-                    </VCol>
-                    <VCol
-                        class="d-flex justify-end"
-                        cols="auto"
-                        v-if="item.started"
-                    >
-                        <div class="linear-progress-container">
-                            <VProgressLinear
-                                bg-color="blue-grey"
-                                color="lime"
-                                :model-value="item.progress"
-                            ></VProgressLinear>
-                        </div>
-                        <VBtn
-                            icon
-                            variant="flat"
-                            @click="cancelTask(item.taskId, item.taskType)"
-                            v-if="item.progress < 100"
-                        >
-                            <VIcon @click="cancelTask(item.taskId, item.taskType)"
-                                >mdi-window-close</VIcon
-                            >
-                        </VBtn>
-                        <VBtn icon variant="flat" disabled v-else>
-                            <VIcon>mdi-check</VIcon>
-                        </VBtn>
-                    </VCol>
-                    <VCol class="d-flex justify-end" cols="auto" v-else>
-                        <div class="circular-progress-container">
-                            <VProgressCircular
-                                color="white"
-                                class="circular-progress"
-                                indeterminate
-                            />
-                        </div>
-                        <VBtn
-                            icon
-                            variant="flat"
-                            @click="cancelTask(item.taskId, item.taskType)"
-                        >
-                            <VIcon @click="cancelTask(item.taskId, item.taskType)">mdi-window-close</VIcon>
-                        </VBtn>
-                    </VCol>
-                </VRow>
-            </VListItem>
-        </VList>
-        <VPagination
-            v-if="
-                taskStatuses?.totalNumberOfRecords &&
-                Math.ceil(taskStatuses?.totalNumberOfRecords / pageSize) > 1
-            "
-            :rounded="true"
-            @update:model-value="(x) => (pageNumber = x)"
-            :length="Math.ceil(taskStatuses?.totalNumberOfRecords! / pageSize)"
-        >
-        </VPagination>
-    </div>
-</template>
-
-<script setup lang="ts">
-import { Connection } from '@/modules/connection/model/Connection'
-import { JobService, useJobService } from '../services/JobService'
-import { ref } from 'vue'
-import { TaskStatuses } from '@/modules/connection/model/data/TaskStatuses'
-import { TaskSimplifiedState } from '@/modules/connection/model/data/TaskSimplifiedState'
-import { Uuid } from '@/modules/connection/model/data-type/Uuid'
-import { TaskStatus } from '@/modules/connection/model/data/TaskStatus'
-import { onUnmounted } from 'vue'
-
-const jobService: JobService = useJobService()
-const props = defineProps<{
-    connection: Connection
-    simplifiedState?: TaskSimplifiedState[]
-    taskType?: string
-}>()
-const emit = defineEmits<{
-    (e: 'taskEnded', taskId: string): void,
-    (e: 'stopJfr'):void
-}>()
-
-const pageNumber = ref<number>(1)
-const pageSize = ref<number>(5)
-const taskStatuses = ref<TaskStatuses>()
-const jobs = ref<TaskStatus[]>()
-const loadedTaskStatuses = ref<boolean>()
-
-getJobs().then()
-
-async function getJobs() {
-    const newJobs = await jobService.getJobs(
-        props.connection,
-        pageNumber.value,
-        pageSize.value,
-        props.simplifiedState,
-        props.taskType
-    )
-    const endedJobs = newJobs.taskStatus.filter(
-        (x) =>
-            !taskStatuses.value?.taskStatus.some(
-                (y) => y.taskId.code === x.taskId.code
-            )
-    )
-    for (const job of endedJobs) {
-        emit('taskEnded', job.taskId.code)
-    }
-    if (newJobs.pageNumber > 1 && taskStatuses.value?.taskStatus.size === 0) {
-        pageNumber.value--
-    }
-    taskStatuses.value = newJobs
-    jobs.value = newJobs.taskStatus.toArray()
-    loadedTaskStatuses.value = true
-}
-
-async function cancelTask(jobId: Uuid, taskType: string) {
-    if (taskType === '') {
-        const result = await jobService.cancelJob(props.connection, jobId)
-        if (result) {
-            jobs.value = taskStatuses.value?.taskStatus
-                .filter((x) => x.taskId.code === jobId.code)
-                .toArray()
-        }
-    } else {
-        emit('stopJfr')
-    }
-}
-
-const jobIntervalId = setInterval(getJobs, 100)
-
-onUnmounted(() => {
-    clearInterval(jobIntervalId)
-})
-</script>
-
-<style lang="scss" scoped>
-@import '@/styles/colors.scss';
-
-.linear-progress-container {
-    width: 100px;
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-}
-
-.circular-progress-container {
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-}
-
-.circular-progress {
-    height: 24px;
-    width: 24px;
-}
-
-.done {
-    background-color: $success;
-}
-
-.processing {
-    background-color: $warning;
-}
-
-.circle {
-    display: inline-block;
-    width: 10px;
-    height: 10px;
-    margin-right: 8px;
-    border-radius: 50%;
-}
-.white-space {
-}
-</style>
diff --git a/src/modules/jobs/components/JobsControl.vue b/src/modules/jobs/components/JobsControl.vue
deleted file mode 100644
index 49f2c100..00000000
--- a/src/modules/jobs/components/JobsControl.vue
+++ /dev/null
@@ -1,30 +0,0 @@
-<template>
-    <TabWindowBody :path="path" :visible-button="false" icon="mdi-chart-gantt">
-        <JobVisualizer :connection="props.params.connection" />
-    </TabWindowBody>
-</template>
-
-<script setup lang="ts">
-import TabWindowBody from '@/modules/global/components/TabWindowBody.vue'
-import { useI18n } from 'vue-i18n'
-import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
-import { JobTabParams } from '@/modules/jobs/model/JobTabParams'
-import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
-import { List } from 'immutable'
-import JobVisualizer from '@/modules/jobs/components/JobVisualizer.vue'
-import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
-
-const { t } = useI18n()
-
-const props = defineProps<TabComponentProps<JobTabParams, VoidTabData>>()
-const emit = defineEmits<TabComponentEvents>()
-
-
-const path: List<string> = List([t('jobs.path')])
-emit('ready')
-
-</script>
-
-<style scoped>
-
-</style>
diff --git a/src/modules/jobs/model/JobDefinition.ts b/src/modules/jobs/model/JobDefinition.ts
deleted file mode 100644
index 9dcab1dd..00000000
--- a/src/modules/jobs/model/JobDefinition.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { TabDefinition } from '@/modules/workspace/tab/model/TabDefinition'
-import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
-import { DefineComponent, markRaw } from 'vue'
-import { JobTabParams } from '@/modules/jobs/model/JobTabParams'
-import JobsControl from '@/modules/jobs/components/JobsControl.vue'
-
-export class JobDefinition extends TabDefinition<JobTabParams, VoidTabData> {
-    constructor(title: string, params: JobTabParams) {
-        super(undefined, title, 'mdi-chart-gantt', markRaw(JobsControl as DefineComponent<any, any, any>), params, new VoidTabData())
-    }
-}
diff --git a/src/modules/jobs/services/JobService.ts b/src/modules/jobs/services/JobService.ts
deleted file mode 100644
index f0b6fd22..00000000
--- a/src/modules/jobs/services/JobService.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { EvitaDBDriverResolver } from "@/modules/connection/driver/EvitaDBDriverResolver";
-import { Connection } from "@/modules/connection/model/Connection";
-import { Uuid } from "@/modules/connection/model/data-type/Uuid";
-import { TaskSimplifiedState } from "@/modules/connection/model/data/TaskSimplifiedState";
-import { TaskStatuses } from "@/modules/connection/model/data/TaskStatuses";
-import { mandatoryInject } from "@/utils/reactivity";
-import { InjectionKey } from "vue";
-
-export const jobServiceInjectionKey: InjectionKey<JobService> = Symbol('jobService')
-
-export class JobService {
-    private readonly evitaDBDriverResolver: EvitaDBDriverResolver
-
-    constructor(evitaDBDriver: EvitaDBDriverResolver) {
-        this.evitaDBDriverResolver = evitaDBDriver
-    }
-
-    async getJobs(connection: Connection, pageNumber: number, pageSize: number, simplifiedState?: TaskSimplifiedState[], taskType?: string):Promise<TaskStatuses>{
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.getActiveJobs(connection, pageNumber, pageSize, simplifiedState, taskType)
-    }
-
-    async cancelJob(connection: Connection, jobId: Uuid):Promise<boolean>{
-        const driver = await this.evitaDBDriverResolver.resolveDriver(connection)
-        return await driver.cancelJob(connection, jobId)
-    }
-}
-
-export const useJobService = (): JobService => {
-    return mandatoryInject(jobServiceInjectionKey) as JobService
-}
diff --git a/src/modules/jobs/services/JobTabFactory.ts b/src/modules/jobs/services/JobTabFactory.ts
deleted file mode 100644
index 5956494c..00000000
--- a/src/modules/jobs/services/JobTabFactory.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { InjectionKey } from 'vue'
-import { ConnectionService } from '@/modules/connection/service/ConnectionService'
-import { Connection } from '@/modules/connection/model/Connection'
-import { JobDefinition } from '@/modules/jobs/model/JobDefinition'
-import { JobTabParams } from '@/modules/jobs/model/JobTabParams'
-import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
-import { TabDataDto } from '@/modules/workspace/tab/model/TabDataDto'
-import { JobTabParamsDto } from '@/modules/jobs/model/JobTabParamsDto'
-import { mandatoryInject } from '@/utils/reactivity'
-
-export const jobTabFactoryInjectionKey: InjectionKey<JobTabFactory> = Symbol('JobTabFactory')
-
-export class JobTabFactory {
-    private readonly connectionService: ConnectionService
-
-    constructor(connectionService: ConnectionService) {
-        this.connectionService = connectionService
-    }
-
-    createNew(connection: Connection, executeOnOpen: boolean = false):JobDefinition {
-        return new JobDefinition('Jobs',this.createTabParams(connection, executeOnOpen))
-    }
-
-    private createTabParams(connection: Connection, executeOnOpen: boolean = false):JobTabParams {
-        return new JobTabParams(connection, executeOnOpen)
-    }
-
-    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabDataDto):JobDefinition{
-        const params: JobTabParamsDto = paramsJson as JobTabParamsDto
-        return new JobDefinition('Jobs', this.createTabParams(this.connectionService.getConnection(params.connection.id)))
-    }
-}
-
-export const useJobTabFactory = ():JobTabFactory => {
-    return mandatoryInject(jobTabFactoryInjectionKey) as JobTabFactory
-}
diff --git a/src/modules/modules.ts b/src/modules/modules.ts
index be1bd167..f4b02607 100644
--- a/src/modules/modules.ts
+++ b/src/modules/modules.ts
@@ -11,10 +11,10 @@ import { ConfigModuleRegistrar } from '@/modules/config/ConfigModuleRegistrar'
 import { StorageModuleRegistrar } from '@/modules/storage/StorageModuleRegistrar'
 import { WelcomeScreenModuleRegistrar } from '@/modules/welcome-screen/WelcomeScreenModuleRegistrar'
 import { KeymapModuleRegistrar } from '@/modules/keymap/KeymapModuleRegistrar'
-import { BackupsModuleRegistrar } from './backups/BackupsModuleRegistrar'
-import { JobModuleRegistrar } from '@/modules/jobs/JobModuleRegistrar'
+import { BackupViewerModuleRegistrar } from '@/modules/backup-viewer/BackupViewerModuleRegistrar'
+import { TaskViewerModuleRegistrar } from '@/modules/task-viewer/TaskViewerModuleRegistrar'
 import { ServerActionsModuleRegistrar } from '@/modules/server-status/ServerActionsModuleRegistrar'
-import { JfrModuleRegistrar } from '@/modules/jfr-recording/JfrModuleRegistrar'
+import { JfrViewerModuleRegistrar } from '@/modules/jfr-viewer/JfrViewerModuleRegistrar'
 
 // todo docs
 export const modules: ModuleRegistrar[] = [
@@ -34,7 +34,7 @@ export const modules: ModuleRegistrar[] = [
     new EntityViewerModuleRegistrar(),
     new SchemaViewerModuleRegistrar(),
     new ServerActionsModuleRegistrar(),
-    new BackupsModuleRegistrar(),
-    new JobModuleRegistrar(),
-    new JfrModuleRegistrar()
+    new BackupViewerModuleRegistrar(),
+    new TaskViewerModuleRegistrar(),
+    new JfrViewerModuleRegistrar()
 ]
diff --git a/src/modules/server-status/component/ServerStatus.vue b/src/modules/server-status/component/ServerStatus.vue
index 9ce1ae16..c833f7e9 100644
--- a/src/modules/server-status/component/ServerStatus.vue
+++ b/src/modules/server-status/component/ServerStatus.vue
@@ -2,19 +2,19 @@
 import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
 import { useServerStatusService } from '../service/ServerStatusService'
 import { ref } from 'vue'
-import { ServerStatus } from '@/modules/connection/model/data/ServerStatus'
 import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
 import { ServerStatusTabParams } from '../model/ServerStatusTabParams'
 import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
 import { Duration } from 'luxon'
-import { ApiReadiness } from '@/modules/connection/model/data/ApiReadiness'
-import { ApiServerStatus } from '@/modules/connection/model/data/ApiServerStatus'
-import { ApiEndpoint } from '@/modules/connection/model/data/ApiEndpoint'
 import { List } from 'immutable'
 import { useI18n } from 'vue-i18n'
 import VTabToolbar from '@/modules/base/component/VTabToolbar.vue'
 import RuntimeConfigurationDialog from '@/modules/server-status/component/RuntimeConfigurationDialog.vue'
 import { EvitaLabConfig, useEvitaLabConfig } from '@/modules/config/EvitaLabConfig'
+import { ServerStatus } from '@/modules/connection/model/status/ServerStatus'
+import { ApiReadiness } from '@/modules/connection/model/status/ApiReadiness'
+import { ApiServerStatus } from '@/modules/connection/model/status/ApiServerStatus'
+import { ApiEndpoint } from '@/modules/connection/model/status/ApiEndpoint'
 
 const emit = defineEmits<TabComponentEvents>()
 const props = defineProps<TabComponentProps<ServerStatusTabParams, VoidTabData>>()
diff --git a/src/modules/server-status/service/ServerStatusService.ts b/src/modules/server-status/service/ServerStatusService.ts
index bedac352..22540931 100644
--- a/src/modules/server-status/service/ServerStatusService.ts
+++ b/src/modules/server-status/service/ServerStatusService.ts
@@ -1,10 +1,10 @@
 import { EvitaDBDriverResolver } from '@/modules/connection/driver/EvitaDBDriverResolver'
 import { Connection } from '@/modules/connection/model/Connection'
-import { ApiReadiness } from '@/modules/connection/model/data/ApiReadiness'
-import { ApiServerStatus } from '@/modules/connection/model/data/ApiServerStatus'
-import { ServerStatus } from '@/modules/connection/model/data/ServerStatus'
 import { mandatoryInject } from '@/utils/reactivity'
 import { InjectionKey } from 'vue'
+import { ServerStatus } from '@/modules/connection/model/status/ServerStatus'
+import { ApiReadiness } from '@/modules/connection/model/status/ApiReadiness'
+import { ApiServerStatus } from '@/modules/connection/model/status/ApiServerStatus'
 
 export const serverStatusServiceInjectionKey: InjectionKey<ServerStatusService> = Symbol('serverStatusService')
 
diff --git a/src/modules/task-viewer/TaskViewerModuleRegistrar.ts b/src/modules/task-viewer/TaskViewerModuleRegistrar.ts
new file mode 100644
index 00000000..db2325b4
--- /dev/null
+++ b/src/modules/task-viewer/TaskViewerModuleRegistrar.ts
@@ -0,0 +1,13 @@
+import { ModuleContextBuilder } from "@/ModuleContextBuilder";
+import { ModuleRegistrar } from "@/ModuleRegistrar";
+import { EvitaDBDriverResolver, evitaDBDriverResolverInjectionKey } from "../connection/driver/EvitaDBDriverResolver";
+import { TaskViewerService, taskViewerServiceInjectionKey } from "./services/TaskViewerService";
+import { ConnectionService, connectionServiceInjectionKey } from '@/modules/connection/service/ConnectionService'
+
+export class TaskViewerModuleRegistrar implements ModuleRegistrar {
+    register(builder: ModuleContextBuilder): void {
+        const connectionService: ConnectionService = builder.inject(connectionServiceInjectionKey)
+        const taskViewerService: TaskViewerService = new TaskViewerService(connectionService)
+        builder.provide(taskViewerServiceInjectionKey, taskViewerService)
+    }
+}
diff --git a/src/modules/task-viewer/components/TaskViewer.vue b/src/modules/task-viewer/components/TaskViewer.vue
new file mode 100644
index 00000000..7a9604ec
--- /dev/null
+++ b/src/modules/task-viewer/components/TaskViewer.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import { TabComponentProps } from '@/modules/workspace/tab/model/TabComponentProps'
+import { TaskViewerTabParams } from '@/modules/task-viewer/model/TaskViewerTabParams'
+import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
+import { List } from 'immutable'
+import { TabComponentEvents } from '@/modules/workspace/tab/model/TabComponentEvents'
+import TasksVisualizer from '@/modules/task-viewer/components/TasksVisualizer.vue'
+import VTabToolbar from '@/modules/base/component/VTabToolbar.vue'
+
+const { t } = useI18n()
+
+const props = defineProps<TabComponentProps<TaskViewerTabParams, VoidTabData>>()
+const emit = defineEmits<TabComponentEvents>()
+
+const path: List<string> = List([t('taskViewer.path')])
+emit('ready')
+
+</script>
+
+<template>
+    <div class="task-viewer">
+        <VTabToolbar :prepend-icon="'mdi-chart-gantt'" :path="path"/>
+
+        <TasksVisualizer :connection="props.params.connection" />
+    </div>
+</template>
+
+<style scoped>
+.task-viewer {
+    display: grid;
+    grid-template-rows: 3rem 1fr;
+
+    &__body {
+        position: relative;
+    }
+}
+</style>
diff --git a/src/modules/task-viewer/components/TasksVisualizer.vue b/src/modules/task-viewer/components/TasksVisualizer.vue
new file mode 100644
index 00000000..4b2dc06d
--- /dev/null
+++ b/src/modules/task-viewer/components/TasksVisualizer.vue
@@ -0,0 +1,275 @@
+<script setup lang="ts">
+import { Connection } from '@/modules/connection/model/Connection'
+import { TaskViewerService, useTaskViewerService } from '../services/TaskViewerService'
+import { computed, ref, watch } from 'vue'
+import { onUnmounted } from 'vue'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+import { TaskStatuses } from '@/modules/connection/model/task/TaskStatuses'
+import { TaskStatus } from '@/modules/connection/model/task/TaskStatus'
+import { Toaster, useToaster } from '@/modules/notification/service/Toaster'
+import { useI18n } from 'vue-i18n'
+
+const taskViewerService: TaskViewerService = useTaskViewerService()
+const toaster: Toaster = useToaster()
+const { t } = useI18n()
+
+const props = withDefaults(
+    defineProps<{
+        subheader?: string,
+        connection: Connection
+        states?: TaskState[]
+        taskType?: string,
+        pageSize?: number,
+        hideablePagination?: boolean,
+    }>(),
+    {
+        pageSize: 20,
+        hideablePagination: false
+    }
+)
+const emit = defineEmits<{
+    (e: 'update:activeJobsPresent', value: boolean): void
+}>()
+
+const tasksReloadIntervalId = setInterval(loadTaskStatuses, 2000)
+
+onUnmounted(() => {
+    clearInterval(tasksReloadIntervalId)
+})
+
+const pageNumber = ref<number>(1)
+const pageCount = computed<number>(() => {
+    if (taskStatuses.value == undefined) {
+        return 1
+    }
+    return Math.ceil(taskStatuses.value.totalNumberOfRecords / props.pageSize)
+})
+const taskStatuses = ref<TaskStatuses>()
+const taskStatusesItems = computed<TaskStatus[]>(() => {
+    if (taskStatuses.value == undefined) {
+        return []
+    }
+    return taskStatuses.value.statuses.toArray()
+})
+const loadedTaskStatuses = ref<boolean>(false)
+const shouldDisplayPagination = computed<boolean>(() => {
+    if (!props.hideablePagination) {
+        return true
+    }
+    if (taskStatuses.value == undefined) {
+        return false
+    }
+    return taskStatuses.value.totalNumberOfRecords > props.pageSize
+})
+
+watch(pageNumber, async () => {
+    await loadTaskStatuses()
+})
+watch(taskStatusesItems, async (newValue) => {
+    if (newValue != undefined && newValue.length > 0) {
+        emit('update:activeJobsPresent', true)
+    } else {
+        emit('update:activeJobsPresent', false)
+    }
+})
+
+loadTaskStatuses().then()
+
+async function loadTaskStatuses(): Promise<void> {
+    try {
+        const fetchedTaskStatuses: TaskStatuses = await taskViewerService.getTaskStates(
+            props.connection,
+            pageNumber.value,
+            props.pageSize,
+            props.states,
+            props.taskType
+        )
+        taskStatuses.value = fetchedTaskStatuses
+
+        if (fetchedTaskStatuses.pageNumber > 1 && taskStatuses.value?.statuses.size === 0) {
+            pageNumber.value--
+        }
+        if (!loadedTaskStatuses.value) {
+            loadedTaskStatuses.value = true
+        }
+    } catch (e: any) {
+        toaster.error(t('taskViewer.tasksVisualizer.notification.couldNotLoadTaskStatuses'))
+    }
+}
+
+async function cancelTask(taskStatus: TaskStatus): Promise<void> {
+    try {
+        const cancelled = await taskViewerService.cancelTask(props.connection, taskStatus.taskId)
+        if (cancelled) {
+            toaster.success(t(
+                'taskViewer.tasksVisualizer.notification.taskCancelled',
+                { taskName: taskStatus.taskName }
+            ))
+        } else {
+            toaster.info(t(
+                'taskViewer.tasksVisualizer.notification.taskNotCancelled',
+                { taskName: taskStatus.taskName }
+            ))
+        }
+        // visualize the cancel until the next full reload
+        taskStatus.cancelRequested()
+    } catch (e: any) {
+        toaster.error(t(
+            'taskViewer.tasksVisualizer.notification.couldNotCancelTask',
+            {
+                taskName: taskStatus.taskName,
+                reason: e.message
+            }
+        ))
+    }
+}
+</script>
+
+<template>
+    <VList v-if="loadedTaskStatuses">
+        <VListSubheader v-if="subheader !== undefined && subheader.length > 0">
+            {{ subheader }}
+        </VListSubheader>
+
+        <VDataIterator
+            :items="taskStatusesItems"
+            :page="pageNumber"
+            :items-per-page="pageSize"
+        >
+            <template #default="{ items }">
+                <VListItem v-for="item in items" :key="item.raw.taskId.code">
+                    <VRow class="align-center">
+                        <VCol>
+                            <div class="d-flex align-center">
+                                <div
+                                    :class="[
+                                'circle',
+                                item.raw.progress < 100 ? 'processing' : 'done',
+                            ]"
+                                ></div>
+                                <template v-if="item.raw.taskType === 'BackupTask'">
+                                    <VIcon
+                                        class="mx-4"
+                                        icon="mdi-cloud-download-outline"
+                                    ></VIcon>
+                                </template>
+                                <template
+                                    v-else-if="item.raw.taskType === 'JfrRecorderTask'"
+                                >
+                                    <VIcon
+                                        class="mx-4"
+                                        icon="mdi-chart-timeline"
+                                    ></VIcon>
+                                </template>
+                                <template
+                                    v-else-if="item.raw.taskType === 'MetricTask'"
+                                >
+                                    <VIcon
+                                        class="mx-4"
+                                        icon="mdi-folder-information-outline"
+                                    ></VIcon>
+                                </template>
+                                <VListItemTitle>{{ item.raw.taskName }}</VListItemTitle>
+                            </div>
+                        </VCol>
+                        <VCol
+                            v-if="item.raw.started"
+                            class="d-flex justify-end"
+                            cols="auto"
+                        >
+                            <div class="linear-progress-container">
+                                <VProgressLinear
+                                    v-if="item.raw.state == TaskState.Running"
+                                    :model-value="item.raw.progress"
+                                    bg-color="blue-grey"
+                                    color="lime"
+                                />
+                            </div>
+                            <slot
+                                v-if="item.raw.progress < 100"
+                                name="cancel-action"
+                                :task-status="item.raw"
+                            >
+                                <VBtn
+                                    v-if="item.raw.progress < 100"
+                                    icon="mdi-cancel"
+                                    variant="flat"
+                                    @click="cancelTask(item.raw)"
+                                />
+                            </slot>
+                            <VBtn v-else icon="mdi-check" density="compact" variant="flat" disabled />
+                        </VCol>
+                        <VCol class="d-flex justify-end" cols="auto" v-else>
+                            <div class="circular-progress-container">
+                                <VProgressCircular
+                                    color="white"
+                                    class="circular-progress"
+                                    indeterminate
+                                />
+                            </div>
+                            <slot
+                                name="cancel-action"
+                                :task-status="item.raw"
+                            >
+                                <VBtn
+                                    icon="mdi-cancel"
+                                    density="compact"
+                                    variant="flat"
+                                    @click="cancelTask(item.raw)"
+                                />
+                            </slot>
+                        </VCol>
+                    </VRow>
+                </VListItem>
+            </template>
+
+            <template #footer>
+                <VPagination
+                    v-if="shouldDisplayPagination"
+                    v-model="pageNumber"
+                    :length="pageCount"
+                />
+            </template>
+        </VDataIterator>
+    </VList>
+</template>
+
+<style lang="scss" scoped>
+@import '@/styles/colors.scss';
+
+.linear-progress-container {
+    width: 100px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+}
+
+.circular-progress-container {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+}
+
+.circular-progress {
+    height: 24px;
+    width: 24px;
+}
+
+.done {
+    background-color: $success;
+}
+
+.processing {
+    background-color: $warning;
+}
+
+.circle {
+    display: inline-block;
+    width: 10px;
+    height: 10px;
+    margin-right: 8px;
+    border-radius: 50%;
+}
+.white-space {
+}
+</style>
diff --git a/src/modules/task-viewer/model/TaskViewerDefinition.ts b/src/modules/task-viewer/model/TaskViewerDefinition.ts
new file mode 100644
index 00000000..8214cd06
--- /dev/null
+++ b/src/modules/task-viewer/model/TaskViewerDefinition.ts
@@ -0,0 +1,18 @@
+import { TabDefinition } from '@/modules/workspace/tab/model/TabDefinition'
+import { VoidTabData } from '@/modules/workspace/tab/model/void/VoidTabData'
+import { DefineComponent, markRaw } from 'vue'
+import { TaskViewerTabParams } from '@/modules/task-viewer/model/TaskViewerTabParams'
+import TaskViewer from '@/modules/task-viewer/components/TaskViewer.vue'
+
+export class TaskViewerDefinition extends TabDefinition<TaskViewerTabParams, VoidTabData> {
+    constructor(title: string, params: TaskViewerTabParams) {
+        super(
+            undefined,
+            title,
+            'mdi-chart-gantt',
+            markRaw(TaskViewer as DefineComponent<any, any, any>),
+            params,
+            new VoidTabData()
+        )
+    }
+}
diff --git a/src/modules/jobs/model/JobTabParams.ts b/src/modules/task-viewer/model/TaskViewerTabParams.ts
similarity index 69%
rename from src/modules/jobs/model/JobTabParams.ts
rename to src/modules/task-viewer/model/TaskViewerTabParams.ts
index cd1ccaf0..6ffd131b 100644
--- a/src/modules/jobs/model/JobTabParams.ts
+++ b/src/modules/task-viewer/model/TaskViewerTabParams.ts
@@ -1,19 +1,18 @@
 import { TabParams } from '@/modules/workspace/tab/model/TabParams'
-import { JobTabParamsDto } from '@/modules/jobs/model/JobTabParamsDto'
+import { TaskViewerTabParamsDto } from '@/modules/task-viewer/model/TaskViewerTabParamsDto'
 import { ExecutableTabRequest } from '@/modules/workspace/tab/model/ExecutableTabRequest'
 import { Connection } from '@/modules/connection/model/Connection'
 
-export class JobTabParams implements TabParams<JobTabParamsDto>, ExecutableTabRequest{
+export class TaskViewerTabParams implements TabParams<TaskViewerTabParamsDto>, ExecutableTabRequest{
     readonly  executeOnOpen: boolean
     readonly connection: Connection
 
-
     constructor(connection: Connection, executeOnOpen: boolean = false) {
         this.executeOnOpen = executeOnOpen
         this.connection = connection
     }
 
-    toSerializable(): JobTabParamsDto {
+    toSerializable(): TaskViewerTabParamsDto {
         return {
             connection: this.connection
         }
diff --git a/src/modules/jfr-recording/model/JfrVisualizerTabParamsDto.ts b/src/modules/task-viewer/model/TaskViewerTabParamsDto.ts
similarity index 73%
rename from src/modules/jfr-recording/model/JfrVisualizerTabParamsDto.ts
rename to src/modules/task-viewer/model/TaskViewerTabParamsDto.ts
index 2334aeab..475a242c 100644
--- a/src/modules/jfr-recording/model/JfrVisualizerTabParamsDto.ts
+++ b/src/modules/task-viewer/model/TaskViewerTabParamsDto.ts
@@ -1,6 +1,6 @@
-import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
 import { Connection } from '@/modules/connection/model/Connection'
+import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
 
-export interface JfrVisualizerTabParamsDto extends TabParamsDto {
+export interface TaskViewerTabParamsDto extends TabParamsDto {
     readonly connection: Connection
 }
diff --git a/src/modules/task-viewer/services/TaskViewerService.ts b/src/modules/task-viewer/services/TaskViewerService.ts
new file mode 100644
index 00000000..ae4214cc
--- /dev/null
+++ b/src/modules/task-viewer/services/TaskViewerService.ts
@@ -0,0 +1,35 @@
+import { Connection } from "@/modules/connection/model/Connection";
+import { Uuid } from "@/modules/connection/model/data-type/Uuid";
+import { mandatoryInject } from "@/utils/reactivity";
+import { InjectionKey } from "vue";
+import { TaskStatuses } from '@/modules/connection/model/task/TaskStatuses'
+import { TaskState } from '@/modules/connection/model/task/TaskState'
+import { ConnectionService } from '@/modules/connection/service/ConnectionService'
+
+export const taskViewerServiceInjectionKey: InjectionKey<TaskViewerService> = Symbol('taskViewerService')
+
+export class TaskViewerService {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService) {
+        this.connectionService = connectionService
+    }
+
+    async getTaskStates(connection: Connection,
+                        pageNumber: number,
+                        pageSize: number,
+                        states?: TaskState[],
+                        taskType?: string): Promise<TaskStatuses>{
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.getTaskStatuses(connection, pageNumber, pageSize, states, taskType)
+    }
+
+    async cancelTask(connection: Connection, taskId: Uuid): Promise<boolean> {
+        const driver = await this.connectionService.getDriver(connection)
+        return await driver.cancelTask(connection, taskId)
+    }
+}
+
+export function useTaskViewerService(): TaskViewerService {
+    return mandatoryInject(taskViewerServiceInjectionKey) as TaskViewerService
+}
diff --git a/src/modules/task-viewer/services/TaskViewerTabFactory.ts b/src/modules/task-viewer/services/TaskViewerTabFactory.ts
new file mode 100644
index 00000000..8a4e6642
--- /dev/null
+++ b/src/modules/task-viewer/services/TaskViewerTabFactory.ts
@@ -0,0 +1,37 @@
+import { InjectionKey } from 'vue'
+import { ConnectionService } from '@/modules/connection/service/ConnectionService'
+import { Connection } from '@/modules/connection/model/Connection'
+import { TaskViewerDefinition } from '@/modules/task-viewer/model/TaskViewerDefinition'
+import { TaskViewerTabParams } from '@/modules/task-viewer/model/TaskViewerTabParams'
+import { TabParamsDto } from '@/modules/workspace/tab/model/TabParamsDto'
+import { TabDataDto } from '@/modules/workspace/tab/model/TabDataDto'
+import { TaskViewerTabParamsDto } from '@/modules/task-viewer/model/TaskViewerTabParamsDto'
+import { mandatoryInject } from '@/utils/reactivity'
+
+export const taskViewerTabFactoryInjectionKey: InjectionKey<TaskViewerTabFactory> = Symbol('taskViewerTabFactory')
+
+export class TaskViewerTabFactory {
+    private readonly connectionService: ConnectionService
+
+    constructor(connectionService: ConnectionService) {
+        this.connectionService = connectionService
+    }
+
+    // todo lho i18n
+    createNew(connection: Connection, executeOnOpen: boolean = false):TaskViewerDefinition {
+        return new TaskViewerDefinition('Tasks',this.createTabParams(connection, executeOnOpen))
+    }
+
+    private createTabParams(connection: Connection, executeOnOpen: boolean = false):TaskViewerTabParams {
+        return new TaskViewerTabParams(connection, executeOnOpen)
+    }
+
+    restoreFromJson(paramsJson: TabParamsDto, dataJson?: TabDataDto):TaskViewerDefinition{
+        const params: TaskViewerTabParamsDto = paramsJson as TaskViewerTabParamsDto
+        return new TaskViewerDefinition('Tasks', this.createTabParams(this.connectionService.getConnection(params.connection.id)))
+    }
+}
+
+export const useTaskViewerTabFactory = ():TaskViewerTabFactory => {
+    return mandatoryInject(taskViewerTabFactoryInjectionKey) as TaskViewerTabFactory
+}
diff --git a/src/modules/workspace/WorkspaceModuleRegistrar.ts b/src/modules/workspace/WorkspaceModuleRegistrar.ts
index fc81c5e3..4e3ad16d 100644
--- a/src/modules/workspace/WorkspaceModuleRegistrar.ts
+++ b/src/modules/workspace/WorkspaceModuleRegistrar.ts
@@ -31,9 +31,9 @@ import {
     ServerStatusTabFactory,
     serverStatusTabFactoryInjectionKey
 } from '@/modules/server-status/service/ServerStatusTabFactory'
-import { BackupsTabFactory, backupsTabFactoryInjectionKey } from '../backups/service/BackupsTabFactory'
-import { JobTabFactory, jobTabFactoryInjectionKey } from '@/modules/jobs/services/JobTabFactory'
-import { JfrTabFactory, jfrTabFactoryInjectionKey } from '@/modules/jfr-recording/service/JfrTabFactory'
+import { BackupViewerTabFactory, backupsTabFactoryInjectionKey } from '@/modules/backup-viewer/service/BackupViewerTabFactory'
+import { TaskViewerTabFactory, taskViewerTabFactoryInjectionKey } from '@/modules/task-viewer/services/TaskViewerTabFactory'
+import { JfrViewerTabFactory, jfrViewerTabFactoryInjectionKey } from '@/modules/jfr-viewer/service/JfrViewerTabFactory'
 
 export class WorkspaceModuleRegistrar implements ModuleRegistrar {
 
@@ -56,11 +56,11 @@ export class WorkspaceModuleRegistrar implements ModuleRegistrar {
         builder.provide(keymapViewerTabFactoryInjectionKey, keymapViewerTabFactory)
         const serverStatusTabFactory: ServerStatusTabFactory = new ServerStatusTabFactory(connectionService)
         builder.provide(serverStatusTabFactoryInjectionKey, serverStatusTabFactory)
-        const jobTabFactory: JobTabFactory = new JobTabFactory(connectionService)
-        builder.provide(jobTabFactoryInjectionKey, jobTabFactory)
-        const jfrTabFactory: JfrTabFactory = new JfrTabFactory(connectionService)
-        builder.provide(jfrTabFactoryInjectionKey, jfrTabFactory)
-        const backupsTabFactory: BackupsTabFactory = new BackupsTabFactory(connectionService)
+        const jobTabFactory: TaskViewerTabFactory = new TaskViewerTabFactory(connectionService)
+        builder.provide(taskViewerTabFactoryInjectionKey, jobTabFactory)
+        const jfrTabFactory: JfrViewerTabFactory = new JfrViewerTabFactory(connectionService)
+        builder.provide(jfrViewerTabFactoryInjectionKey, jfrTabFactory)
+        const backupsTabFactory: BackupViewerTabFactory = new BackupViewerTabFactory(connectionService)
         builder.provide(backupsTabFactoryInjectionKey, backupsTabFactory)
         // todo lho fix circular dep
         // const entityViewerTabFactory: EntityViewerTabFactory = builder.inject(entityViewerTabFactoryInjectionKey)
diff --git a/src/modules/workspace/service/WorkspaceService.ts b/src/modules/workspace/service/WorkspaceService.ts
index 4a3a747e..97ca7523 100644
--- a/src/modules/workspace/service/WorkspaceService.ts
+++ b/src/modules/workspace/service/WorkspaceService.ts
@@ -25,7 +25,7 @@ import { KeymapViewerTabDefinition } from '@/modules/keymap/viewer/workspace/mod
 import { mandatoryInject } from '@/utils/reactivity'
 import { ServerStatusTabFactory } from '@/modules/server-status/service/ServerStatusTabFactory'
 import { ServerStatusTabDefinition } from '@/modules/server-status/model/ServerStatusTabDefinition'
-import { JobTabFactory } from '@/modules/jobs/services/JobTabFactory'
+import { TaskViewerTabFactory } from '@/modules/task-viewer/services/TaskViewerTabFactory'
 
 const openedTabsStorageKey: string = 'openedTabs'
 const tabHistoryStorageKey: string = 'tabHistory'
@@ -45,7 +45,7 @@ export class WorkspaceService {
     private readonly schemaViewerTabFactory: SchemaViewerTabFactory
     private readonly keymapViewerTabFactory: KeymapViewerTabFactory
     private readonly serverStatusTabFactory: ServerStatusTabFactory
-    private readonly jobTabFactory: JobTabFactory
+    private readonly jobTabFactory: TaskViewerTabFactory
 
     constructor(store: WorkspaceStore,
                 labStorage: LabStorage,
@@ -55,7 +55,7 @@ export class WorkspaceService {
                 schemaViewerTabFactory: SchemaViewerTabFactory,
                 keymapViewerTabFactory: KeymapViewerTabFactory,
                 serverStatusTabFactory: ServerStatusTabFactory,
-                jobTabFactory: JobTabFactory) {
+                jobTabFactory: TaskViewerTabFactory) {
         this.store = store
         this.labStorage = labStorage
         this.entityViewerTabFactory = entityViewerTabFactory
diff --git a/src/modules/workspace/tab/model/TabType.ts b/src/modules/workspace/tab/model/TabType.ts
index 7a0e563d..22bc28e0 100644
--- a/src/modules/workspace/tab/model/TabType.ts
+++ b/src/modules/workspace/tab/model/TabType.ts
@@ -1,6 +1,7 @@
 /**
  * Global listing of all implemented tab types.
  */
+// todo lho support for new tabs
 export enum TabType {
     EntityViewer = 'entityViewer',
     EvitaQLConsole = 'evitaQLConsole',
diff --git a/src/modules/workspace/tab/service/SharedTabResolver.ts b/src/modules/workspace/tab/service/SharedTabResolver.ts
index 939e4b51..1cba3e0c 100644
--- a/src/modules/workspace/tab/service/SharedTabResolver.ts
+++ b/src/modules/workspace/tab/service/SharedTabResolver.ts
@@ -9,7 +9,7 @@ import { GraphQLConsoleTabFactory } from '@/modules/graphql-console/console/work
 import { SchemaViewerTabFactory } from '@/modules/schema-viewer/viewer/workspace/service/SchemaViewerTabFactory'
 import { mandatoryInject } from '@/utils/reactivity'
 import { ServerStatusTabFactory } from '@/modules/server-status/service/ServerStatusTabFactory'
-import { JobTabFactory } from '@/modules/jobs/services/JobTabFactory'
+import { TaskViewerTabFactory } from '@/modules/task-viewer/services/TaskViewerTabFactory'
 
 export const sharedTabResolverInjectionKey: InjectionKey<SharedTabResolver> = Symbol('sharedTabResolver')
 
@@ -22,20 +22,20 @@ export class SharedTabResolver {
     private readonly graphQLConsoleTabFactory: GraphQLConsoleTabFactory
     private readonly schemaViewerTabFactory: SchemaViewerTabFactory
     private readonly serverStatusTabFactory: ServerStatusTabFactory
-    private readonly jobTabFactory: JobTabFactory
+    private readonly taskViewerTabFactory: TaskViewerTabFactory
 
     constructor(entityViewerTabFactory: EntityViewerTabFactory,
                 evitaQLConsoleTabFactory: EvitaQLConsoleTabFactory,
                 graphQLConsoleTabFactory: GraphQLConsoleTabFactory,
                 schemaViewerTabFactory: SchemaViewerTabFactory,
                 serverStatusTabFactory: ServerStatusTabFactory,
-                jobTabFactory: JobTabFactory) {
+                jobTabFactory: TaskViewerTabFactory) {
         this.entityViewerTabFactory = entityViewerTabFactory
         this.evitaQLConsoleTabFactory = evitaQLConsoleTabFactory
         this.graphQLConsoleTabFactory = graphQLConsoleTabFactory
         this.schemaViewerTabFactory = schemaViewerTabFactory
         this.serverStatusTabFactory = serverStatusTabFactory
-        this.jobTabFactory = jobTabFactory
+        this.taskViewerTabFactory = jobTabFactory
     }
 
     async resolve(shareTabObjectSerialized: string | undefined): Promise<TabDefinition<any, any> | undefined> {
diff --git a/src/vue-plugins/vuetify.ts b/src/vue-plugins/vuetify.ts
index 8a74c8be..a87ebf19 100644
--- a/src/vue-plugins/vuetify.ts
+++ b/src/vue-plugins/vuetify.ts
@@ -9,10 +9,14 @@ import '@mdi/font/css/materialdesignicons.css'
 import 'vuetify/styles'
 
 // Composables
+import { VDateInput } from 'vuetify/labs/VDateInput'
 import { createVuetify } from 'vuetify'
 
 // https://vuetifyjs.com/en/introduction/why-vuetify/#feature-guides
 export default createVuetify({
+    components: {
+        VDateInput,
+    },
     theme: {
         defaultTheme: 'dark',
         themes: {
diff --git a/yarn.lock b/yarn.lock
index 83c81535..391814fd 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3042,10 +3042,10 @@ vue@^3.2.0:
     "@vue/server-renderer" "3.3.4"
     "@vue/shared" "3.3.4"
 
-vuetify@^3.1.0:
-  version "3.7.0"
-  resolved "https://registry.yarnpkg.com/vuetify/-/vuetify-3.7.0.tgz#1230e97330b9112492aa25183809e483477b2c36"
-  integrity sha512-x+UaU4SPYNcJSE/voCTBFrNn0q9Spzx2EMfDdUj0NYgHGKb59OqnZte+AjaJaoOXy1AHYIGEpm5Ryk2BEfgWuw==
+vuetify@^3.6.0:
+  version "3.7.2"
+  resolved "https://registry.yarnpkg.com/vuetify/-/vuetify-3.7.2.tgz#e37fa4c191ea00144de5943315cbf77ddb80448d"
+  integrity sha512-q0WTcRG977+a9Dqhb8TOaPm+Xmvj0oVhnBJhAdHWFSov3HhHTTxlH2nXP/GBTXZuuMHDbBeIWFuUR2/1Fx0PPw==
 
 w3c-keyname@^2.2.4:
   version "2.2.8"