display overhaul, compatibility with legacy plugins, fixes

1 files changed, 57 insertions, 36 deletions

diff --git a/backend/loader.py b/backend/loader.py
index e68842e2..60b1a901 100644
--- a/backend/loader.py
+++ b/backend/loader.py
@@ -2,16 +2,15 @@ from asyncio import Queue
 from logging import getLogger
 from os import listdir, path
 from pathlib import Path
-from time import time
 from traceback import print_exc
 
 from aiohttp import web
-from aiohttp_jinja2 import template
 from genericpath import exists
+from json.decoder import JSONDecodeError
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers.polling import PollingObserver as Observer
 
-from injector import inject_to_tab
+from injector import inject_to_tab, get_tab
 from plugin import PluginWrapper
 
 
@@ -63,7 +62,6 @@ class Loader:
         self.plugin_path = plugin_path
         self.logger.info(f"plugin_path: {self.plugin_path}")
         self.plugins = {}
-        self.import_plugins()
 
         if live_reload:
             self.reload_queue = Queue()
@@ -73,17 +71,21 @@ class Loader:
             self.loop.create_task(self.handle_reloads())
 
         server_instance.add_routes([
-            web.get("/plugins", self.handle_plugins),
+            web.get("/plugins", self.get_plugins),
             web.get("/plugins/{plugin_name}/frontend_bundle", self.handle_frontend_bundle),
             web.post("/plugins/{plugin_name}/methods/{method_name}", self.handle_plugin_method_call),
-            web.post("/methods/{method_name}", self.handle_server_method_call)
+            
+            # The following is legacy plugin code.
+            web.get("/plugins/load_main/{name}", self.load_plugin_main_view),
+            web.get("/plugins/plugin_resource/{name}/{path:.+}", self.handle_sub_route),
+            web.get("/steam_resource/{path:.+}", self.get_steam_resource)
         ])
 
-    def handle_plugins(self, request):
-      plugins = list(map(lambda kv: dict([("name", kv[0])]), self.plugins.items()))
-      return web.json_response(plugins)
+    async def get_plugins(self, request):
+        plugins = list(self.plugins.values())
+        return web.json_response([str(i) if not i.legacy else "$LEGACY_"+str(i) for i in plugins])
 
-    def handle_frontend_bundle(self, request):
+    async def handle_frontend_bundle(self, request):
         plugin = self.plugins[request.match_info["plugin_name"]]
 
         with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.frontend_bundle), 'r') as bundle:
@@ -103,14 +105,13 @@ class Loader:
                 self.logger.info(f"Plugin {plugin.name} is passive")
             self.plugins[plugin.name] = plugin.start()
             self.logger.info(f"Loaded {plugin.name}")
-            if refresh:
-                self.loop.create_task(self.reload_frontend_plugin(plugin.name))
+            #self.loop.create_task(self.dispatch_plugin(plugin.name))
         except Exception as e:
             self.logger.error(f"Could not load {file}. {e}")
             print_exc()
 
-    async def reload_frontend_plugin(self, name):
-        await inject_to_tab("SP", f"window.DeckyPluginLoader?.loadPlugin('{name}')")
+    async def dispatch_plugin(self, name):
+        await inject_to_tab("SP", f"window.importDeckyPlugin('{name}')")
 
     def import_plugins(self):
         self.logger.info(f"import plugins from {self.plugin_path}")
@@ -125,38 +126,58 @@ class Loader:
             args = await self.reload_queue.get()
             self.import_plugin(*args)
 
-    async def handle_server_method_call(self, request):
-        method_name = request.match_info["method_name"]
-        method_info = await request.json()
-        args = method_info["args"]
-
-        res = {}
-        try:
-            r = await self.utilities.util_methods[method_name](**args)
-            res["result"] = r
-            res["success"] = True
-        except Exception as e:
-            res["result"] = str(e)
-            res["success"] = False
-
-        return web.json_response(res)
-
     async def handle_plugin_method_call(self, request):
         res = {}
         plugin = self.plugins[request.match_info["plugin_name"]]
         method_name = request.match_info["method_name"]
-
-        method_info = await request.json()
-        args = method_info["args"]
-
+        try:
+            method_info = await request.json()
+            args = method_info["args"]
+        except JSONDecodeError:
+            args = {}
         try:
           if method_name.startswith("_"):
               raise RuntimeError("Tried to call private method")
-
           res["result"] = await plugin.execute_method(method_name, args)
           res["success"] = True
         except Exception as e:
             res["result"] = str(e)
             res["success"] = False
-
         return web.json_response(res)
+
+    """ 
+    The following methods are used to load legacy plugins, which are considered deprecated.
+    I made the choice to re-add them so that the first iteration/version of the react loader
+    can work as a drop-in replacement for the stable branch of the PluginLoader, so that we 
+    can introduce it more smoothly and give people the chance to sample the new features even
+    without plugin support. They will be removed once legacy plugins are no longer relevant. 
+    """
+    async def load_plugin_main_view(self, request):
+        plugin = self.plugins[request.match_info["name"]]
+        with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.main_view_html), 'r') as template:
+            template_data = template.read()
+            ret = f"""
+            <script src="/static/legacy-library.js"></script>
+            <script>const plugin_name = '{plugin.name}' </script>
+            <base href="http://127.0.0.1:1337/plugins/plugin_resource/{plugin.name}/">
+            {template_data}
+            """
+            return web.Response(text=ret, content_type="text/html")
+
+    async def handle_sub_route(self, request):
+        plugin = self.plugins[request.match_info["name"]]
+        route_path = request.match_info["path"]
+        self.logger.info(path)
+        ret = ""
+        file_path = path.join(self.plugin_path, plugin.plugin_directory, route_path)
+        with open(file_path, 'r') as resource_data:
+            ret = resource_data.read()
+
+        return web.Response(text=ret)
+
+    async def get_steam_resource(self, request):
+        tab = await get_tab("QuickAccess")
+        try:
+            return web.Response(text=await tab.get_steam_resource(f"https://steamloopback.host/{request.match_info['path']}"), content_type="text/html")
+        except Exception as e:
+            return web.Response(text=str(e), status=400)
\ No newline at end of file