Fix disablers_for/enablers_for in GET_day breaking as_dict.

[plomtask] / plomtask / http.py

diff --git a/plomtask/http.py b/plomtask/http.py
index d602f07b9baf3c18df19fa88435928d2a33845d6..e1f5434bb2c1fb321a03c7343e022a24652e8978 100644 (file)
--- a/plomtask/http.py
+++ b/plomtask/http.py
@@ -17,7 +17,6 @@ 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'
 


@@ -42,15 +41,25 @@ class TaskServer(HTTPServer):
     def ctx_to_json(ctx: dict[str, object]) -> str:
         """Render ctx into JSON string."""
         def walk_ctx(node: object) -> Any:
     def ctx_to_json(ctx: dict[str, object]) -> str:
         """Render ctx into JSON string."""
         def walk_ctx(node: object) -> Any:

-            if isinstance(node, BaseModel):
+            if hasattr(node, 'as_dict_into_reference'):
+                if hasattr(node, 'id_') and node.id_ is not None:
+                    return node.as_dict_into_reference(library)
+            if hasattr(node, 'as_dict'):

                 return node.as_dict
             if isinstance(node, (list, tuple)):
                 return [walk_ctx(x) for x in node]
                 return node.as_dict
             if isinstance(node, (list, tuple)):
                 return [walk_ctx(x) for x in node]

+            if isinstance(node, dict):
+                d = {}
+                for k, v in node.items():
+                    d[k] = walk_ctx(v)
+                return d

             if isinstance(node, HandledException):
                 return str(node)
             return node
             if isinstance(node, HandledException):
                 return str(node)
             return node

+        library: dict[str, dict[str | int, object]] = {}

         for k, v in ctx.items():
             ctx[k] = walk_ctx(v)
         for k, v in ctx.items():
             ctx[k] = walk_ctx(v)

+        ctx['_library'] = library

         return json_dumps(ctx)
 
     def render(self, ctx: dict[str, object], tmpl_name: str = '') -> str:
         return json_dumps(ctx)
 
     def render(self, ctx: dict[str, object], tmpl_name: str = '') -> str:


@@ -143,7 +152,7 @@ class TaskHandler(BaseHTTPRequestHandler):
                    tmpl_name: str,
                    code: int = 200
                    ) -> None:
                    tmpl_name: str,
                    code: int = 200
                    ) -> None:

-        """Send HTML as proper HTTP response."""
+        """Send ctx as proper HTTP response."""

         body = self.server.render(ctx, tmpl_name)
         self.send_response(code)
         for header_tuple in self.server.headers:
         body = self.server.render(ctx, tmpl_name)
         self.send_response(code)
         for header_tuple in self.server.headers:


@@ -244,7 +253,7 @@ 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)
+        day = Day.by_id_or_create(self.conn, date)

         make_type = self._params.get_str('make_type')
         conditions_present = []
         enablers_for = {}
         make_type = self._params.get_str('make_type')
         conditions_present = []
         enablers_for = {}


@@ -335,7 +344,8 @@ class TaskHandler(BaseHTTPRequestHandler):
         adoptables: dict[int, list[Todo]] = {}
         any_adoptables = [Todo.by_id(self.conn, t.id_)
                           for t in Todo.by_date(self.conn, todo.date)
         adoptables: dict[int, list[Todo]] = {}
         any_adoptables = [Todo.by_id(self.conn, t.id_)
                           for t in Todo.by_date(self.conn, todo.date)

-                          if t != todo]
+                          if t.id_ is not None
+                          and t != todo]

         for id_ in collect_adoptables_keys(steps_todo_to_process):
             adoptables[id_] = [t for t in any_adoptables
                                if t.process.id_ == id_]
         for id_ in collect_adoptables_keys(steps_todo_to_process):
             adoptables[id_] = [t for t in any_adoptables
                                if t.process.id_ == id_]


@@ -374,6 +384,7 @@ class TaskHandler(BaseHTTPRequestHandler):
             todos.sort(key=lambda t: t.date, reverse=True)
         else:
             todos.sort(key=lambda t: t.date)
             todos.sort(key=lambda t: t.date, reverse=True)
         else:
             todos.sort(key=lambda t: t.date)

+            sort_by = 'title'

         return {'start': start, 'end': end, 'process_id': process_id,
                 'comment_pattern': comment_pattern, 'todos': todos,
                 'all_processes': Process.all(self.conn), 'sort_by': sort_by}
         return {'start': start, 'end': end, 'process_id': process_id,
                 'comment_pattern': comment_pattern, 'todos': todos,
                 'all_processes': Process.all(self.conn), 'sort_by': sort_by}


@@ -391,6 +402,7 @@ class TaskHandler(BaseHTTPRequestHandler):
             conditions.sort(key=lambda c: c.title.newest, reverse=True)
         else:
             conditions.sort(key=lambda c: c.title.newest)
             conditions.sort(key=lambda c: c.title.newest, reverse=True)
         else:
             conditions.sort(key=lambda c: c.title.newest)

+            sort_by = 'title'

         return {'conditions': conditions,
                 'sort_by': sort_by,
                 'pattern': pattern}
         return {'conditions': conditions,
                 'sort_by': sort_by,
                 'pattern': pattern}


@@ -398,7 +410,7 @@ class TaskHandler(BaseHTTPRequestHandler):
     def do_GET_condition(self) -> dict[str, object]:
         """Show Condition of ?id=."""
         id_ = self._params.get_int_or_none('id')
     def do_GET_condition(self) -> dict[str, object]:
         """Show Condition of ?id=."""
         id_ = self._params.get_int_or_none('id')

-        c = Condition.by_id(self.conn, id_, create=True)
+        c = Condition.by_id_or_create(self.conn, id_)

         ps = Process.all(self.conn)
         return {'condition': c, 'is_new': c.id_ is None,
                 'enabled_processes': [p for p in ps if c in p.conditions],
         ps = Process.all(self.conn)
         return {'condition': c, 'is_new': c.id_ is None,
                 'enabled_processes': [p for p in ps if c in p.conditions],


@@ -408,20 +420,20 @@ class TaskHandler(BaseHTTPRequestHandler):
 
     def do_GET_condition_titles(self) -> dict[str, object]:
         """Show title history of Condition of ?id=."""
 
     def do_GET_condition_titles(self) -> dict[str, object]:
         """Show title history of Condition of ?id=."""

-        id_ = self._params.get_int_or_none('id')
+        id_ = self._params.get_int('id')

         condition = Condition.by_id(self.conn, id_)
         return {'condition': condition}
 
     def do_GET_condition_descriptions(self) -> dict[str, object]:
         """Show description historys of Condition of ?id=."""
         condition = Condition.by_id(self.conn, id_)
         return {'condition': condition}
 
     def do_GET_condition_descriptions(self) -> dict[str, object]:
         """Show description historys of Condition of ?id=."""

-        id_ = self._params.get_int_or_none('id')
+        id_ = self._params.get_int('id')

         condition = Condition.by_id(self.conn, id_)
         return {'condition': condition}
 
     def do_GET_process(self) -> dict[str, object]:
         """Show Process of ?id=."""
         id_ = self._params.get_int_or_none('id')
         condition = Condition.by_id(self.conn, id_)
         return {'condition': condition}
 
     def do_GET_process(self) -> dict[str, object]:
         """Show Process of ?id=."""
         id_ = self._params.get_int_or_none('id')

-        process = Process.by_id(self.conn, id_, create=True)
+        process = Process.by_id_or_create(self.conn, id_)

         title_64 = self._params.get_str('title_b64')
         if title_64:
             title = b64decode(title_64.encode()).decode()
         title_64 = self._params.get_str('title_b64')
         if title_64:
             title = b64decode(title_64.encode()).decode()


@@ -441,19 +453,19 @@ class TaskHandler(BaseHTTPRequestHandler):
 
     def do_GET_process_titles(self) -> dict[str, object]:
         """Show title history of Process of ?id=."""
 
     def do_GET_process_titles(self) -> dict[str, object]:
         """Show title history of Process of ?id=."""

-        id_ = self._params.get_int_or_none('id')
+        id_ = self._params.get_int('id')

         process = Process.by_id(self.conn, id_)
         return {'process': process}
 
     def do_GET_process_descriptions(self) -> dict[str, object]:
         """Show description historys of Process of ?id=."""
         process = Process.by_id(self.conn, id_)
         return {'process': process}
 
     def do_GET_process_descriptions(self) -> dict[str, object]:
         """Show description historys of Process of ?id=."""

-        id_ = self._params.get_int_or_none('id')
+        id_ = self._params.get_int('id')

         process = Process.by_id(self.conn, id_)
         return {'process': process}
 
     def do_GET_process_efforts(self) -> dict[str, object]:
         """Show default effort history of Process of ?id=."""
         process = Process.by_id(self.conn, id_)
         return {'process': process}
 
     def do_GET_process_efforts(self) -> dict[str, object]:
         """Show default effort history of Process of ?id=."""

-        id_ = self._params.get_int_or_none('id')
+        id_ = self._params.get_int('id')

         process = Process.by_id(self.conn, id_)
         return {'process': process}
 
         process = Process.by_id(self.conn, id_)
         return {'process': process}
 


@@ -478,6 +490,7 @@ class TaskHandler(BaseHTTPRequestHandler):
             processes.sort(key=lambda p: p.title.newest, reverse=True)
         else:
             processes.sort(key=lambda p: p.title.newest)
             processes.sort(key=lambda p: p.title.newest, reverse=True)
         else:
             processes.sort(key=lambda p: p.title.newest)

+            sort_by = 'title'

         return {'processes': processes, 'sort_by': sort_by, 'pattern': pattern}
 
     # POST handlers
         return {'processes': processes, 'sort_by': sort_by, 'pattern': pattern}
 
     # POST handlers


@@ -498,7 +511,7 @@ class TaskHandler(BaseHTTPRequestHandler):
     def do_POST_day(self) -> str:
         """Update or insert Day of date and Todos mapped to it."""
         date = self._params.get_str('date')
     def do_POST_day(self) -> str:
         """Update or insert Day of date and Todos mapped to it."""
         date = self._params.get_str('date')

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

         day.comment = self._form_data.get_str('day_comment')
         day.save(self.conn)
         make_type = self._form_data.get_str('make_type')
         day.comment = self._form_data.get_str('day_comment')
         day.save(self.conn)
         make_type = self._form_data.get_str('make_type')


@@ -594,10 +607,12 @@ class TaskHandler(BaseHTTPRequestHandler):
         # pylint: disable=too-many-branches
         id_ = self._params.get_int_or_none('id')
         for _ in self._form_data.get_all_str('delete'):
         # pylint: disable=too-many-branches
         id_ = self._params.get_int_or_none('id')
         for _ in self._form_data.get_all_str('delete'):

+            if id_ is None:
+                raise NotFoundException('trying to delete non-saved Process')

             process = Process.by_id(self.conn, id_)
             process.remove(self.conn)
             return '/processes'
             process = Process.by_id(self.conn, id_)
             process.remove(self.conn)
             return '/processes'

-        process = Process.by_id(self.conn, id_, create=True)
+        process = Process.by_id_or_create(self.conn, id_)

         process.title.set(self._form_data.get_str('title'))
         process.description.set(self._form_data.get_str('description'))
         process.effort.set(self._form_data.get_float('effort'))
         process.title.set(self._form_data.get_str('title'))
         process.description.set(self._form_data.get_str('description'))
         process.effort.set(self._form_data.get_float('effort'))


@@ -670,11 +685,13 @@ class TaskHandler(BaseHTTPRequestHandler):
         """Update/insert Condition of ?id= and fields defined in postvars."""
         id_ = self._params.get_int_or_none('id')
         for _ in self._form_data.get_all_str('delete'):
         """Update/insert Condition of ?id= and fields defined in postvars."""
         id_ = self._params.get_int_or_none('id')
         for _ in self._form_data.get_all_str('delete'):

-            condition = Condition.by_id(self.conn, id_)
+            if id_ is None:
+                raise NotFoundException('trying to delete non-saved Condition')
+            condition = Condition.by_id_or_create(self.conn, id_)

             condition.remove(self.conn)
             return '/conditions'
             condition.remove(self.conn)
             return '/conditions'

-        condition = Condition.by_id(self.conn, id_, create=True)
-        condition.is_active = self._form_data.get_all_str('is_active') != []
+        condition = Condition.by_id_or_create(self.conn, id_)
+        condition.is_active = self._form_data.get_str('is_active') == 'True'

         condition.title.set(self._form_data.get_str('title'))
         condition.description.set(self._form_data.get_str('description'))
         condition.save(self.conn)
         condition.title.set(self._form_data.get_str('title'))
         condition.description.set(self._form_data.get_str('description'))
         condition.save(self.conn)