X-Git-Url: https://plomlompom.com/repos/foo.html?a=blobdiff_plain;f=plomtask%2Fprocesses.py;h=fe9bd4a63ff36a34afdbcbe0abed36edb891c8f5;hb=63249f5d7cefb97574610848ca3473cb1f9687e2;hp=ba9707be5c407116d1bdd13f0f9210147942b25e;hpb=13845c83a9e3e107aa7c40e86d8a0cda1a317f8a;p=plomtask

diff --git a/plomtask/processes.py b/plomtask/processes.py
index ba9707b..fe9bd4a 100644
--- a/plomtask/processes.py
+++ b/plomtask/processes.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 from sqlite3 import Row
 from datetime import datetime
+from typing import Any, Set
 from plomtask.db import DatabaseConnection
 from plomtask.exceptions import NotFoundException, BadFormatException
 
@@ -16,32 +17,37 @@ class Process:
         self.title = VersionedAttribute(self, 'title', 'UNNAMED')
         self.description = VersionedAttribute(self, 'description', '')
         self.effort = VersionedAttribute(self, 'effort', 1.0)
-        self.child_ids: list[int] = []
+        self.explicit_steps: list[ProcessStep] = []
 
     @classmethod
-    def from_table_row(cls, row: Row) -> Process:
+    def from_table_row(cls, db_conn: DatabaseConnection, row: Row) -> Process:
         """Make Process from database row, with empty VersionedAttributes."""
-        return cls(row[0])
+        process = cls(row[0])
+        assert process.id_ is not None
+        db_conn.cached_processes[process.id_] = process
+        return process
 
     @classmethod
     def all(cls, db_conn: DatabaseConnection) -> list[Process]:
         """Collect all Processes and their connected VersionedAttributes."""
         processes = {}
-        for row in db_conn.exec('SELECT * FROM processes'):
-            process = cls.from_table_row(row)
-            processes[process.id_] = process
-        for row in db_conn.exec('SELECT * FROM process_titles'):
-            processes[row[0]].title.history[row[1]] = row[2]
-        for row in db_conn.exec('SELECT * FROM process_descriptions'):
-            processes[row[0]].description.history[row[1]] = row[2]
-        for row in db_conn.exec('SELECT * FROM process_efforts'):
-            processes[row[0]].effort.history[row[1]] = row[2]
+        for id_, process in db_conn.cached_processes.items():
+            processes[id_] = process
+        already_recorded = processes.keys()
+        for row in db_conn.exec('SELECT id FROM processes'):
+            if row[0] not in already_recorded:
+                process = cls.by_id(db_conn, row[0])
+                processes[process.id_] = process
         return list(processes.values())
 
     @classmethod
     def by_id(cls, db_conn: DatabaseConnection, id_: int | None,
               create: bool = False) -> Process:
         """Collect Process, its VersionedAttributes, and its child IDs."""
+        if id_ in db_conn.cached_processes.keys():
+            process = db_conn.cached_processes[id_]
+            assert isinstance(process, Process)
+            return process
         process = None
         for row in db_conn.exec('SELECT * FROM processes '
                                 'WHERE id = ?', (id_,)):
@@ -61,43 +67,157 @@ class Process:
             for row in db_conn.exec('SELECT * FROM process_efforts '
                                     'WHERE process_id = ?', (process.id_,)):
                 process.effort.history[row[1]] = row[2]
-            for row in db_conn.exec('SELECT * FROM process_children '
-                                    'WHERE parent_id = ?', (process.id_,)):
-                process.child_ids += [row[1]]
+            for row in db_conn.exec('SELECT * FROM process_steps '
+                                    'WHERE owner_id = ?', (process.id_,)):
+                process.explicit_steps += [ProcessStep.from_table_row(db_conn,
+                                                                      row)]
+        assert isinstance(process, Process)
         return process
 
-    def get_descendants(self, db_conn: DatabaseConnection) ->\
-            dict[int, dict[str, object]]:
-        """Return tree of descendant Processes"""
-        descendants = {}
-        for id_ in self.child_ids:
-            child = self.__class__.by_id(db_conn, id_)
-            descendants[id_] = {'process': child,
-                                'children': child.get_descendants(db_conn)}
-        return descendants
+    def used_as_step_by(self, db_conn: DatabaseConnection) -> list[Process]:
+        """Return Processes using self for a ProcessStep."""
+        owner_ids = set()
+        for owner_id in db_conn.exec('SELECT owner_id FROM process_steps WHERE'
+                                     ' step_process_id = ?', (self.id_,)):
+            owner_ids.add(owner_id[0])
+        return [self.__class__.by_id(db_conn, id_) for id_ in owner_ids]
 
-    def save(self, db_conn: DatabaseConnection) -> None:
-        """Add (or re-write) self and connected VersionedAttributes to DB.
+    def get_steps(self, db_conn: DatabaseConnection, external_owner:
+                  Process | None = None) -> dict[int, dict[str, object]]:
+        """Return tree of depended-on explicit and implicit ProcessSteps."""
+
+        def make_node(step: ProcessStep) -> dict[str, object]:
+            step_process = self.__class__.by_id(db_conn, step.step_process_id)
+            is_explicit = False
+            if external_owner is not None:
+                is_explicit = step.owner_id == external_owner.id_
+            step_steps = step_process.get_steps(db_conn, external_owner)
+            return {'process': step_process, 'parent_id': step.parent_step_id,
+                    'is_explicit': is_explicit, 'steps': step_steps}
+
+        def walk_steps(node_id: int, node: dict[str, Any]) -> None:
+            explicit_children = [s for s in self.explicit_steps
+                                 if s.parent_step_id == node_id]
+            for child in explicit_children:
+                node['steps'][child.id_] = make_node(child)
+            node['seen'] = node_id in seen_step_ids
+            seen_step_ids.add(node_id)
+            for id_, step in node['steps'].items():
+                walk_steps(id_, step)
+
+        steps: dict[int, dict[str, object]] = {}
+        seen_step_ids: Set[int] = set()
+        if external_owner is None:
+            external_owner = self
+        for step in [s for s in self.explicit_steps
+                     if s.parent_step_id is None]:
+            assert step.id_ is not None  # for mypy
+            steps[step.id_] = make_node(step)
+        for step_id, step_node in steps.items():
+            walk_steps(step_id, step_node)
+        return steps
+
+    def add_step(self, db_conn: DatabaseConnection, id_: int | None,
+                 step_process_id: int,
+                 parent_step_id: int | None) -> ProcessStep:
+        """Create new ProcessStep, save and add it to self.explicit_steps.
 
-        Also is the point at which descendancy recursion is checked.
+        Also checks against step recursion.
+        The new step's parent_step_id will fall back to None either if no
+        matching ProcessStep is found (which can be assumed in case it was
+        just deleted under its feet), or if the parent step would not be
+        owned by the current Process.
         """
-        def walk_descendants(node_id: int) -> None:
-            if node_id == self.id_:
-                raise BadFormatException('bad child selection: recursion')
-            descendant = self.by_id(db_conn, node_id)
-            for descendant_id in descendant.child_ids:
-                walk_descendants(descendant_id)
+        def walk_steps(node: ProcessStep) -> None:
+            if node.step_process_id == self.id_:
+                raise BadFormatException('bad step selection causes recursion')
+            step_process = self.by_id(db_conn, node.step_process_id)
+            for step in step_process.explicit_steps:
+                walk_steps(step)
+        if parent_step_id is not None:
+            try:
+                parent_step = ProcessStep.by_id(db_conn, parent_step_id)
+                if parent_step.owner_id != self.id_:
+                    parent_step_id = None
+            except NotFoundException:
+                parent_step_id = None
+        assert self.id_ is not None
+        step = ProcessStep(id_, self.id_, step_process_id, parent_step_id)
+        walk_steps(step)
+        self.explicit_steps += [step]
+        step.save(db_conn)  # NB: This ensures a non-None step.id_.
+        return step
+
+    def save_without_steps(self, db_conn: DatabaseConnection) -> None:
+        """Add (or re-write) self and connected VersionedAttributes to DB."""
         cursor = db_conn.exec('REPLACE INTO processes VALUES (?)', (self.id_,))
         self.id_ = cursor.lastrowid
         self.title.save(db_conn)
         self.description.save(db_conn)
         self.effort.save(db_conn)
-        db_conn.exec('DELETE FROM process_children WHERE parent_id = ?',
+        assert self.id_ is not None
+        db_conn.cached_processes[self.id_] = self
+
+    def fix_steps(self, db_conn: DatabaseConnection) -> None:
+        """Rewrite ProcessSteps from self.explicit_steps.
+
+        This also fixes illegal Step.parent_step_id values, i.e. those pointing
+        to steps now absent, or owned by a different Process, fall back into
+        .parent_step_id=None
+        """
+        db_conn.exec('DELETE FROM process_steps WHERE owner_id = ?',
                      (self.id_,))
-        for child_id in self.child_ids:
-            walk_descendants(child_id)
-            db_conn.exec('INSERT INTO process_children VALUES (?, ?)',
-                         (self.id_, child_id))
+        for step in self.explicit_steps:
+            if step.parent_step_id is not None:
+                try:
+                    parent_step = ProcessStep.by_id(db_conn,
+                                                    step.parent_step_id)
+                    if parent_step.owner_id != self.id_:
+                        step.parent_step_id = None
+                except NotFoundException:
+                    step.parent_step_id = None
+            step.save(db_conn)
+
+
+class ProcessStep:
+    """Sub-unit of Processes."""
+
+    def __init__(self, id_: int | None, owner_id: int, step_process_id: int,
+                 parent_step_id: int | None) -> None:
+        self.id_ = id_
+        self.owner_id = owner_id
+        self.step_process_id = step_process_id
+        self.parent_step_id = parent_step_id
+
+    @classmethod
+    def from_table_row(cls, db_conn: DatabaseConnection,
+                       row: Row) -> ProcessStep:
+        """Make ProcessStep from database row, store in DB cache."""
+        step = cls(row[0], row[1], row[2], row[3])
+        assert step.id_ is not None
+        db_conn.cached_process_steps[step.id_] = step
+        return step
+
+    @classmethod
+    def by_id(cls, db_conn: DatabaseConnection, id_: int) -> ProcessStep:
+        """Retrieve ProcessStep by id_, or throw NotFoundException."""
+        if id_ in db_conn.cached_process_steps.keys():
+            step = db_conn.cached_process_steps[id_]
+            assert isinstance(step, ProcessStep)
+            return step
+        for row in db_conn.exec('SELECT * FROM process_steps '
+                                'WHERE step_id = ?', (id_,)):
+            return cls.from_table_row(db_conn, row)
+        raise NotFoundException(f'found no ProcessStep of ID {id_}')
+
+    def save(self, db_conn: DatabaseConnection) -> None:
+        """Save to database and cache."""
+        cursor = db_conn.exec('REPLACE INTO process_steps VALUES (?, ?, ?, ?)',
+                              (self.id_, self.owner_id, self.step_process_id,
+                               self.parent_step_id))
+        self.id_ = cursor.lastrowid
+        assert self.id_ is not None
+        db_conn.cached_process_steps[self.id_] = self
 
 
 class VersionedAttribute: