feat: show busy dialog while parsing archive contents for extract

Fixes #1570 — large archives could silently process for hours with only a
small status-bar line as feedback. Now shows a QProgressDialog (indeterminate)
that closes once parsing is done and the extract dialog opens.

Author: Temp User

src/vorta/assets/UI/dialogs/repo/change_passphrase.ui

@@ -55,42 +55,6 @@
      </property>
     </layout>
    </item>
-   <item>
-    <widget class="QLabel" name="errorText">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>0</width>
-       <height>20</height>
-      </size>
-     </property>
-     <property name="font">
-      <font>
-       <pointsize>11</pointsize>
-      </font>
-     </property>
-     <property name="text">
-      <string/>
-     </property>
-     <property name="textFormat">
-      <enum>Qt::PlainText</enum>
-     </property>
-     <property name="scaledContents">
-      <bool>false</bool>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
-     </property>
-     <property name="wordWrap">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>

src/vorta/profile_export.py

@@ -8,6 +8,7 @@
 from vorta.store.connection import DB, SCHEMA_VERSION, init_db
 from vorta.store.models import (
     BackupProfileModel,
+    ExclusionModel,
     RepoModel,
     SchemaVersion,
     SettingsModel,
@@ -64,6 +65,11 @@ def from_db(cls, profile, store_password=True, include_settings=True):
             model_to_dict(source, recurse=False, exclude=[SourceFileModel.id])
             for source in SourceFileModel.select().where(SourceFileModel.profile == profile)
         ]
+        # Add ExclusionModel
+        profile_dict['ExclusionModel'] = [
+            model_to_dict(exclusion, recurse=False, exclude=[ExclusionModel.id])
+            for exclusion in ExclusionModel.select().where(ExclusionModel.profile == profile)
+        ]
         # Add SchemaVersion
         profile_dict['SchemaVersion'] = model_to_dict(SchemaVersion.get(id=1))
 
@@ -127,18 +133,27 @@ def to_db(self, overwrite_profile=False, overwrite_settings=True):
             SettingsModel.insert_many(self._profile_dict['SettingsModel']).execute()
             WifiSettingModel.insert_many(self._profile_dict['WifiSettingModel']).execute()
 
-        # Set the profile ids to be match new profile
+        # Set the profile ids to match new profile
         for source in self._profile_dict['SourceFileModel']:
             source['profile'] = self.id
         # Delete existing Sources to avoid duplicates
         SourceFileModel.delete().where(SourceFileModel.profile == self.id).execute()
         SourceFileModel.insert_many(self._profile_dict['SourceFileModel']).execute()
 
+        # Restore ExclusionModel entries
+        if 'ExclusionModel' in self._profile_dict:
+            for exclusion in self._profile_dict['ExclusionModel']:
+                exclusion['profile'] = self.id
+            ExclusionModel.delete().where(ExclusionModel.profile == self.id).execute()
+            ExclusionModel.insert_many(self._profile_dict['ExclusionModel']).execute()
+
         # Delete added dictionaries to make it match BackupProfileModel
         del self._profile_dict['SettingsModel']
         del self._profile_dict['SourceFileModel']
         del self._profile_dict['WifiSettingModel']
         del self._profile_dict['SchemaVersion']
+        if 'ExclusionModel' in self._profile_dict:
+            del self._profile_dict['ExclusionModel']
 
         # dict to profile
         new_profile = dict_to_model(BackupProfileModel, self._profile_dict)

src/vorta/views/archive/archive_extract.py

@@ -0,0 +1,94 @@
+from PyQt6 import QtCore
+from PyQt6.QtWidgets import QProgressDialog
+from PyQt6.QtCore import Qt
+
+from vorta.borg.extract import BorgExtractJob
+from vorta.borg.list_archive import BorgListArchiveJob
+from vorta.store.models import ArchiveModel
+from vorta.utils import choose_file_dialog
+from vorta.views.dialogs.archive import extract as extract_dialog
+from vorta.views.dialogs.archive.extract import ExtractDialog, ExtractTree
+
+
+class ArchiveExtract:
+    def __init__(self, tab):
+        self.tab = tab
+
+    def extract_action(self):
+        """
+        Open a dialog for choosing what to extract from the selected archive.
+        """
+        profile = self.tab.profile()
+
+        row_selected = self.tab.archiveTable.selectionModel().selectedRows()
+        if row_selected:
+            archive_cell = self.tab.archiveTable.item(row_selected[0].row(), 4)
+            if archive_cell:
+                archive_name = archive_cell.text()
+                params = BorgListArchiveJob.prepare(profile, archive_name)
+
+                if not params['ok']:
+                    self.tab._set_status(params['message'])
+                    return
+                self.tab._set_status('')
+                self.tab._toggle_all_buttons(False)
+
+                job = BorgListArchiveJob(params['cmd'], params, self.tab.profile().repo.id)
+                job.updated.connect(self.tab.mountErrors.setText)
+                job.result.connect(self.extract_list_result)
+                self.tab.app.jobs_manager.add_job(job)
+                return job
+        else:
+            self.tab._set_status(self.tab.tr('Select an archive to restore first.'))
+
+    def extract_list_result(self, result):
+        """Process the contents of the archive to extract."""
+        self.tab._set_status('')
+        if result['returncode'] == 0:
+            archive = ArchiveModel.get(name=result['params']['archive_name'])
+            model = ExtractTree()
+            self.tab._set_status(self.tab.tr("Processing archive contents"))
+
+            progress = QProgressDialog(self.tab.tr("Processing archive contents…"), None, 0, 0, self.tab)
+            progress.setWindowTitle(self.tab.tr("Please wait"))
+            progress.setWindowModality(Qt.WindowModality.WindowModal)
+            progress.setMinimumDuration(0)
+            progress.setValue(0)
+            self.tab._extract_progress = progress
+
+            self.tab._t = extract_dialog.ParseThread(result['data'], model)
+            self.tab._t.finished.connect(self.tab._extract_progress.close)
+            self.tab._t.finished.connect(lambda: self.extract_show_dialog(archive, model))
+            self.tab._t.start()
+
+    def extract_show_dialog(self, archive, model):
+        """Show the dialog for choosing the archive contents to extract."""
+        self.tab._set_status('')
+
+        def process_result():
+            def receive():
+                extraction_folder = dialog.selectedFiles()
+                if extraction_folder:
+                    params = BorgExtractJob.prepare(self.tab.profile(), archive.name, model, extraction_folder[0])
+                    if params['ok']:
+                        self.tab._toggle_all_buttons(False)
+                        job = BorgExtractJob(params['cmd'], params, self.tab.profile().repo.id)
+                        job.updated.connect(self.tab.mountErrors.setText)
+                        job.result.connect(self.extract_archive_result)
+                        self.tab.app.jobs_manager.add_job(job)
+                    else:
+                        self.tab._set_status(params['message'])
+
+            dialog = choose_file_dialog(self.tab, self.tab.tr("Choose Extraction Point"), want_folder=True)
+            dialog.open(receive)
+
+        window = ExtractDialog(archive, model)
+        self.tab._toggle_all_buttons(True)
+        window.setParent(self.tab, QtCore.Qt.WindowType.Sheet)
+        self.tab._window = window  # for testing
+        window.show()
+        window.accepted.connect(process_result)
+
+    def extract_archive_result(self, result):
+        """Finished extraction."""
+        self.tab._toggle_all_buttons(True)