feature "import/export" (2nd iteration)

- remove unnecessary code and simplify it
- remove the unstable profile directory export and import functionality
- remove the abort function and button, as the process is so quick that they are completely unnecessary.
- define gladefiles constants at the beginning of webapp-manager.py

Author: JW-CodeArt

usr/lib/webapp-manager/common.py

@@ -65,16 +65,14 @@ def wrapper(*args):
 BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, BROWSER_TYPE_LIBREWOLF_FLATPAK, BROWSER_TYPE_WATERFOX_FLATPAK, BROWSER_TYPE_FLOORP_FLATPAK, BROWSER_TYPE_CHROMIUM, BROWSER_TYPE_EPIPHANY, BROWSER_TYPE_FALKON = range(9)
 
 class ei_task:
-    def __init__(self, result_callback, update_callback, builder, webAppLauncherSelf, window, stop_event, task):
+    def __init__(self, result_callback, update_callback, builder, webAppLauncherSelf, window, task):
         self.result_callback = result_callback
         self.update_callback = update_callback
         self.builder = builder
         self.webAppLauncherSelf = webAppLauncherSelf
         self.path = ""
         self.window = window
-        self.stop_event = stop_event
         self.task = task
-        self.include_browserdata = False
         self.result = "error"
 
 class Browser:
@@ -559,16 +557,12 @@ def download_favicon(url):
     images = sorted(images, key = lambda x: x[1].height, reverse=True)
     return images
 
+@_async
 def export_config(ei_task_info: ei_task):
     # The export process in the background.
     try:
-        # Collect all files
-        webapps = get_all_desktop_files()
-        if ei_task_info.include_browserdata:
-            ice_files = get_all_files(ICE_DIR)
-        else:
-            ice_files = get_all_files(ICONS_DIR)
-        files = webapps + ice_files
+        # Search all files
+        files =  get_all_desktop_files() + get_all_icons()
         total = len(files)
         update_interval = 1 if int(total / 100) < 1 else int(total / 100)
 
@@ -580,99 +574,46 @@ def export_config(ei_task_info: ei_task):
                 if counter % update_interval == 0:
                     progress = round(counter / total, 2)
                     GLib.idle_add(ei_task_info.update_callback, ei_task_info, progress)
-
-                if ei_task_info.stop_event.is_set():
-                    # The user aborts the process.
-                    tar.close()
-                    clean_up_export(ei_task_info)
-                    return "cancelled"
+                
                 counter += 1
-
+        
+        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
         ei_task_info.result = "ok"
     except Exception as e:
         print(e)
         ei_task_info.result = "error"
 
     GLib.idle_add(ei_task_info.result_callback, ei_task_info)
 
-def clean_up_export(ei_task_info: ei_task):
-    # Remove the rest of the exported file when the user aborts the process.
-    if os.path.exists(ei_task_info.path):
-        os.remove(ei_task_info.path)
-    GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
-
+@_async
 def import_config(ei_task_info: ei_task):
     # The import process in the background.
     try:
-        # Make a list of the files beforehand so that the file structure can be restored 
-        # if the user aborts the import process.
-        files_before = get_files_dirs(ICE_DIR) + get_files_dirs(APPS_DIR)
-
         with tarfile.open(ei_task_info.path, "r:gz") as tar:
             files = tar.getnames()
             total = len(files)
             base_dir = os.path.dirname(ICE_DIR)
             update_interval = 1 if int(total / 100) < 1 else int(total / 100)
             counter = 0
             for file in files:
-                # Exclude the file if it belongs to the browser data.
-                no_browserdata = ei_task_info.include_browserdata == False
-                is_ice_dir = file.startswith("ice/")
-                is_no_icon = not file.startswith("ice/icons")
-                if not(no_browserdata and is_ice_dir and is_no_icon):
-                    tar.extract(file, base_dir)
-                
+                tar.extract(file, base_dir)
                 if file.startswith("applications/"):
-                    # Redefine the "Exec" section. This is necessary if the username or browser path differs.
+                    # Rewrite the "Exec" section. This is necessary if the username differs.
                     path = os.path.join(base_dir, file)
                     update_exec_path(path)
 
                 if counter % update_interval == 0:
                     progress = round(counter / total, 2)
                     GLib.idle_add(ei_task_info.update_callback, ei_task_info, progress)
-                
-                if ei_task_info.stop_event.is_set():
-                    tar.close()
-                    clean_up_import(ei_task_info, files_before)
-                    return "cancelled"
                 counter += 1
+        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
         ei_task_info.result = "ok"
     except Exception as e:
         print(e)
         ei_task_info.result = "error"
 
     GLib.idle_add(ei_task_info.result_callback, ei_task_info)
 
-def clean_up_import(ei_task_info: ei_task, files_before):
-    # Delete all imported files if the import process is aborted.
-    try:
-        # Search all new files
-        files_now = get_files_dirs(ICE_DIR) + get_files_dirs(APPS_DIR)
-        new_files = list(set(files_now) - set(files_before))
-        for file in new_files:
-            if os.path.exists(file):
-                if os.path.isdir(file):
-                    shutil.rmtree(file)
-                else:
-                    os.remove(file)
-        
-        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
-    except Exception as e:
-        print(e)
-
-def check_browser_directories_tar(path):
-    # Check if the archive contains browser data.
-    try:
-        with tarfile.open(path, "r:gz") as tar:
-            for member in tar:
-                parts = member.name.strip("/").split("/")
-                if parts[0] == "ice" and parts[1] != "icons":
-                    tar.close()
-                    return True
-            tar.close()
-            return False
-    except:
-        return False
 
 def get_all_desktop_files():
     # Search all web apps and desktop files.
@@ -684,37 +625,31 @@ def get_all_desktop_files():
             files.append({"full_path":full_path, "arcname":arcname})
     return files
 
-def get_all_files(base_dir):
+def get_all_icons():
     # List all the files in a directory.
     files = []
-    for root, dirs, filenames in os.walk(base_dir):
+    for root, dirs, filenames in os.walk(ICONS_DIR):
         for filename in filenames:
             full_path = os.path.join(root, filename)
             arcname = ""
-            if base_dir == ICONS_DIR:
-                arcname += "ice/"
-            arcname += os.path.relpath(full_path, os.path.dirname(base_dir))
+            arcname += os.path.relpath(full_path, os.path.dirname(ICE_DIR))
             files.append({"full_path":full_path, "arcname":arcname})
     return files
 
-def get_files_dirs(base_dir):
-    # List all the files and subdirectories within a directory.
-    paths = []
-    for dirpath, dirnames, filenames in os.walk(base_dir):
-        paths.append(dirpath)
-        for name in filenames:
-            paths.append(os.path.join(dirpath, name))
-    return paths
 
-def update_exec_path(path):
-    # This updates the 'exec' section of an imported web application or creates the browser directory for it.
-    config = configparser.RawConfigParser()
-    config.optionxform = str
-    config.read(path)
+def get_codename(path):
     codename = os.path.basename(path)
     codename = codename.replace(".desktop", "")
     codename = codename.replace("WebApp-", "")
     codename = codename.replace("webapp-", "")
+    return codename
+
+def update_exec_path(path):
+    # This updates the 'exec' section of an imported web application or creates the profile directory for it.
+    config = configparser.RawConfigParser()
+    config.optionxform = str
+    config.read(path)
+    codename = get_codename(path)
     webapp = WebAppLauncher(path, codename)
     browsers = WebAppManager.get_supported_browsers()
     if "/" in webapp.icon:
@@ -725,7 +660,7 @@ def update_exec_path(path):
         iconpath = webapp.icon
 
     browser = next((browser for browser in browsers if browser.name == webapp.web_browser), None)
-    new_exec_line = WebAppManager.get_exec_string(None, browser, webapp.codename, webapp.custom_parameters, iconpath, webapp.isolate_profile, webapp.navbar, webapp.privatewindow, webapp.url)
+    new_exec_line = WebAppManager.get_exec_string(None, browser, codename, webapp.custom_parameters, iconpath, webapp.isolate_profile, webapp.navbar, webapp.privatewindow, webapp.url)
     config.set("Desktop Entry", "Exec", new_exec_line)
     with open(path, 'w') as configfile:
         config.write(configfile, space_around_delimiters=False)

usr/lib/webapp-manager/webapp-manager.py

@@ -22,7 +22,7 @@
 from gi.repository import Gtk, Gdk, Gio, XApp, GdkPixbuf
 
 #   3. Local application/library specific imports.
-from common import _async, idle, WebAppManager, download_favicon, BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, export_config, import_config, ei_task, check_browser_directories_tar
+from common import _async, idle, WebAppManager, download_favicon, BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, export_config, import_config, ei_task, ICONS_DIR
 
 setproctitle.setproctitle("webapp-manager")
 
@@ -38,6 +38,10 @@
 CATEGORY_ID, CATEGORY_NAME = range(2)
 BROWSER_OBJ, BROWSER_NAME = range(2)
 
+# Gladefiles
+MAIN_WINDOW_GLADEFILE = "/usr/share/webapp-manager/webapp-manager.ui"
+SHORTCUTS_GLADEFILE = "/usr/share/webapp-manager/shortcuts.ui"
+EI_TOOL_GLADEFILE = "/usr/share/webapp-manager/ei_tool.ui"
 
 class MyApplication(Gtk.Application):
     # Main initialization routine
@@ -68,10 +72,9 @@ def __init__(self, application):
         self.icon_theme = Gtk.IconTheme.get_default()
 
         # Set the Glade file
-        gladefile = "/usr/share/webapp-manager/webapp-manager.ui"
         self.builder = Gtk.Builder()
         self.builder.set_translation_domain(APP)
-        self.builder.add_from_file(gladefile)
+        self.builder.add_from_file(MAIN_WINDOW_GLADEFILE)
         self.window = self.builder.get_object("main_window")
         self.window.set_title(_("Web Apps"))
         self.window.set_icon_name("webapp-manager")
@@ -238,10 +241,9 @@ def data_func_surface(self, column, cell, model, iter_, *args):
         cell.set_property("surface", surface)
 
     def open_keyboard_shortcuts(self, widget):
-        gladefile = "/usr/share/webapp-manager/shortcuts.ui"
         builder = Gtk.Builder()
         builder.set_translation_domain(APP)
-        builder.add_from_file(gladefile)
+        builder.add_from_file(SHORTCUTS_GLADEFILE)
         window = builder.get_object("shortcuts-webappmanager")
         window.set_title(_("Web Apps"))
         window.show()
@@ -559,28 +561,23 @@ def load_webapps(self):
     # Export and Import feature "ei"
     def open_ei_tool(self, action):
         # Open the import / export window
-        gladefile = "/usr/share/webapp-manager/ei_tool.ui"
         builder = Gtk.Builder()
         builder.set_translation_domain(APP)
-        builder.add_from_file(gladefile)
+        builder.add_from_file(EI_TOOL_GLADEFILE)
         window = builder.get_object("window")
+
         # Translate text and prepare widgets
         if action == "export":
             window.set_title(_("Export Tool"))
         else:
             window.set_title(_("Import Tool"))
         builder.get_object("choose_location_text").set_text(_("Choose a location"))
-        builder.get_object("include_browserdata").set_label(_("BETA: Include Browser data (Config, Cache, Extensions...)\nIt requires the same browser version on the destination computer\nIt might take some time."))
-        builder.get_object("no_browser_data").set_text(_("Browser data import not available because \nit is not included in the importet file."))
-        builder.get_object("no_browser_data").set_visible(False)
         builder.get_object("start_button").set_label(_("Start"))
         builder.get_object("start_button").connect("clicked", lambda button: self.ei_start_process(button, ei_task_info))
-        builder.get_object("cancel_button").set_visible(False)
-        builder.get_object("select_location_button").connect("clicked", lambda widget: self.select_location(ei_task_info))
+        builder.get_object("select_location_button").connect("clicked", lambda widget: self.ei_select_location(ei_task_info))
 
         # Prepare ei_task_info which stores all the values for the import / export
-        stop_event = threading.Event()
-        ei_task_info = ei_task(self.show_ei_result, self.update_ei_progress, builder, self, window, stop_event, action)
+        ei_task_info = ei_task(self.show_ei_result, self.update_ei_progress, builder, self, window, action)
         window.show()
 
     def ei_start_process(self, button, ei_task_info: ei_task):
@@ -589,25 +586,24 @@ def ei_start_process(self, button, ei_task_info: ei_task):
         path = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
         if path != "":
             ei_task_info.path = path
-            ei_task_info.include_browserdata = ei_task_info.builder.get_object("include_browserdata").get_active()
             button.set_sensitive(False)
             if ei_task_info.task == "export":
-                thread = threading.Thread(target=export_config, args=(ei_task_info,))
+                export_config(ei_task_info)
+                #thread = threading.Thread(target=export_config, args=(ei_task_info,))
             else:
-                thread = threading.Thread(target=import_config, args=(ei_task_info,))
-            thread.start()
-            ei_task_info.builder.get_object("cancel_button").set_visible(True)
-            ei_task_info.builder.get_object("cancel_button").connect("clicked", lambda button: self.abort_ei(button, ei_task_info, thread))
+                import_config(ei_task_info)
+                #thread = threading.Thread(target=import_config, args=(ei_task_info,))
+            #thread.start()
 
 
-    def select_location(self, ei_task_info: ei_task):
+    def ei_select_location(self, ei_task_info: ei_task):
         # Open the file chooser window
         if ei_task_info.task == "export":
             buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK)
             dialog = Gtk.FileChooserDialog(_("Export Configuration - Please choose a file location"), self.window, Gtk.FileChooserAction.SAVE, buttons)
         else:
             buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)
-            dialog = Gtk.FileChooserDialog(_("Import Configuration - Please select the file"), self.window, Gtk.FileChooserAction.OPEN, buttons)
+            dialog = Gtk.FileChooserDialog(_("Import Configuration - Please select the archive"), self.window, Gtk.FileChooserAction.OPEN, buttons)
 
         filter = Gtk.FileFilter()
         filter.set_name(".tar.gz")
@@ -619,41 +615,20 @@ def select_location(self, ei_task_info: ei_task):
             if ei_task_info.task == "export":
                 path += ".tar.gz"
             ei_task_info.builder.get_object("file_path").get_buffer().set_text(path)
-
-            # Check if include browser data is available 
-            include_browser_available = True
-            if ei_task_info.task == "import":
-                if not check_browser_directories_tar(path):
-                    include_browser_available = False
-            
-            ei_task_info.builder.get_object("include_browserdata").set_sensitive(include_browser_available)
-            ei_task_info.builder.get_object("no_browser_data").set_visible(not include_browser_available)
-            ei_task_info.builder.get_object("include_browserdata").set_active(include_browser_available)
         dialog.destroy()
 
-        
-    def abort_ei(self, button, ei_task_info:ei_task, thread):
-        # Abort the export / import process
-        button.set_sensitive(False)
-        self.update_ei_progress(ei_task_info, 0)
-        # The backend function will automatically clean up after the stop flag is triggered.
-        ei_task_info.stop_event.set()
-        thread.join()
-
     def update_ei_progress(self, ei_task_info:ei_task, progress):
-        # Update the progress bar or close the tool window by 100%.
+        # Update the progress bar
         try:
-            ei_task_info.builder.get_object("progress").set_fraction(progress)
-            if progress == 1:
-                ei_task_info.window.destroy()
+            ei_task_info.builder.get_object("progress").set_fraction(progress)                
         except:
             # The user closed the progress window
             pass
 
 
     def show_ei_result(self, ei_task_info:ei_task):
         # Displays a success or failure message when the process is complete.
-        ei_task_info.window.destroy()
+        ei_task_info.webAppLauncherSelf.load_webapps()
         if ei_task_info.result == "ok":
             message = _(ei_task_info.task.capitalize() + " completed!")
         else:
@@ -667,16 +642,19 @@ def show_ei_result(self, ei_task_info:ei_task):
             result = dialog.run()
             if result == 10:
                 # Open Containing Folder
-                print("open folder")
                 os.system("xdg-open " + os.path.dirname(ei_task_info.path))
         else:
             dialog = Gtk.MessageDialog(text=message, message_type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK)
             dialog.run()
 
         dialog.destroy()
-        ei_task_info.webAppLauncherSelf.load_webapps()
+        try:
+            ei_task_info.window.destroy()
+        except:
+            # User closed the window manually
+            pass
+        
 
 if __name__ == "__main__":
     application = MyApplication("org.x.webapp-manager", Gio.ApplicationFlags.FLAGS_NONE)
-    application.run()
-
+    application.run()