Add expression of summations of efforts in Day display.

[plomtask] / plomtask / http.py

diff --git a/plomtask/http.py b/plomtask/http.py
index 773548f8a9201e3e48ab8093b6431ab826842110..44300166f0cc5d91fbdfe0c532dcf01c9d3e87e6 100644 (file)
--- a/plomtask/http.py
+++ b/plomtask/http.py
@@ -45,6 +45,13 @@ class InputsParser:
             return default
         return self.inputs[key][0]
 
+    def get_first_strings_starting(self, prefix: str) -> dict[str, str]:
+        """Retrieve list of (first) strings at key starting with prefix."""
+        ret = {}
+        for key in [k for k in self.inputs.keys() if k.startswith(prefix)]:
+            ret[key] = self.inputs[key][0]
+        return ret
+
     def get_int(self, key: str) -> int:
         """Retrieve single/first value of key as int, error if empty."""
         val = self.get_int_or_none(key)
@@ -90,6 +97,7 @@ class InputsParser:
 
 class TaskHandler(BaseHTTPRequestHandler):
     """Handles single HTTP request."""
+    # pylint: disable=too-many-public-methods
     server: TaskServer
 
     def do_GET(self) -> None:
@@ -110,12 +118,12 @@ class TaskHandler(BaseHTTPRequestHandler):
         finally:
             self.conn.close()
 
-    def do_GET_calendar(self) -> dict[str, object]:
+    def _do_GET_calendar(self) -> dict[str, object]:
         """Show Days from ?start= to ?end=."""
         start = self.params.get_str('start')
         end = self.params.get_str('end')
         if not end:
-            end = date_in_n_days(60)
+            end = date_in_n_days(366)
         ret = Day.by_date_range_with_limits(self.conn, (start, end), 'id')
         days, start, end = ret
         days = Day.with_filled_gaps(days, start, end)
@@ -124,10 +132,21 @@ class TaskHandler(BaseHTTPRequestHandler):
         today = date_in_n_days(0)
         return {'start': start, 'end': end, 'days': days, 'today': today}
 
+    def do_GET_calendar(self) -> dict[str, object]:
+        """Show Days from ?start= to ?end= – normal view."""
+        return self._do_GET_calendar()
+
+    def do_GET_calendar_txt(self) -> dict[str, object]:
+        """Show Days from ?start= to ?end= – minimalist view."""
+        return self._do_GET_calendar()
+
     def do_GET_day(self) -> dict[str, object]:
         """Show single Day of ?date=."""
         date = self.params.get_str('date', date_in_n_days(0))
         todays_todos = Todo.by_date(self.conn, date)
+        total_effort = 0
+        for todo in todays_todos:
+            total_effort += todo.performed_effort
         conditions_present = []
         enablers_for = {}
         disablers_for = {}
@@ -145,6 +164,7 @@ class TaskHandler(BaseHTTPRequestHandler):
         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,
                 'top_nodes': top_nodes,
                 'enablers_for': enablers_for,
                 'disablers_for': disablers_for,
@@ -156,6 +176,7 @@ class TaskHandler(BaseHTTPRequestHandler):
         id_ = self.params.get_int('id')
         todo = Todo.by_id(self.conn, id_)
         return {'todo': todo,
+                'process_candidates': Process.all(self.conn),
                 'todo_candidates': Todo.by_date(self.conn, todo.date),
                 'condition_candidates': Condition.all(self.conn)}
 
@@ -359,6 +380,9 @@ class TaskHandler(BaseHTTPRequestHandler):
                 continue
             child = Todo.by_id(self.conn, child_id)
             todo.add_child(child)
+        for process_id in self.form_data.get_all_int('make'):
+            made = Todo.create_with_children(self.conn, process_id, todo.date)
+            todo.add_child(made)
         effort = self.form_data.get_str('effort', ignore_strict=True)
         todo.effort = float(effort) if effort else None
         todo.set_conditions(self.conn, self.form_data.get_all_int('condition'))
@@ -375,6 +399,31 @@ class TaskHandler(BaseHTTPRequestHandler):
             condition.save(self.conn)
         return f'/todo?id={todo.id_}'
 
+    def _do_POST_versioned_timestamps(self, cls: Any, attr_name: str) -> str:
+        """Update history timestamps for VersionedAttribute."""
+        id_ = self.params.get_int_or_none('id')
+        item = cls.by_id(self.conn, id_)
+        attr = getattr(item, attr_name)
+        for k, v in self.form_data.get_first_strings_starting('at:').items():
+            old = k[3:]
+            if old[19:] != v:
+                attr.reset_timestamp(old, f'{v}.0')
+        attr.save(self.conn)
+        cls_name = cls.__name__.lower()
+        return f'/{cls_name}_{attr_name}s?id={item.id_}'
+
+    def do_POST_process_descriptions(self) -> str:
+        """Update history timestamps for Process.description."""
+        return self._do_POST_versioned_timestamps(Process, 'description')
+
+    def do_POST_process_efforts(self) -> str:
+        """Update history timestamps for Process.effort."""
+        return self._do_POST_versioned_timestamps(Process, 'effort')
+
+    def do_POST_process_titles(self) -> str:
+        """Update history timestamps for Process.title."""
+        return self._do_POST_versioned_timestamps(Process, 'title')
+
     def do_POST_process(self) -> str:
         """Update or insert Process of ?id= and fields defined in postvars."""
         # pylint: disable=too-many-branches
@@ -443,6 +492,14 @@ class TaskHandler(BaseHTTPRequestHandler):
             params = f'has_step={process.id_}&title_b64={title_b64_encoded}'
         return f'/process?{params}'
 
+    def do_POST_condition_descriptions(self) -> str:
+        """Update history timestamps for Condition.description."""
+        return self._do_POST_versioned_timestamps(Condition, 'description')
+
+    def do_POST_condition_titles(self) -> str:
+        """Update history timestamps for Condition.title."""
+        return self._do_POST_versioned_timestamps(Condition, 'title')
+
     def do_POST_condition(self) -> str:
         """Update/insert Condition of ?id= and fields defined in postvars."""
         id_ = self.params.get_int_or_none('id')