feature "import/export" (3rd iteration)

- update text and function names
- removed the ei_task class as it is no longer needed
- created a get_codename() function as this is used twice in common.py
- removed the tool window and the progress tracking because they are not needed
- removed the browser profile export feature because it is unstable. It takes extremely long and does not work with different browser versions
- implemented a function which checks during the import process whether the browser is installed on the device. If not, it searches an alternative browser on the device.
- declared gladefiles paths as constants at the beginning of webapp-manager.py
- removed all trailing spaces
- applied the maximum line length

Author: JW-CodeArt

usr/lib/webapp-manager/common.py

@@ -64,17 +64,6 @@ def wrapper(*args):
 ICONS_DIR = os.path.join(ICE_DIR, "icons")
 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, task):
-        self.result_callback = result_callback
-        self.update_callback = update_callback
-        self.builder = builder
-        self.webAppLauncherSelf = webAppLauncherSelf
-        self.path = ""
-        self.window = window
-        self.task = task
-        self.result = "error"
-
 class Browser:
 
     def __init__(self, browser_type, name, exec_path, test_path):
@@ -170,7 +159,7 @@ def get_webapps(self):
         for filename in os.listdir(APPS_DIR):
             if filename.lower().startswith("webapp-") and filename.endswith(".desktop"):
                 path = os.path.join(APPS_DIR, filename)
-                codename = filename.replace("webapp-", "").replace("WebApp-", "").replace(".desktop", "")
+                codename = get_codename(path)
                 if not os.path.isdir(path):
                     try:
                         webapp = WebAppLauncher(path, codename)
@@ -315,8 +304,8 @@ def create_webapp(self, name, url, icon, category, browser, custom_parameters, i
                 falkon_orig_prof_dir = os.path.join(os.path.expanduser("~/.config/falkon/profiles"), codename)
                 os.symlink(falkon_profile_path, falkon_orig_prof_dir)
 
-
-    def get_exec_string(self, browser, codename, custom_parameters, icon, isolate_profile, navbar, privatewindow, url):
+    @staticmethod
+    def get_exec_string( browser, codename, custom_parameters, icon, isolate_profile, navbar, privatewindow, url):
         if browser.browser_type in [BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP]:
             # Firefox based
             if browser.browser_type == BROWSER_TYPE_FIREFOX:
@@ -558,61 +547,41 @@ def download_favicon(url):
     return images
 
 @_async
-def export_config(ei_task_info: ei_task):
-    # The export process in the background.
+def export_webapps(callback, path):
+    # The background export process
     try:
-        # 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)
-
+        desktop_files = get_all_desktop_files()
         # Write the .tar.gz file
-        with tarfile.open(ei_task_info.path, "w:gz") as tar:
-            counter = 0
-            for file in files:
-                tar.add(file["full_path"], arcname=file["arcname"])
-                if counter % update_interval == 0:
-                    progress = round(counter / total, 2)
-                    GLib.idle_add(ei_task_info.update_callback, ei_task_info, progress)
-                
-                counter += 1
-        
-        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
-        ei_task_info.result = "ok"
+        with tarfile.open(path, "w:gz") as tar:
+            for desktop_file in desktop_files:
+                tar.add(desktop_file["full_path"], arcname=desktop_file["arcname"])
+            tar.add(ICONS_DIR, "ice/icons/")
+        result = "ok"
     except Exception as e:
         print(e)
-        ei_task_info.result = "error"
-    
-    GLib.idle_add(ei_task_info.result_callback, ei_task_info)
+        result = "error"
+
+    callback(result, "export", path)
 
 @_async
-def import_config(ei_task_info: ei_task):
-    # The import process in the background.
+def import_webapps(callback, path):
+    # The background import process
     try:
-        with tarfile.open(ei_task_info.path, "r:gz") as tar:
+        result = "ok"
+        with tarfile.open(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:
                 tar.extract(file, base_dir)
                 if file.startswith("applications/"):
-                    # Rewrite the "Exec" section. This is necessary if the username differs.
+                    # Rewrite the "Exec" section. It will apply the new paths and will search for browsers
                     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)
-                counter += 1
-        GLib.idle_add(ei_task_info.update_callback, ei_task_info, 1)
-        ei_task_info.result = "ok"
+                    update_imported_desktop(path)
     except Exception as e:
         print(e)
-        ei_task_info.result = "error"
+        result = "error"
 
-    GLib.idle_add(ei_task_info.result_callback, ei_task_info)
+    callback(result, "import", path)
 
 
 def get_all_desktop_files():
@@ -625,45 +594,42 @@ def get_all_desktop_files():
             files.append({"full_path":full_path, "arcname":arcname})
     return files
 
-def get_all_icons():
-    # List all the files in a directory.
-    files = []
-    for root, dirs, filenames in os.walk(ICONS_DIR):
-        for filename in filenames:
-            full_path = os.path.join(root, filename)
-            arcname = ""
-            arcname += os.path.relpath(full_path, os.path.dirname(ICE_DIR))
-            files.append({"full_path":full_path, "arcname":arcname})
-    return files
-
 
 def get_codename(path):
-    codename = os.path.basename(path)
-    codename = codename.replace(".desktop", "")
-    codename = codename.replace("WebApp-", "")
-    codename = codename.replace("webapp-", "")
+    filename = os.path.basename(path)
+    codename = filename.replace(".desktop", "").replace("WebApp-", "").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()
+def update_imported_desktop(path):
+    webapp = WebAppLauncher(path, get_codename(path))
     if "/" in webapp.icon:
         # Update Icon Path
-        iconpath = ICONS_DIR + "/" + os.path.basename(webapp.icon)
-        config.set("Desktop Entry", "Icon", iconpath)
+        iconpath = os.path.join(ICONS_DIR, os.path.basename(webapp.icon))
     else:
         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, 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)
+    # Check if the browser is installed
+    browsers = WebAppManager.get_supported_browsers()
+    configured_browser = next((browser for browser in browsers if browser.name == webapp.web_browser), None)
+    if os.path.exists(configured_browser.test_path) == False:
+        # If the browser is not installed, search another browser.
+        # 1. Sort browsers by same browser type
+        # 2. Sort the browsers by similarity of the name of the missing browser
+        similar_browsers = browsers
+        similar_browsers.sort(key=lambda browser: (
+            browser.browser_type == configured_browser.browser_type,
+            configured_browser.name.split(" ")[0].lower() not in browser.name.lower()
+        ))
+        configured_browser = None
+        for browser in similar_browsers:
+            if os.path.exists(browser.test_path):
+                configured_browser = browser
+                break
+
+        print(webapp.web_browser, "-Browser not installed")
+
+    WebAppManager.edit_webapp(WebAppManager, path, webapp.name, configured_browser, webapp.url, iconpath, webapp.category, 
+                webapp.custom_parameters, webapp.codename, webapp.isolate_profile, webapp.navbar, webapp.privatewindow)
 
 if __name__ == "__main__":
     download_favicon(sys.argv[1])

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

@@ -22,7 +22,8 @@
 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, ICONS_DIR
+from common import BROWSER_TYPE_FIREFOX, BROWSER_TYPE_FIREFOX_FLATPAK, BROWSER_TYPE_FIREFOX_SNAP, ICONS_DIR
+from common import _async, idle, WebAppManager, download_favicon, export_webapps, import_webapps
 
 setproctitle.setproctitle("webapp-manager")
 
@@ -41,7 +42,6 @@
 # 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
@@ -130,14 +130,14 @@ def __init__(self, application):
         item = Gtk.ImageMenuItem()
         item.set_image(Gtk.Image.new_from_icon_name("document-send-symbolic", Gtk.IconSize.MENU))
         item.set_label(_("Export"))
-        item.connect("activate", lambda widget: self.open_ei_tool("export"))
+        item.connect("activate", lambda widget: self.ei_select_location("export"))
         key, mod = Gtk.accelerator_parse("<Control><Shift>E")
         item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
         menu.append(item)
         item = Gtk.ImageMenuItem()
         item.set_image(Gtk.Image.new_from_icon_name("document-open-symbolic", Gtk.IconSize.MENU))
         item.set_label(_("Import"))
-        item.connect("activate", lambda widget: self.open_ei_tool("import"))
+        item.connect("activate", lambda widget: self.ei_select_location("import"))
         key, mod = Gtk.accelerator_parse("<Control><Shift>I")
         item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
         menu.append(item)
@@ -554,102 +554,58 @@ def load_webapps(self):
         self.stack.set_visible_child_name("main_page")
         self.headerbar.set_subtitle(_("Run websites as if they were apps"))
 
-    # Export and Import feature "ei"
-    def open_ei_tool(self, action):
-        # Open the import / export window
-        builder = Gtk.Builder()
-        builder.set_translation_domain(APP)
-        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("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("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
-        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):
-        # Start the import / export process
-        buffer = ei_task_info.builder.get_object("file_path").get_buffer()
-        path = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
-        if path != "":
-            ei_task_info.path = path
-            button.set_sensitive(False)
-            if ei_task_info.task == "export":
-                export_config(ei_task_info)
-                #thread = threading.Thread(target=export_config, args=(ei_task_info,))
-            else:
-                import_config(ei_task_info)
-                #thread = threading.Thread(target=import_config, args=(ei_task_info,))
-            #thread.start()
-
-
-    def ei_select_location(self, ei_task_info: ei_task):
-        # Open the file chooser window
-        if ei_task_info.task == "export":
+    # "ei" means export and import feature
+    def ei_select_location(self, task):
+        # Open the file chooser dialog
+        if 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)
+            title = _("Export WebApps - Select file location")
+            dialog = Gtk.FileChooserDialog(title, 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 archive"), self.window, Gtk.FileChooserAction.OPEN, buttons)
-        
+            title = _("Import WebApps - Select the archive")
+            dialog = Gtk.FileChooserDialog(title, self.window, Gtk.FileChooserAction.OPEN, buttons)
+
         filter = Gtk.FileFilter()
         filter.set_name(".tar.gz")
         filter.add_pattern("*.tar.gz")
         dialog.add_filter(filter)
         response = dialog.run()
         if response == Gtk.ResponseType.OK:
             path = dialog.get_filename()
-            if ei_task_info.task == "export":
-                path += ".tar.gz"
-            ei_task_info.builder.get_object("file_path").get_buffer().set_text(path)
+            if path != "":
+                if task == "export":
+                    path += ".tar.gz"
+                    export_webapps(self.show_ei_result, path)
+                else:
+                    import_webapps(self.show_ei_result, path)
         dialog.destroy()
 
-    def update_ei_progress(self, ei_task_info:ei_task, progress):
-        # Update the progress bar
-        try:
-            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):
+    def show_ei_result(self, result, task, path):
         # Displays a success or failure message when the process is complete.
-        ei_task_info.webAppLauncherSelf.load_webapps()
-        if ei_task_info.result == "ok":
-            message = _(ei_task_info.task.capitalize() + " completed!")
-        else:
-            message = _(ei_task_info.task.capitalize() + " failed!")
-        
-        if ei_task_info.result == "ok" and ei_task_info.task == "export":
+        self.load_webapps()
+        if result == "ok" and task == "export":
             # This dialog box gives users the option to open the containing directory.
-            dialog = Gtk.Dialog(message, ei_task_info.webAppLauncherSelf.window, None, (_("Open Containing Folder"), 10, Gtk.STOCK_OK, Gtk.ButtonsType.OK))
-            dialog.get_content_area().add(Gtk.Label(label=_("Configuration has been exported successfully. This is the file location:")+"\n"+ei_task_info.path))
+            title = _("Export completed!")
+            button_text = _("Open Containing Folder")
+            dialog = Gtk.Dialog(title, self.window, None, (button_text, 10, Gtk.STOCK_OK, Gtk.ButtonsType.OK))
+            dialog.get_content_area().add(Gtk.Label(label=_("WebApps have been exported successfully.")))
             dialog.show_all()
             result = dialog.run()
             if result == 10:
                 # Open Containing Folder
-                os.system("xdg-open " + os.path.dirname(ei_task_info.path))
+                os.system("xdg-open " + os.path.dirname(path))
         else:
+            if result == "ok" and task == "import":
+                message = _("Import completed!")
+            elif result != "ok" and task == "import":
+                message = _("Import failed!")
+            elif result != "ok" and task == "export":
+                message = _("Export failed!")
+
             dialog = Gtk.MessageDialog(text=message, message_type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK)
             dialog.run()
-
         dialog.destroy()
-        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)