Buildings and levels for the floor map, and make every identifier searchable

shopdb/core/models/mapsnapshot.py

@@ -0,0 +1,76 @@
+"""A saved set of marker positions, so a bulk change can be undone.
+
+Positions had no history. A landmark transform rewrites every marker on a level
+in one statement, and without a way back the honest instruction would be "take a
+database backup first" - which nobody does before clicking a button in a UI, so
+in practice the feature would either not be used or be used once, badly.
+
+One row holds the whole set as JSON rather than a row per asset. A snapshot is
+read back whole or not at all, so restore stays a single statement, and there is
+no orphan-child case to reason about.
+"""
+
+import json
+
+from shopdb.extensions import db
+from .base import BaseModel
+
+
+class MapPositionSnapshot(BaseModel):
+    __tablename__ = 'mappositionsnapshots'
+
+    snapshotid = db.Column(db.Integer, primary_key=True)
+    # Which level the operation targeted. Nullable because a snapshot may span
+    # levels (moving assets between them), and then no single level owns it.
+    levelid = db.Column(db.Integer, nullable=True)
+    reason = db.Column(db.String(255), nullable=True)
+    assetcount = db.Column(db.Integer, nullable=False, default=0)
+    positionsjson = db.Column(db.Text, nullable=False)
+    # Set when this snapshot has been restored, so the history reads as what
+    # happened rather than as a list of identical-looking saves.
+    restoredat = db.Column(db.DateTime, nullable=True)
+    createdby = db.Column(db.String(100), nullable=True)
+
+    def __repr__(self):
+        return f"<MapPositionSnapshot {self.snapshotid} ({self.assetcount})>"
+
+    @property
+    def positions(self):
+        try:
+            return json.loads(self.positionsjson or '[]')
+        except ValueError:
+            return []
+
+    def to_dict(self):
+        """Metadata only. The positions themselves are large and nobody browsing
+        a list of snapshots wants them."""
+        data = super().to_dict()
+        data.pop('positionsjson', None)
+        return data
+
+    @classmethod
+    def capture(cls, assets, reason, levelid=None, createdby=None):
+        """Record the CURRENT positions of these assets, before they change.
+
+        Includes levelid and mapverifiedat, not just the coordinates: a restore
+        has to put a marker back on the level it was on and with the review state
+        it had, or undo would silently mark reviewed work as unreviewed.
+        """
+        rows = [{
+            'assetid': asset.assetid,
+            'mapx': asset.mapx,
+            'mapy': asset.mapy,
+            'levelid': asset.levelid,
+            'mapverifiedat': asset.mapverifiedat.isoformat()
+                             if asset.mapverifiedat else None,
+        } for asset in assets]
+        snapshot = cls(
+            levelid=levelid,
+            reason=reason,
+            assetcount=len(rows),
+            positionsjson=json.dumps(rows, separators=(',', ':')),
+            createdby=createdby,
+        )
+        db.session.add(snapshot)
+        db.session.flush()
+        return snapshot