xmas-app 0.12.2__tar.gz → 0.13.1__tar.gz

{xmas_app-0.12.2 → xmas_app-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmas-app
-Version: 0.12.2
+Version: 0.13.1
 Summary: The XLeitstelle model-driven application schema app.
 License: EUPL-1.2-or-later
 License-File: LICENSE

{xmas_app-0.12.2 → xmas_app-0.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xmas-app"
-version = "0.12.2"
+version = "0.13.1"
 description = "The XLeitstelle model-driven application schema app."
 authors = [{ name = "Tobias Kraft", email = "tobias.kraft@gv.hamburg.de" }]
 classifiers = [

xmas_app-0.13.1/xmas_app/components/association.py

@@ -0,0 +1,246 @@
+import logging
+
+from nicegui import app, binding, events, run, ui
+
+from xmas_app.components.buttons import FeatureInteractionButton
+from xmas_app.db import get_ref_candidates, get_ref_objects
+
+logger = logging.getLogger("xmas_app")
+
+
+class AssociationList(ui.button):
+    """Class to view and edit associations with multiplicity > 1.
+
+    It initializes a button to use in a feature form that opens a dialog.
+    The dialog contains two tabs: one for existing and one for potential feature references.
+    The (potential) reference features are retreived from the database and rendered in tables.
+    A click on a feature (row) opens a dialog with action buttons to zoom to it etc.
+    Active references are handled via the tables selection mechanism: selected features are referenced, deselected features are not.
+    """
+
+    refs = binding.BindableProperty()
+
+    def __init__(self, bind_obj: object, bind_key: str) -> None:
+        """Initialize the button element.
+
+        Args:
+            bind_obj: The binding object to bind the reference list to, i.e. the feature.
+            bind_key: The property of the binding object to bind to, i.e. the association attribute.
+        """
+        super().__init__(icon="link")
+        self.props("square unelevated outline")
+        self.classes("w-full")
+        binding.bind(
+            self,
+            "refs",
+            bind_obj,
+            bind_key,
+            forward=lambda x: None if not x else x,
+            backward=lambda x: [] if not x else x,
+        )
+        self.rel = bind_key
+        self.dialog = ui.dialog().props("full-height")
+        self.dialog.on("before-show", self._on_dialog_open)
+        self.action_dialog = ui.dialog()
+        self.tab_panels: ui.tab_panels | None = None
+        self.table_existing: ui.table | None = None
+        self.table_candidates: ui.table | None = None
+        self.ref_objects: list[dict] | None = None
+        self.ref_candidates: list[dict] | None = None
+        # create a badge on the button showing the number of active references
+        with self:
+            ui.badge().props("floating").bind_text_from(
+                self,
+                "refs",
+                backward=lambda refs: str(len(refs)),
+            )
+        with (
+            self.dialog,
+            ui.card().style("min-width: 800px; max-width: 90vw;"),
+        ):
+            with ui.icon("live_help", size="1.2rem").classes("absolute top-1 right-1"):
+                ui.tooltip(
+                    """
+                    Durch Klick auf Features öffnet sich ein Aktionsdialog.
+                    Durch Selektion bzw. Deselektion von Features (nur im Editiermodus verfügbar)
+                    wird die entsprechende Referenz hinzugefügt bzw. entfernt.
+                    """
+                ).props("max-width=200px")
+            with ui.tabs().classes("w-full pt-2").props("no-caps dense") as tabs:
+                ui.tab("existing", "Bestehende Referenzen", "link").classes("w-full")
+                ui.tab("candidates", "Mögliche Referenzen", "add_link").classes(
+                    "w-full"
+                )
+            self.tab_panels = ui.tab_panels(
+                tabs, on_change=self._on_tab_change
+            ).classes("w-full")
+            with self.tab_panels:
+                with ui.tab_panel("existing"):
+                    self.table_existing = self._create_table()
+                with ui.tab_panel("candidates"):
+                    self.table_candidates = self._create_table()
+        self.on_click(self.dialog.open)
+
+    async def _on_dialog_open(self, _: events.GenericEventArguments):
+        """Deferred one-time initialization of table content."""
+        if not self.tab_panels.value:
+            self.tab_panels.set_value("existing")
+
+    async def _on_row_click(self, e: events.GenericEventArguments):
+        """Opens a dialog with action buttons for the row/feature."""
+        try:
+            row = e.args[1]
+            feature_id = row["id"]
+        except Exception as e:
+            logger.exception("error on loading feature data from row: %s", e)
+            return ui.notify("Fehler beim Abruf der Feature-Daten", type="negative")
+        self.action_dialog.clear()
+        with self.action_dialog, ui.card():
+            ui.label(f"{row['featuretype']} {feature_id[:8]}").classes("text-bold")
+            ui.button(
+                text="Vorschau öffnen",
+                icon="o_preview",
+                on_click=lambda: app.storage.client["form"]._preview_association(
+                    feature_id
+                ),
+            ).props("flat square no-caps align=left").classes("w-full")
+            FeatureInteractionButton(
+                "highlight_feature", feature_id, row["geometry_type"] != "nogeom"
+            )
+            FeatureInteractionButton("select_feature", feature_id)
+            FeatureInteractionButton(
+                "show_attribute_form", feature_id, app.storage.client["form"].feature.id
+            )
+        self.action_dialog.open()
+
+    async def _on_select(self, _: events.TableSelectionEventArguments):
+        """Sets active references to the aggregated selected features from both tables."""
+        try:
+            self.refs = [
+                selected["id"]
+                for selected in (
+                    self.table_existing.selected + self.table_candidates.selected
+                )
+            ]
+        except Exception as e:
+            logger.exception("Error while updating references: %s", e)
+            ui.notify("Fehler bei Aktualisierung der Referenzen", type="negative")
+
+    async def _on_tab_change(self, e: events.ValueChangeEventArguments):
+        """Deferred loading of DB features and table initialisation via tab change event."""
+        match e.value:
+            case "existing":
+                if self.ref_objects is None:
+                    self.table_existing.props("loading")
+                    self.ref_objects = await run.io_bound(get_ref_objects, self.refs)
+                    self.table_existing.update_rows(self.ref_objects)
+                    self.table_existing.selected = self.ref_objects
+                    self.table_existing.props(
+                        f":selected-rows-label='(numberOfRows) => `${{ numberOfRows }} von {len(self.ref_objects)} Referenzen selektiert`'"
+                    )
+                    self.table_existing.props(remove="loading")
+            case "candidates":
+                if self.ref_candidates is None:
+                    self.table_candidates.props("loading")
+                    self.ref_candidates = await run.io_bound(
+                        get_ref_candidates,
+                        self.refs,
+                        app.storage.client["plan_id"],
+                        app.storage.client["form"].model,
+                        self.rel,
+                    )
+                    self.table_candidates.update_rows(self.ref_candidates)
+                    self.table_candidates.props(
+                        f":selected-rows-label='(numberOfRows) => `${{ numberOfRows }} von {len(self.ref_candidates)} Referenzen selektiert`'"
+                    )
+                    self.table_candidates.props(remove="loading")
+
+    def _create_table(self) -> ui.table:
+        """Creates a table with adequate columns, props and event handlers."""
+        columns = [
+            {
+                "name": "id",
+                "label": "Identifikator",
+                "field": "id",
+                "align": "left",
+                "sortable": True,
+            },
+            {
+                "name": "featuretype",
+                "label": "Objektart",
+                "field": "featuretype",
+                "align": "left",
+                "sortable": True,
+            },
+            {
+                "name": "updated",
+                "label": "letzte Aktualisierung",
+                "field": "updated",
+                "align": "left",
+                "sortable": True,
+            },
+            {
+                "name": "extra_property",
+                "label": "Selektionskriterium",
+                "field": "extra_property",
+                "align": "left",
+                "sortable": True,
+                "classes": "hidden",
+                "headerClasses": "hidden",
+            },
+        ]
+        table = (
+            ui.table(
+                rows=[],
+                columns=columns,
+                selection="multiple",
+            )
+            .props(
+                """
+                no-data-label='keine passenden Features vorhanden'
+                no-results-label='keine passenden Ergebnisse gefunden'
+                flat
+                square
+                dense
+                virtual-scroll
+            """
+            )
+            .classes("w-full h-full")
+        )
+        if form := app.storage.client["form"]:
+            # use existing bind method to enable/disable selection
+            table.bind_visibility_from(
+                form,
+                "editable",
+                backward=lambda editable, table=table: table.props(
+                    f"selection={'none' if not editable else 'multiple'}"
+                ),
+            )
+        table.on("row-click", self._on_row_click)
+        table.on_select(self._on_select)
+        with table.add_slot("top"):
+            search = (
+                ui.input("Filter")
+                .bind_value(table, "filter")
+                .tooltip("über alle Spalten nach Ausdruck filtern")
+                .props("clearable square dense")
+                .classes("w-64")
+            )
+            with search.add_slot("prepend"):
+                ui.icon("filter_list")
+            ui.space()
+            ui.checkbox(
+                "Selektionskriterium",
+                on_change=lambda e, table=table: (
+                    table.columns[-1].update(
+                        {
+                            "classes": "" if e.value else "hidden",
+                            "headerClasses": "" if e.value else "hidden",
+                        }
+                    ),
+                    table.update(),
+                ),
+            ).tooltip(
+                "aktiviert eine zusätzliche Spalte mit einem ggf. definierten Selektionskriterium"
+            )
+        return table

xmas_app-0.13.1/xmas_app/components/buttons.py

@@ -0,0 +1,62 @@
+import json
+import logging
+from typing import Literal, get_args
+
+from nicegui import events, ui
+
+logger = logging.getLogger("xmas_app")
+
+
+class FeatureInteractionButton(ui.button):
+    """Generic Button to interact with QGIS features via QWebchannel."""
+
+    action_types = Literal["highlight_feature", "show_attribute_form", "select_feature"]
+    type_map = {
+        "highlight_feature": {"text": "Zum Feature springen", "icon": "o_pageview"},
+        "show_attribute_form": {
+            "text": "Attributformular öffnen",
+            "icon": "list_alt",
+        },
+        "select_feature": {"text": "Feature selektieren", "icon": "select_all"},
+    }
+
+    def __init__(
+        self,
+        action_type: action_types,
+        target: str,
+        source: str | None = None,
+        geom: bool = True,
+    ):
+        """Button initialization.
+
+        Args:
+            type: the specific action to initialize the button for
+            target: the ID of the target feature
+            source: the ID of the source feature
+            geom: whether the feature has a geometry
+        Raises:
+            ValueError: if the type is unknown
+        """
+        if action_type not in get_args(self.action_types):
+            raise ValueError(f"invalid type: '{action_type}'")
+        self.action_type = action_type
+        self.source = source
+        self.target = target
+        super().__init__(**self.type_map[action_type], on_click=self._on_click)
+        self.props("flat square no-caps align=left")
+        self.classes("w-full")
+        if not geom:
+            self.disable()
+            self.tooltip("Keine Geometrie")
+
+    async def _on_click(self, _: events.ClickEventArguments):
+        try:
+            logger.debug("Sending %s request to QWebChannel handler", self.action_type)
+            data = json.dumps({"source": self.source, "target": self.target})
+            ui.run_javascript(f"""new QWebChannel(qt.webChannelTransport, function (channel) {{
+                                        channel.objects.handler.{self.action_type}({data})
+                                }});""")
+        except Exception as e:
+            logger.exception(
+                "Exception while %s was called: %s", self.action_type, str(e)
+            )

xmas_app-0.13.1/xmas_app/components/label.py

@@ -0,0 +1,13 @@
+from nicegui import ui
+
+
+class LabelWithDescription(ui.label):
+    def __init__(self, text: str, tooltip=str | None):
+        super().__init__(text)
+        self.classes(
+            "underline underline-offset-2 decoration-1 decoration-dotted cursor-help"
+        )
+        with self:
+            ui.tooltip(tooltip or "").classes("text-sm").props(
+                "anchor='center middle' self='center left'"
+            )

{xmas_app-0.12.2 → xmas_app-0.13.1}/xmas_app/db.py

@@ -3,12 +3,13 @@ import logging
 from nicegui.observables import ObservableSet
 from sqlalchemy import select, text
 from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.orm import selectinload
+from sqlalchemy.orm import aliased, selectinload
 from xplan_tools.interface.db import DBRepository
 from xplan_tools.model import model_factory
-from xplan_tools.model.orm import Feature
+from xplan_tools.model.base import BaseFeature
+from xplan_tools.model.orm import Feature, Refs
 
-from xmas_app.settings import settings
+from xmas_app.settings import get_mappings, get_settings
 
 logger = logging.getLogger(__name__)
 
@@ -83,7 +84,7 @@ def get_db_plans() -> list[dict]:
     """
     results = []
     try:
-        with settings.repo.Session() as session:
+        with get_settings().repo.Session() as session:
             stmt = select(Feature).where(Feature.featuretype.regexp_match("^.*Plan$"))
             try:
                 db_result = session.execute(stmt)
@@ -199,21 +200,20 @@ def get_nodes(
                 icon = "o_text_snippet"
         return icon
 
-    with settings.repo.Session() as session:
-        Ref = Feature.refs.property.mapper.class_
+    with get_settings().repo.Session() as session:
         stmt = (
             select(Feature)
             .options(
                 selectinload(Feature.refs)
-                .selectinload(Ref.feature_inv)
+                .selectinload(Refs.feature_inv)
                 .selectinload(Feature.refs)
-                .selectinload(Ref.feature_inv)
+                .selectinload(Refs.feature_inv)
                 .selectinload(Feature.refs)
             )
             .where(Feature.id == id)
         )
 
-        feature = session.execute(stmt).scalars().first()
+        feature = session.execute(stmt).scalar_one_or_none()
         # feature = session.get(Feature, id)
         if not feature or "Plan" not in feature.featuretype:
             return
@@ -235,3 +235,86 @@ def get_nodes(
             feature.id,
             feature.appschema,
         )
+
+
+def _feature_to_table_row(feature: Feature) -> dict:
+    extra_property = getattr(
+        get_mappings().association_table.extra_properties, feature.appschema
+    ).get(feature.featuretype)
+    extra_property_label = feature.properties.get(extra_property, "N/A")
+    return {
+        "id": str(feature.id),
+        "featuretype": feature.featuretype,
+        "geometry_type": feature.geometry_type,
+        "updated": f"{feature.updated_at.strftime('%m.%d.%Y')} {feature.updated_at.strftime('%H:%M:%S')}",
+        "extra_property": f"{extra_property}={extra_property_label}"
+        if extra_property
+        else "N/A",
+    }
+
+
+def _rel_inv_is_list(feature: Feature, rel_inv: str | None) -> bool:
+    # if there is no inverse relation, return True
+    if not rel_inv:
+        return True
+    model = model_factory(feature.featuretype, feature.version, feature.appschema)
+    return model.get_property_info(rel_inv)["list"]
+
+
+def get_ref_objects(refs: list[str]) -> list[dict]:
+    """Returns a list of data objects for existing feature references to use in table rows."""
+    with get_settings().repo.Session() as session:
+        stmt = select(Feature).where(Feature.id.in_(refs))
+        features = session.execute(stmt).scalars().all()
+
+    return [_feature_to_table_row(feature) for feature in features]
+
+
+def get_ref_candidates(
+    refs: list[str], plan_id: str, model: BaseFeature, rel: str
+) -> list[dict]:
+    """Returns a list of data objects for potential feature references to use in table rows."""
+    prop_info = model.get_property_info(rel)
+    typename = prop_info["typename"]
+    featuretypes = typename if isinstance(typename, list) else [typename]
+    rel_inv = model.get_property_info(rel)["assoc_info"]["reverse"]
+
+    with get_settings().repo.Session() as session:
+        # collect all plan features while applying WHERE clauses to filter on the DB side
+        Plan = aliased(Feature, name="plan")
+        DirectFeature = aliased(Feature, name="direct_feature")
+        IndirectFeature = aliased(Feature, name="indirect_feature")
+
+        RefPlanDirect = aliased(Refs, name="ref_plan_direct")
+        RefDirectIndirect = aliased(Refs, name="ref_direct_indirect")
+        direct = (
+            select(DirectFeature)
+            .select_from(Plan)
+            .join(RefPlanDirect, RefPlanDirect.base_id == Plan.id)
+            .join(DirectFeature, DirectFeature.id == RefPlanDirect.related_id)
+            .where(Plan.id == plan_id)
+            .where(DirectFeature.featuretype.in_(featuretypes))
+            .where(DirectFeature.id.not_in(refs))
+        )
+
+        indirect = (
+            select(IndirectFeature)
+            .select_from(Plan)
+            .join(RefPlanDirect, RefPlanDirect.base_id == Plan.id)
+            .join(DirectFeature, DirectFeature.id == RefPlanDirect.related_id)
+            .join(RefDirectIndirect, RefDirectIndirect.base_id == DirectFeature.id)
+            .join(IndirectFeature, IndirectFeature.id == RefDirectIndirect.related_id)
+            .where(Plan.id == plan_id)
+            .where(IndirectFeature.featuretype.in_(featuretypes))
+            .where(IndirectFeature.id.not_in(refs))
+        )
+        stmt = direct.union(indirect)
+
+        candidates = (
+            session.execute(select(Feature).from_statement(stmt)).scalars().all()
+        )
+        return [
+            _feature_to_table_row(feature)
+            for feature in candidates
+            if _rel_inv_is_list(feature, rel_inv)
+        ]

{xmas_app-0.12.2 → xmas_app-0.13.1}/xmas_app/deps/version_guard.py

@@ -1,13 +1,16 @@
 from fastapi import Header, HTTPException
 from semver import format_version, parse
 
-from xmas_app.settings import settings
+from xmas_app.settings import get_settings
 
 
 async def enforce_plugin_version(
     user_agent: str = Header(...),
 ):
-    if not user_agent.startswith(settings.qgis_plugin_name):
+    if (
+        not user_agent.startswith(get_settings().qgis_plugin_name)
+        or get_settings().app_mode == "dev"
+    ):
         return
     try:
         _, plugin_version = user_agent.split("/")
@@ -15,12 +18,12 @@ async def enforce_plugin_version(
     except Exception:
         raise HTTPException(
             status_code=400,
-            detail=f"Invalid {settings.qgis_plugin_name} user-agent header: '{user_agent}'",
+            detail=f"Invalid {get_settings().qgis_plugin_name} user-agent header: '{user_agent}'",
         )
 
-    if client_v < settings.qgis_plugin_min_version:
+    if client_v < get_settings().qgis_plugin_min_version:
         # 426 Upgrade Required is appropriate
         raise HTTPException(
             status_code=426,
-            detail=f"Plugin version {settings.qgis_plugin_min_version}+ required, got {format_version(**client_v)}",
+            detail=f"Plugin version {get_settings().qgis_plugin_min_version}+ required, got {format_version(**client_v)}",
         )