e2xauthoring 0.2.0.dev1__py3-none-any.whl → 0.2.0.dev2__py3-none-any.whl

e2xauthoring/__version__.py

@@ -1 +1 @@
-__version__ = "0.2.0-dev1"
+__version__ = "0.2.0-dev2"

e2xauthoring/app/handlers/apihandlers.py

@@ -1,5 +1,4 @@
 import json
-import os
 
 from e2xcore.handlers import E2xApiHandler
 from e2xcore.utils import urljoin
@@ -7,58 +6,16 @@ from jupyter_client.kernelspec import KernelSpecManager
 from nbgrader.server_extensions.formgrader.base import check_xsrf
 from tornado import web
 
-from ...converters import GenerateExercise
-from ...models import (
-    AssignmentModel,
-    ExerciseModel,
-    PresetModel,
-    TaskModel,
-    TaskPoolModel,
-    TemplateModel,
+from ...managers import (
+    AssignmentManager,
+    PresetManager,
+    TaskManager,
+    TaskPoolManager,
+    TemplateManager,
+    WorksheetManager,
 )
-from ...utils import NotebookVariableExtractor
 from ...utils.gitutils import get_author, set_author
-from .base import BaseApiListHandler, BaseApiManageHandler
-
-
-class PresetHandler(E2xApiHandler):
-    def initialize(self):
-        self.__model = PresetModel(self.coursedir)
-
-    def _list_template(self):
-        self.write(json.dumps(self.__model.list_template_presets()))
-
-    def _get_template(self):
-        name = self.get_argument("name")
-        self.write(json.dumps(self.__model.get_template_preset(name)))
-
-    def _list_question(self):
-        self.write(json.dumps(self.__model.list_question_presets()))
-
-    def _get_question(self):
-        name = self.get_argument("name")
-        self.write(json.dumps(self.__model.get_question_preset(name)))
-
-    @web.authenticated
-    @check_xsrf
-    def get(self):
-        action = self.get_argument("action")
-        preset_type = self.get_argument("type")
-        handler = getattr(self, "_{}_{}".format(action, preset_type))
-        handler()
-
-
-class TemplateVariableHandler(E2xApiHandler):
-    @web.authenticated
-    @check_xsrf
-    def get(self):
-        template = self.get_argument("template")
-        variables = NotebookVariableExtractor().extract(
-            os.path.join(
-                self.url_prefix, "templates", template, "{}.ipynb".format(template)
-            )
-        )
-        self.write(json.dumps(variables))
+from .base import ApiManageHandler
 
 
 class KernelSpecHandler(E2xApiHandler):
@@ -68,152 +25,6 @@ class KernelSpecHandler(E2xApiHandler):
         self.write(json.dumps(KernelSpecManager().get_all_specs()))
 
 
-class ManagePoolsHandler(E2xApiHandler):
-    def initialize(self) -> None:
-        self.__poolmodel = TaskPoolModel(self.coursedir)
-
-    @web.authenticated
-    @check_xsrf
-    def get(self, action):
-        if action == "list":
-            self.write(json.dumps(self.__poolmodel.list()))
-        elif action == "get":
-            self.write(json.dumps(self.__poolmodel.get(pool=self.get_argument("pool"))))
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-    @web.authenticated
-    @check_xsrf
-    def post(self, action):
-        data = self.get_json_body()
-        name = data.get("name")
-        if action == "new":
-            create_repository = data.get("create_repository", False)
-            self.write(
-                json.dumps(
-                    self.__poolmodel.new(name=name, create_repository=create_repository)
-                )
-            )
-        elif action == "remove":
-            self.write(json.dumps(self.__poolmodel.remove(name=name)))
-        elif action == "init_repo":
-            self.write(json.dumps(self.__poolmodel.turn_into_repository(name)))
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-
-class ManageTasksHandler(E2xApiHandler):
-    def initialize(self) -> None:
-        self.__model = TaskModel(self.coursedir)
-
-    @web.authenticated
-    @check_xsrf
-    def get(self, action):
-        if action == "list":
-            self.write(json.dumps(self.__model.list(pool=self.get_argument("pool"))))
-        elif action == "list_all":
-            tasks = []
-            pool_model = TaskPoolModel(self.coursedir)
-            for pool in pool_model.list():
-                tasks.extend(self.__model.list(pool["name"]))
-            self.write(json.dumps(tasks))
-        elif action == "get":
-            self.write(
-                json.dumps(
-                    self.__model.get(
-                        pool=self.get_argument("pool"), name=self.get_argument("name")
-                    )
-                )
-            )
-        elif action == "diff":
-            self.write(
-                json.dumps(
-                    self.__model.git_diff(
-                        pool=self.get_argument("pool"),
-                        task=self.get_argument("task"),
-                        file=self.get_argument("file"),
-                    )
-                )
-            )
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-    @web.authenticated
-    @check_xsrf
-    def post(self, action):
-        data = self.get_json_body()
-        name = data.get("name")
-        pool = data.get("pool")
-        if action == "new":
-            self.write(json.dumps(self.__model.new(pool=pool, name=name)))
-        elif action == "remove":
-            self.write(json.dumps(self.__model.remove(pool=pool, name=name)))
-        elif action == "commit":
-            message = data.get("message", None)
-            self.write(
-                json.dumps(self.__model.commit(pool=pool, task=name, message=message))
-            )
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-
-class ManageTemplatesHandler(E2xApiHandler):
-    def initialize(self) -> None:
-        self.__model = TemplateModel(self.coursedir)
-
-    @web.authenticated
-    @check_xsrf
-    def get(self, action):
-        if action == "list":
-            self.write(json.dumps(self.__model.list()))
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-    @web.authenticated
-    @check_xsrf
-    def post(self, action):
-        data = self.get_json_body()
-        name = data.get("name")
-        if action == "new":
-            self.write(json.dumps(self.__model.new(name=name)))
-        elif action == "remove":
-            self.write(json.dumps(self.__model.remove(name=name)))
-        else:
-            self.write(
-                json.dumps(
-                    dict(status="error", message=f"{action} is not a valid action")
-                )
-            )
-
-
-class GenerateExerciseHandler(E2xApiHandler):
-    @web.authenticated
-    @check_xsrf
-    def post(self):
-        GenerateExercise(coursedir=self.coursedir).convert(self.get_json_body())
-        self.write(dict(success=True))
-
-
 class GitAuthorHandler(E2xApiHandler):
     @web.authenticated
     @check_xsrf
@@ -232,41 +43,87 @@ class GitAuthorHandler(E2xApiHandler):
 api_url = urljoin("e2x", "authoring", "api")
 name_regex = r"(?P<name>[^/]+)"
 assignment_regex = r"(?P<assignment>[^/]+)"
-pool_action_regex = r"(?P<action>new|list|remove|get|init_repo)"
-task_action_regex = r"(?P<action>new|list|list_all|remove|commit|get|diff)"
-template_action_regex = r"(?P<action>new|list|remove)"
 default_handlers = [
-    (urljoin(api_url, "presets"), PresetHandler),
     (
         urljoin(api_url, "assignments", "?"),
-        BaseApiListHandler,
-        dict(model_cls=AssignmentModel),
+        ApiManageHandler,
+        dict(
+            manager_cls=AssignmentManager,
+            actions=dict(
+                get=dict(actions=["list"]),
+            ),
+        ),
     ),
     (
-        urljoin(api_url, "template", name_regex, "?"),
-        BaseApiManageHandler,
-        dict(model_cls=TemplateModel),
+        urljoin(api_url, "worksheets", "?"),
+        ApiManageHandler,
+        dict(
+            manager_cls=WorksheetManager,
+            actions=dict(
+                get=dict(actions=["get", "list"]),
+                delete=dict(default="remove", actions=["remove"]),
+                post=dict(default="create", actions=["create"]),
+            ),
+        ),
+    ),
+    (
+        urljoin(api_url, "tasks", "?"),
+        ApiManageHandler,
+        dict(
+            manager_cls=TaskManager,
+            actions=dict(
+                delete=dict(default="remove", actions=["remove"]),
+                get=dict(
+                    default="get", actions=["get", "list", "list_all", "git_diff"]
+                ),
+                post=dict(default="create", actions=["create"]),
+                put=dict(actions=["copy", "rename", "commit"]),
+            ),
+        ),
     ),
     (
         urljoin(api_url, "templates", "?"),
-        BaseApiListHandler,
-        dict(model_cls=TemplateModel),
+        ApiManageHandler,
+        dict(
+            manager_cls=TemplateManager,
+            actions=dict(
+                delete=dict(default="remove", actions=["remove"]),
+                get=dict(default="get", actions=["get", "list", "list_variables"]),
+                post=dict(default="create", actions=["create"]),
+                put=dict(actions=["copy", "rename"]),
+            ),
+        ),
     ),
     (
-        urljoin(api_url, "worksheets", assignment_regex, name_regex, "?"),
-        BaseApiManageHandler,
-        dict(model_cls=ExerciseModel),
+        urljoin(api_url, "pools", "?"),
+        ApiManageHandler,
+        dict(
+            manager_cls=TaskPoolManager,
+            actions=dict(
+                delete=dict(default="remove", actions=["remove"]),
+                get=dict(default="get", actions=["get", "list"]),
+                post=dict(default="create", actions=["create"]),
+                put=dict(actions=["copy", "rename", "turn_into_repository"]),
+            ),
+        ),
     ),
     (
-        urljoin(api_url, "worksheets", assignment_regex, "?"),
-        BaseApiListHandler,
-        dict(model_cls=ExerciseModel),
+        urljoin(api_url, "presets", "?"),
+        ApiManageHandler,
+        dict(
+            manager_cls=PresetManager,
+            actions=dict(
+                get=dict(
+                    actions=[
+                        "list_question_presets",
+                        "list_template_presets",
+                        "get_question_preset",
+                        "get_template_preset",
+                    ]
+                )
+            ),
+        ),
     ),
-    (urljoin(api_url, "pools", pool_action_regex, "?"), ManagePoolsHandler),
-    (urljoin(api_url, "tasks", task_action_regex, "?"), ManageTasksHandler),
-    (urljoin(api_url, "templates", template_action_regex, "?"), ManageTemplatesHandler),
-    (urljoin(api_url, "templates", "variables"), TemplateVariableHandler),
     (urljoin(api_url, "kernelspec"), KernelSpecHandler),
-    (urljoin(api_url, "generate_worksheet"), GenerateExerciseHandler),
     (urljoin(api_url, "git", "author"), GitAuthorHandler),
 ]

e2xauthoring/app/handlers/base.py

@@ -1,41 +1,102 @@
-import json
+import inspect
+from typing import List
 
 from e2xcore.handlers import E2xApiHandler
 from nbgrader.server_extensions.formgrader.base import check_xsrf
 from tornado import web
 
+from e2xauthoring.managers.dataclasses import ErrorMessage, SuccessMessage
 
-class BaseApiManageHandler(E2xApiHandler):
-    def initialize(self, model_cls):
-        self.__model = model_cls(self.coursedir)
 
-    @web.authenticated
-    @check_xsrf
-    def post(self, **kwargs):
-        self.write(self.__model.new(**kwargs))
+def status_msg(method):
+    """Decorates a method of a BaseApiManager
+    Wraps the response in a status message (ErrorMessage or SuccessMessage)
+    and catches exceptions.
+
+    Args:
+        method: The method to decorate
+    """
+
+    def wrapper(*args, **kwargs):
+        try:
+            res = method(*args, **kwargs)
+            return SuccessMessage(data=res)
+        except Exception as e:
+            return ErrorMessage(error=getattr(e, "message", str(e)))
+
+    return wrapper
+
+
+class ApiManageHandler(E2xApiHandler):
+    def initialize(self, manager_cls, actions) -> None:
+        self.__manager = manager_cls(self.coursedir)
+        self.__allowed_actions = {
+            request_type: dict(default=None, actions=[])
+            for request_type in ["delete", "get", "post", "put"]
+        }
+        self.set_allowed_actions(actions)
+
+    def set_allowed_actions(self, allowed_actions):
+        for request_type, action_dict in self.__allowed_actions.items():
+            if request_type in allowed_actions:
+                actions = allowed_actions[request_type].get("actions", [])
+                for action in actions:
+                    assert hasattr(
+                        self.__manager, action
+                    ), f"The manager class does not provide an action called {action}."
+                action_dict["default"] = allowed_actions[request_type].get(
+                    "default", None
+                )
+                action_dict["actions"].extend(actions)
+
+    def extract_arguments(self, method: str):
+        params = dict()
+        json_body = self.get_json_body() or dict()
+        for arg in inspect.signature(method).parameters.keys():
+            argument = self.get_argument(name=arg, default=None)
+            if argument is None:
+                argument = json_body.get(arg, None)
+            params[arg] = argument
+        return params
+
+    def perform_action(self, action: str, allowed_actions: List[str]):
+        assert (
+            action is not None and action in allowed_actions
+        ), f"Action {action} is not a valid action."
+        method = getattr(self.__manager, action)
+        arguments = self.extract_arguments(method)
+        return method(**arguments)
+
+    @status_msg
+    def handle_request(self, request_type: str):
+        action = self.get_argument(
+            "action", default=None  # self.__allowed_actions[request_type]["default"]
+        )
+        if action is None:
+            action = (self.get_json_body() or dict()).get(
+                "action", self.__allowed_actions[request_type]["default"]
+            )
+
+        return self.perform_action(
+            action, self.__allowed_actions[request_type]["actions"]
+        )
 
     @web.authenticated
     @check_xsrf
-    def delete(self, **kwargs):
-        self.__model.remove(**kwargs)
-        self.write({"status": True})
+    def get(self):
+        self.finish(self.handle_request("get").json())
 
     @web.authenticated
     @check_xsrf
-    def get(self, **kwargs):
-        self.write(json.dumps(self.__model.get(**kwargs)))
+    def delete(self):
+        self.finish(self.handle_request("delete").json())
 
     @web.authenticated
     @check_xsrf
-    def put(self, **kwargs):
-        self.write(self.__model.new(**kwargs))
-
-
-class BaseApiListHandler(E2xApiHandler):
-    def initialize(self, model_cls):
-        self.__model = model_cls(self.coursedir)
+    def put(self):
+        self.finish(self.handle_request("put").json())
 
     @web.authenticated
     @check_xsrf
-    def get(self, **kwargs):
-        self.write(json.dumps(self.__model.list(**kwargs)))
+    def post(self):
+        self.finish(self.handle_request("post").json())

e2xauthoring/app/templates/authoring/asset-manifest.json

@@ -1,10 +1,10 @@
 {
   "files": {
-    "main.js": "/e2x/authoring/static/js/main.fe9bcd55.js",
+    "main.js": "/e2x/authoring/static/js/main.1e6f65c1.js",
     "index.html": "/e2x/authoring/index.html",
-    "main.fe9bcd55.js.map": "/e2x/authoring/static/js/main.fe9bcd55.js.map"
+    "main.1e6f65c1.js.map": "/e2x/authoring/static/js/main.1e6f65c1.js.map"
   },
   "entrypoints": [
-    "static/js/main.fe9bcd55.js"
+    "static/js/main.1e6f65c1.js"
   ]
 }

e2xauthoring/app/templates/authoring/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>e²xgrader - Authoring</title><script type="text/javascript">window.base_url="{{ base_url }}",window.url_prefix="{{ url_prefix }}",window.webpackstuff="/e2x/authoring/static/js/main.fe9bcd55.js"</script><script defer="defer" src="{{base_url}}/e2x/authoring/static/js/main.fe9bcd55.js"></script>{%- block head -%} {%- endblock -%}</head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>e²xgrader - Authoring</title><script type="text/javascript">window.base_url="{{ base_url }}",window.url_prefix="{{ url_prefix }}",window.webpackstuff="/e2x/authoring/static/js/main.1e6f65c1.js"</script><script defer="defer" src="{{base_url}}/e2x/authoring/static/js/main.1e6f65c1.js"></script>{%- block head -%} {%- endblock -%}</head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>