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

[plomtask] / plomtask / todos.py

diff --git a/plomtask/todos.py b/plomtask/todos.py
index 9fac63b3d962aacd867a2ab9f6e1be86074c149a..705bd725e2ff662ab4f9f2e370e61169a413ff03 100644 (file)
--- a/plomtask/todos.py
+++ b/plomtask/todos.py
@@ -1,7 +1,7 @@
 """Actionables."""
 from __future__ import annotations
 from dataclasses import dataclass
 """Actionables."""
 from __future__ import annotations
 from dataclasses import dataclass

-from typing import Any
+from typing import Any, Set

 from sqlite3 import Row
 from plomtask.db import DatabaseConnection, BaseModel
 from plomtask.processes import Process, ProcessStepsNode
 from sqlite3 import Row
 from plomtask.db import DatabaseConnection, BaseModel
 from plomtask.processes import Process, ProcessStepsNode


@@ -23,16 +23,20 @@ class TodoNode:
 class Todo(BaseModel[int], ConditionsRelations):
     """Individual actionable."""
     # pylint: disable=too-many-instance-attributes
 class Todo(BaseModel[int], ConditionsRelations):
     """Individual actionable."""
     # pylint: disable=too-many-instance-attributes

+    # pylint: disable=too-many-public-methods

     table_name = 'todos'
     to_save = ['process_id', 'is_done', 'date', 'comment', 'effort',
                'calendarize']
     table_name = 'todos'
     to_save = ['process_id', 'is_done', 'date', 'comment', 'effort',
                'calendarize']

-    to_save_relations = [('todo_conditions', 'todo', 'conditions'),
-                         ('todo_blockers', 'todo', 'blockers'),
-                         ('todo_enables', 'todo', 'enables'),
-                         ('todo_disables', 'todo', 'disables'),
-                         ('todo_children', 'parent', 'children'),
-                         ('todo_children', 'child', 'parents')]
+    to_save_relations = [('todo_conditions', 'todo', 'conditions', 0),
+                         ('todo_blockers', 'todo', 'blockers', 0),
+                         ('todo_enables', 'todo', 'enables', 0),
+                         ('todo_disables', 'todo', 'disables', 0),
+                         ('todo_children', 'parent', 'children', 0),
+                         ('todo_children', 'child', 'parents', 1)]

     to_search = ['comment']
     to_search = ['comment']

+    days_to_update: Set[str] = set()
+    children: list[Todo]
+    parents: list[Todo]

 
     # pylint: disable=too-many-arguments
     def __init__(self, id_: int | None,
 
     # pylint: disable=too-many-arguments
     def __init__(self, id_: int | None,


@@ -50,8 +54,8 @@ class Todo(BaseModel[int], ConditionsRelations):
         self.date = valid_date(date)
         self.comment = comment
         self.effort = effort
         self.date = valid_date(date)
         self.comment = comment
         self.effort = effort

-        self.children: list[Todo] = []
-        self.parents: list[Todo] = []
+        self.children = []
+        self.parents = []

         self.calendarize = calendarize
         if not self.id_:
             self.calendarize = self.process.calendarize
         self.calendarize = calendarize
         if not self.id_:
             self.calendarize = self.process.calendarize


@@ -91,6 +95,8 @@ class Todo(BaseModel[int], ConditionsRelations):
             sub_step_nodes = list(step_node.steps.values())
             sub_step_nodes.sort(key=key_order_func)
             for sub_node in sub_step_nodes:
             sub_step_nodes = list(step_node.steps.values())
             sub_step_nodes.sort(key=key_order_func)
             for sub_node in sub_step_nodes:

+                if sub_node.is_suppressed:
+                    continue

                 n_slots = len([n for n in sub_step_nodes
                                if n.process == sub_node.process])
                 filled_slots = len([t for t in satisfier.children
                 n_slots = len([n for n in sub_step_nodes
                                if n.process == sub_node.process])
                 filled_slots = len([t for t in satisfier.children


@@ -107,6 +113,8 @@ class Todo(BaseModel[int], ConditionsRelations):
         todo.save(db_conn)
         steps_tree = process.get_steps(db_conn)
         for step_node in steps_tree.values():
         todo.save(db_conn)
         steps_tree = process.get_steps(db_conn)
         for step_node in steps_tree.values():

+            if step_node.is_suppressed:
+                continue

             todo.add_child(walk_steps(todo, step_node))
         todo.save(db_conn)
         return todo
             todo.add_child(walk_steps(todo, step_node))
         todo.save(db_conn)
         return todo


@@ -124,11 +132,9 @@ class Todo(BaseModel[int], ConditionsRelations):
         assert isinstance(todo.id_, int)
         for t_id in db_conn.column_where('todo_children', 'child',
                                          'parent', todo.id_):
         assert isinstance(todo.id_, int)
         for t_id in db_conn.column_where('todo_children', 'child',
                                          'parent', todo.id_):

-            # pylint: disable=no-member

             todo.children += [cls.by_id(db_conn, t_id)]
         for t_id in db_conn.column_where('todo_children', 'parent',
                                          'child', todo.id_):
             todo.children += [cls.by_id(db_conn, t_id)]
         for t_id in db_conn.column_where('todo_children', 'parent',
                                          'child', todo.id_):

-            # pylint: disable=no-member

             todo.parents += [cls.by_id(db_conn, t_id)]
         for name in ('conditions', 'blockers', 'enables', 'disables'):
             table = f'todo_{name}'
             todo.parents += [cls.by_id(db_conn, t_id)]
         for name in ('conditions', 'blockers', 'enables', 'disables'):
             table = f'todo_{name}'


@@ -173,6 +179,15 @@ class Todo(BaseModel[int], ConditionsRelations):
             return False
         return True
 
             return False
         return True
 

+    @property
+    def performed_effort(self) -> float:
+        """Return performed effort, i.e. self.effort or default if done.."""
+        if self.effort is not None:
+            return self.effort
+        if self.is_done:
+            return self.effort_then
+        return 0
+

     @property
     def process_id(self) -> int | str | None:
         """Needed for super().save to save Processes as attributes."""
     @property
     def process_id(self) -> int | str | None:
         """Needed for super().save to save Processes as attributes."""


@@ -214,6 +229,18 @@ class Todo(BaseModel[int], ConditionsRelations):
         assert isinstance(effort_then, float)
         return effort_then
 
         assert isinstance(effort_then, float)
         return effort_then
 

+    @property
+    def has_doneness_in_path(self) -> bool:
+        """Check whether self is done or has any children that are."""
+        if self.is_done:
+            return True
+        for child in self.children:
+            if child.is_done:
+                return True
+            if child.has_doneness_in_path:
+                return True
+        return False
+

     def get_step_tree(self, seen_todos: set[int]) -> TodoNode:
         """Return tree of depended-on Todos."""
 
     def get_step_tree(self, seen_todos: set[int]) -> TodoNode:
         """Return tree of depended-on Todos."""
 


@@ -228,6 +255,18 @@ class Todo(BaseModel[int], ConditionsRelations):
 
         return make_node(self)
 
 
         return make_node(self)
 

+    @property
+    def tree_effort(self) -> float:
+        """Return sum of performed efforts of self and all descendants."""
+
+        def walk_tree(node: Todo) -> float:
+            local_effort = 0.0
+            for child in node.children:
+                local_effort += walk_tree(child)
+            return node.performed_effort + local_effort
+
+        return walk_tree(self)
+

     def add_child(self, child: Todo) -> None:
         """Add child to self.children, avoid recursion, update parenthoods."""
 
     def add_child(self, child: Todo) -> None:
         """Add child to self.children, avoid recursion, update parenthoods."""
 


@@ -259,12 +298,17 @@ class Todo(BaseModel[int], ConditionsRelations):
         if self.effort and self.effort < 0 and self.is_deletable:
             self.remove(db_conn)
             return
         if self.effort and self.effort < 0 and self.is_deletable:
             self.remove(db_conn)
             return

+        if self.id_ is None:
+            self.__class__.days_to_update.add(self.date)

         super().save(db_conn)
         super().save(db_conn)

+        for condition in self.enables + self.disables + self.conditions:
+            condition.save(db_conn)

 
     def remove(self, db_conn: DatabaseConnection) -> None:
         """Remove from DB, including relations."""
         if not self.is_deletable:
             raise HandledException('Cannot remove non-deletable Todo.')
 
     def remove(self, db_conn: DatabaseConnection) -> None:
         """Remove from DB, including relations."""
         if not self.is_deletable:
             raise HandledException('Cannot remove non-deletable Todo.')

+        self.__class__.days_to_update.add(self.date)

         children_to_remove = self.children[:]
         parents_to_remove = self.parents[:]
         for child in children_to_remove:
         children_to_remove = self.children[:]
         parents_to_remove = self.parents[:]
         for child in children_to_remove: