Enable server to alternatively output response ctx as JSON, for debugging and testing...

[plomtask] / plomtask / http.py

diff --git a/plomtask/http.py b/plomtask/http.py
index 3d507be9b344ff8be7ca26952bfa422872ec6b78..d602f07b9baf3c18df19fa88435928d2a33845d6 100644 (file)
--- a/plomtask/http.py
+++ b/plomtask/http.py
@@ -6,6 +6,7 @@ from base64 import b64encode, b64decode
 from http.server import BaseHTTPRequestHandler
 from http.server import HTTPServer
 from urllib.parse import urlparse, parse_qs
 from http.server import BaseHTTPRequestHandler
 from http.server import HTTPServer
 from urllib.parse import urlparse, parse_qs

+from json import dumps as json_dumps

 from os.path import split as path_split
 from jinja2 import Environment as JinjaEnv, FileSystemLoader as JinjaFSLoader
 from plomtask.dating import date_in_n_days
 from os.path import split as path_split
 from jinja2 import Environment as JinjaEnv, FileSystemLoader as JinjaFSLoader
 from plomtask.dating import date_in_n_days


@@ -16,6 +17,7 @@ from plomtask.db import DatabaseConnection, DatabaseFile
 from plomtask.processes import Process, ProcessStep, ProcessStepsNode
 from plomtask.conditions import Condition
 from plomtask.todos import Todo
 from plomtask.processes import Process, ProcessStep, ProcessStepsNode
 from plomtask.conditions import Condition
 from plomtask.todos import Todo

+from plomtask.db import BaseModel

 
 TEMPLATES_DIR = 'templates'
 
 
 TEMPLATES_DIR = 'templates'
 


@@ -27,7 +29,37 @@ class TaskServer(HTTPServer):
                  *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.db = db_file
                  *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.db = db_file

-        self.jinja = JinjaEnv(loader=JinjaFSLoader(TEMPLATES_DIR))
+        self.headers: list[tuple[str, str]] = []
+        self._render_mode = 'html'
+        self._jinja = JinjaEnv(loader=JinjaFSLoader(TEMPLATES_DIR))
+
+    def set_json_mode(self) -> None:
+        """Make server send JSON instead of HTML responses."""
+        self._render_mode = 'json'
+        self.headers += [('Content-Type', 'application/json')]
+
+    @staticmethod
+    def ctx_to_json(ctx: dict[str, object]) -> str:
+        """Render ctx into JSON string."""
+        def walk_ctx(node: object) -> Any:
+            if isinstance(node, BaseModel):
+                return node.as_dict
+            if isinstance(node, (list, tuple)):
+                return [walk_ctx(x) for x in node]
+            if isinstance(node, HandledException):
+                return str(node)
+            return node
+        for k, v in ctx.items():
+            ctx[k] = walk_ctx(v)
+        return json_dumps(ctx)
+
+    def render(self, ctx: dict[str, object], tmpl_name: str = '') -> str:
+        """Render ctx according to self._render_mode.."""
+        tmpl_name = f'{tmpl_name}.{self._render_mode}'
+        if 'html' == self._render_mode:
+            template = self._jinja.get_template(tmpl_name)
+            return template.render(ctx)
+        return self.__class__.ctx_to_json(ctx)

 
 
 class InputsParser:
 
 
 class InputsParser:


@@ -106,11 +138,18 @@ class TaskHandler(BaseHTTPRequestHandler):
     _form_data: InputsParser
     _params: InputsParser
 
     _form_data: InputsParser
     _params: InputsParser
 

-    def _send_html(self, html: str, code: int = 200) -> None:
+    def _send_page(self,
+                   ctx: dict[str, Any],
+                   tmpl_name: str,
+                   code: int = 200
+                   ) -> None:

         """Send HTML as proper HTTP response."""
         """Send HTML as proper HTTP response."""

+        body = self.server.render(ctx, tmpl_name)

         self.send_response(code)
         self.send_response(code)

+        for header_tuple in self.server.headers:
+            self.send_header(*header_tuple)

         self.end_headers()
         self.end_headers()

-        self.wfile.write(bytes(html, 'utf-8'))
+        self.wfile.write(bytes(body, 'utf-8'))

 
     @staticmethod
     def _request_wrapper(http_method: str, not_found_msg: str
 
     @staticmethod
     def _request_wrapper(http_method: str, not_found_msg: str


@@ -139,9 +178,11 @@ class TaskHandler(BaseHTTPRequestHandler):
                         msg = f'{not_found_msg}: {self._site}'
                         raise NotFoundException(msg)
                 except HandledException as error:
                         msg = f'{not_found_msg}: {self._site}'
                         raise NotFoundException(msg)
                 except HandledException as error:

-                    html = self.server.jinja.\
-                            get_template('msg.html').render(msg=error)
-                    self._send_html(html, error.http_code)
+                    for cls in (Day, Todo, Condition, Process, ProcessStep):
+                        assert hasattr(cls, 'empty_cache')
+                        cls.empty_cache()
+                    ctx = {'msg': error}
+                    self._send_page(ctx, 'msg', error.http_code)

                 finally:
                     self.conn.close()
             return wrapper
                 finally:
                     self.conn.close()
             return wrapper


@@ -151,13 +192,11 @@ class TaskHandler(BaseHTTPRequestHandler):
     def do_GET(self, handler: Callable[[], str | dict[str, object]]
                ) -> str | None:
         """Render page with result of handler, or redirect if result is str."""
     def do_GET(self, handler: Callable[[], str | dict[str, object]]
                ) -> str | None:
         """Render page with result of handler, or redirect if result is str."""

-        template = f'{self._site}.html'
-        ctx_or_redir = handler()
-        if str == type(ctx_or_redir):
-            return ctx_or_redir
-        assert isinstance(ctx_or_redir, dict)
-        html = self.server.jinja.get_template(template).render(**ctx_or_redir)
-        self._send_html(html)
+        tmpl_name = f'{self._site}'
+        ctx_or_redir_target = handler()
+        if isinstance(ctx_or_redir_target, str):
+            return ctx_or_redir_target
+        self._send_page(ctx_or_redir_target, tmpl_name)

         return None
 
     @_request_wrapper('POST', 'Unknown POST target')
         return None
 
     @_request_wrapper('POST', 'Unknown POST target')


@@ -191,8 +230,6 @@ class TaskHandler(BaseHTTPRequestHandler):
         ret = Day.by_date_range_with_limits(self.conn, (start, end), 'id')
         days, start, end = ret
         days = Day.with_filled_gaps(days, start, end)
         ret = Day.by_date_range_with_limits(self.conn, (start, end), 'id')
         days, start, end = ret
         days = Day.with_filled_gaps(days, start, end)

-        for day in days:
-            day.collect_calendarized_todos(self.conn)

         today = date_in_n_days(0)
         return {'start': start, 'end': end, 'days': days, 'today': today}
 
         today = date_in_n_days(0)
         return {'start': start, 'end': end, 'days': days, 'today': today}
 


@@ -207,15 +244,12 @@ class TaskHandler(BaseHTTPRequestHandler):
     def do_GET_day(self) -> dict[str, object]:
         """Show single Day of ?date=."""
         date = self._params.get_str('date', date_in_n_days(0))
     def do_GET_day(self) -> dict[str, object]:
         """Show single Day of ?date=."""
         date = self._params.get_str('date', date_in_n_days(0))

+        day = Day.by_id(self.conn, date, create=True)

         make_type = self._params.get_str('make_type')
         make_type = self._params.get_str('make_type')

-        todays_todos = Todo.by_date(self.conn, date)
-        total_effort = 0.0
-        for todo in todays_todos:
-            total_effort += todo.performed_effort

         conditions_present = []
         enablers_for = {}
         disablers_for = {}
         conditions_present = []
         enablers_for = {}
         disablers_for = {}

-        for todo in todays_todos:
+        for todo in day.todos:

             for condition in todo.conditions + todo.blockers:
                 if condition not in conditions_present:
                     conditions_present += [condition]
             for condition in todo.conditions + todo.blockers:
                 if condition not in conditions_present:
                     conditions_present += [condition]


@@ -227,9 +261,8 @@ class TaskHandler(BaseHTTPRequestHandler):
                                                     if condition in p.disables]
         seen_todos: set[int] = set()
         top_nodes = [t.get_step_tree(seen_todos)
                                                     if condition in p.disables]
         seen_todos: set[int] = set()
         top_nodes = [t.get_step_tree(seen_todos)

-                     for t in todays_todos if not t.parents]
-        return {'day': Day.by_id(self.conn, date, create=True),
-                'total_effort': total_effort,
+                     for t in day.todos if not t.parents]
+        return {'day': day,

                 'top_nodes': top_nodes,
                 'make_type': make_type,
                 'enablers_for': enablers_for,
                 'top_nodes': top_nodes,
                 'make_type': make_type,
                 'enablers_for': enablers_for,


@@ -487,10 +520,6 @@ class TaskHandler(BaseHTTPRequestHandler):
             if len(efforts) > 0:
                 todo.effort = float(efforts[i]) if efforts[i] else None
             todo.save(self.conn)
             if len(efforts) > 0:
                 todo.effort = float(efforts[i]) if efforts[i] else None
             todo.save(self.conn)

-            for condition in todo.enables:
-                condition.save(self.conn)
-            for condition in todo.disables:
-                condition.save(self.conn)

         return f'/day?date={date}&make_type={make_type}'
 
     def do_POST_todo(self) -> str:
         return f'/day?date={date}&make_type={make_type}'
 
     def do_POST_todo(self) -> str:


@@ -546,10 +575,6 @@ class TaskHandler(BaseHTTPRequestHandler):
         todo.calendarize = len(self._form_data.get_all_str('calendarize')) > 0
         todo.comment = self._form_data.get_str('comment', ignore_strict=True)
         todo.save(self.conn)
         todo.calendarize = len(self._form_data.get_all_str('calendarize')) > 0
         todo.comment = self._form_data.get_str('comment', ignore_strict=True)
         todo.save(self.conn)

-        for condition in todo.enables:
-            condition.save(self.conn)
-        for condition in todo.disables:
-            condition.save(self.conn)

         return f'/todo?id={todo.id_}'
 
     def do_POST_process_descriptions(self) -> str:
         return f'/todo?id={todo.id_}'
 
     def do_POST_process_descriptions(self) -> str:


@@ -611,12 +636,10 @@ class TaskHandler(BaseHTTPRequestHandler):
                                       None)]
             except ValueError:
                 new_step_title = step_identifier
                                       None)]
             except ValueError:
                 new_step_title = step_identifier

-        process.uncache()

         process.set_steps(self.conn, steps)
         process.set_step_suppressions(self.conn,
                                       self._form_data.
                                       get_all_int('suppresses'))
         process.set_steps(self.conn, steps)
         process.set_step_suppressions(self.conn,
                                       self._form_data.
                                       get_all_int('suppresses'))

-        process.save(self.conn)

         owners_to_set = []
         new_owner_title = None
         for owner_identifier in self._form_data.get_all_str('step_of'):
         owners_to_set = []
         new_owner_title = None
         for owner_identifier in self._form_data.get_all_str('step_of'):


@@ -632,6 +655,7 @@ class TaskHandler(BaseHTTPRequestHandler):
         elif new_owner_title:
             title_b64_encoded = b64encode(new_owner_title.encode()).decode()
             params = f'has_step={process.id_}&title_b64={title_b64_encoded}'
         elif new_owner_title:
             title_b64_encoded = b64encode(new_owner_title.encode()).decode()
             params = f'has_step={process.id_}&title_b64={title_b64_encoded}'

+        process.save(self.conn)

         return f'/process?{params}'
 
     def do_POST_condition_descriptions(self) -> str:
         return f'/process?{params}'
 
     def do_POST_condition_descriptions(self) -> str: