+ @dataclass
+ class TodoStepsNode:
+ """Collect what's useful for Todo steps tree display."""
+ id_: int
+ todo: Todo | None
+ process: Process | None
+ children: list[TodoStepsNode] # pylint: disable=undefined-variable
+ fillable: bool = False
+
+ def walk_process_steps(id_: int,
+ process_step_nodes: list[ProcessStepsNode],
+ steps_nodes: list[TodoStepsNode]) -> None:
+ for process_step_node in process_step_nodes:
+ id_ += 1
+ node = TodoStepsNode(id_, None, process_step_node.process, [])
+ steps_nodes += [node]
+ walk_process_steps(id_, list(process_step_node.steps.values()),
+ node.children)
+
+ def walk_todo_steps(id_: int, todos: list[Todo],
+ steps_nodes: list[TodoStepsNode]) -> None:
+ for todo in todos:
+ matched = False
+ for match in [item for item in steps_nodes
+ if item.process
+ and item.process == todo.process]:
+ match.todo = todo
+ matched = True
+ for child in match.children:
+ child.fillable = True
+ walk_todo_steps(id_, todo.children, match.children)
+ if not matched:
+ id_ += 1
+ node = TodoStepsNode(id_, todo, None, [])
+ steps_nodes += [node]
+ walk_todo_steps(id_, todo.children, node.children)
+
+ def collect_adoptables_keys(steps_nodes: list[TodoStepsNode]
+ ) -> set[int]:
+ ids = set()
+ for node in steps_nodes:
+ if not node.todo:
+ assert isinstance(node.process, Process)
+ assert isinstance(node.process.id_, int)
+ ids.add(node.process.id_)
+ ids = ids | collect_adoptables_keys(node.children)
+ return ids
+
+ todo_steps = [step.todo for step in todo.get_step_tree(set()).children]
+ process_tree = todo.process.get_steps(self.conn, None)
+ steps_todo_to_process: list[TodoStepsNode] = []
+ walk_process_steps(0, list(process_tree.values()),
+ steps_todo_to_process)
+ for steps_node in steps_todo_to_process:
+ steps_node.fillable = True
+ walk_todo_steps(len(steps_todo_to_process), todo_steps,
+ steps_todo_to_process)
+ 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.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_]
+ return {'todo': todo, 'steps_todo_to_process': steps_todo_to_process,
+ 'adoption_candidates_for': adoptables,
+ 'process_candidates': Process.all(self.conn),
+ 'todo_candidates': any_adoptables,
+ 'condition_candidates': Condition.all(self.conn)}
+
+ def do_GET_todos(self) -> dict[str, object]:
+ """Show Todos from ?start= to ?end=, of ?process=, ?comment= pattern"""
+ sort_by = self._params.get_str('sort_by')
+ start = self._params.get_str('start')
+ end = self._params.get_str('end')
+ process_id = self._params.get_int_or_none('process_id')
+ comment_pattern = self._params.get_str('comment_pattern')
+ todos = []
+ ret = Todo.by_date_range_with_limits(self.conn, (start, end))
+ todos_by_date_range, start, end = ret
+ todos = [t for t in todos_by_date_range
+ if comment_pattern in t.comment
+ and ((not process_id) or t.process.id_ == process_id)]
+ sort_by = Todo.sort_by(todos, 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}
+
+ def do_GET_conditions(self) -> dict[str, object]:
+ """Show all Conditions."""
+ pattern = self._params.get_str('pattern')
+ sort_by = self._params.get_str('sort_by')
+ conditions = Condition.matching(self.conn, pattern)
+ sort_by = Condition.sort_by(conditions, sort_by)
+ return {'conditions': conditions,
+ 'sort_by': sort_by,
+ 'pattern': pattern}
+
+ @_get_item(Condition)
+ def do_GET_condition(self, c: Condition) -> dict[str, object]:
+ """Show Condition of ?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],
+ 'disabled_processes': [p for p in ps if c in p.blockers],
+ 'enabling_processes': [p for p in ps if c in p.enables],
+ 'disabling_processes': [p for p in ps if c in p.disables]}
+
+ @_get_item(Condition)
+ def do_GET_condition_titles(self, c: Condition) -> dict[str, object]:
+ """Show title history of Condition of ?id=."""
+ return {'condition': c}
+
+ @_get_item(Condition)
+ def do_GET_condition_descriptions(self, c: Condition) -> dict[str, object]:
+ """Show description historys of Condition of ?id=."""
+ return {'condition': c}
+
+ @_get_item(Process)
+ def do_GET_process(self, process: Process) -> dict[str, object]:
+ """Show Process of ?id=."""
+ owner_ids = self._params.get_all_int('step_to')
+ owned_ids = self._params.get_all_int('has_step')
+ title_64 = self._params.get_str('title_b64')
+ if title_64:
+ title = b64decode(title_64.encode()).decode()
+ process.title.set(title)
+ owners = process.used_as_step_by(self.conn)
+ for step_id in owner_ids:
+ owners += [Process.by_id(self.conn, step_id)]
+ preset_top_step = None
+ for process_id in owned_ids:
+ preset_top_step = process_id
+ return {'process': process, 'is_new': process.id_ is None,
+ 'preset_top_step': preset_top_step,
+ 'steps': process.get_steps(self.conn), 'owners': owners,
+ 'n_todos': len(Todo.by_process_id(self.conn, process.id_)),
+ 'process_candidates': Process.all(self.conn),
+ 'condition_candidates': Condition.all(self.conn)}
+
+ @_get_item(Process)
+ def do_GET_process_titles(self, p: Process) -> dict[str, object]:
+ """Show title history of Process of ?id=."""
+ return {'process': p}
+
+ @_get_item(Process)
+ def do_GET_process_descriptions(self, p: Process) -> dict[str, object]:
+ """Show description historys of Process of ?id=."""
+ return {'process': p}
+
+ @_get_item(Process)
+ def do_GET_process_efforts(self, p: Process) -> dict[str, object]:
+ """Show default effort history of Process of ?id=."""
+ return {'process': p}
+
+ def do_GET_processes(self) -> dict[str, object]:
+ """Show all Processes."""
+ pattern = self._params.get_str('pattern')
+ sort_by = self._params.get_str('sort_by')
+ processes = Process.matching(self.conn, pattern)
+ sort_by = Process.sort_by(processes, sort_by)
+ return {'processes': processes, 'sort_by': sort_by, 'pattern': pattern}
+
+ # POST handlers
+
+ @staticmethod
+ def _delete_or_post(target_class: Any, redir_target: str = '/'
+ ) -> Callable[..., Callable[[TaskHandler], str]]:
+ def decorator(f: Callable[..., str]
+ ) -> Callable[[TaskHandler], str]:
+ def wrapper(self: TaskHandler) -> str:
+ # pylint: disable=protected-access
+ # (because pylint here fails to detect the use of wrapper as a
+ # method to self with respective access privileges)
+ id_ = self._params.get_int_or_none('id')
+ for _ in self._form_data.get_all_str('delete'):
+ if id_ is None:
+ msg = 'trying to delete non-saved ' +\
+ f'{target_class.__name__}'
+ raise NotFoundException(msg)
+ item = target_class.by_id(self.conn, id_)
+ item.remove(self.conn)
+ return redir_target
+ if target_class.can_create_by_id:
+ item = target_class.by_id_or_create(self.conn, id_)
+ else:
+ item = target_class.by_id(self.conn, id_)
+ return f(self, item)
+ return wrapper
+ return decorator
+
+ def _change_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)
+ return f'/{cls.name_lowercase()}_{attr_name}s?id={item.id_}'
+
+ def do_POST_day(self) -> str: