xmas-app 0.11.3__tar.gz → 0.12.0__tar.gz

{xmas_app-0.11.3 → xmas_app-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmas-app
-Version: 0.11.3
+Version: 0.12.0
 Summary: The XLeitstelle model-driven application schema app.
 License: EUPL-1.2-or-later
 License-File: LICENSE
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Dist: nicegui (>=2.20,<3.0)
 Requires-Dist: pydantic-extra-types[semver]
 Requires-Dist: pydantic-settings (>=2.0,<3.0)
-Requires-Dist: xplan-tools (>=1.10.3)
+Requires-Dist: xplan-tools (>=1.11.0,<1.12.0)
 Project-URL: Homepage, https://gitlab.opencode.de/xleitstelle/xmas-app
 Project-URL: Issues, https://gitlab.opencode.de/xleitstelle/xmas-app/-/issues
 Description-Content-Type: text/markdown

{xmas_app-0.11.3 → xmas_app-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xmas-app"
-version = "0.11.3"
+version = "0.12.0"
 description = "The XLeitstelle model-driven application schema app."
 authors = [{ name = "Tobias Kraft", email = "tobias.kraft@gv.hamburg.de" }]
 classifiers = [
@@ -16,7 +16,7 @@ license-files = ["LICENSE"]
 dependencies = [
     "pydantic-settings>=2.0,<3.0",
     "pydantic-extra-types[semver]",
-    "xplan-tools>=1.10.3",
+    "xplan-tools~=1.11.0",
     "nicegui>=2.20,<3.0",
     # "uvicorn[standard]>=0.29,<0.31"
     # "pygeoapi @ git+https://github.com/geopython/pygeoapi.git",

{xmas_app-0.11.3 → xmas_app-0.12.0}/xmas_app/db.py

@@ -73,6 +73,45 @@ def get_db_feature_ids(
     return results
 
 
+def get_db_plans() -> list[dict]:
+    """Get plan data from the database.
+
+    Query the database for plan objects.
+
+    Returns:
+        list[dict]: List of dicts containing plan data, i.e. name, id, appschema, version, last update.
+    """
+    results = []
+    try:
+        with settings.repo.Session() as session:
+            stmt = select(Feature).where(Feature.featuretype.regexp_match("^.*Plan$"))
+            try:
+                db_result = session.execute(stmt)
+                features = db_result.unique().scalars().all()
+                logger.info(f"Found {len(features)} feature(s) in DB.")
+            except Exception as db_ex:
+                logger.error(f"Database query failed: {db_ex}", exc_info=True)
+            for feature in features:
+                plan_data = {
+                    "id": str(feature.id),
+                    "label": feature.properties.get("name", "<Name unbekannt>"),
+                    "appschema": {
+                        "name": feature.appschema.upper(),
+                        "version": feature.version,
+                    },
+                    "updated": {
+                        "date": f"{feature.updated_at.strftime('%m.%d.%Y')}",
+                        "time": f"{feature.updated_at.strftime('%H:%M:%S Uhr')}",
+                    },
+                }
+                results.append(plan_data)
+
+    except Exception as ex:
+        logger.error(f"Failed to get plan data: {ex}", exc_info=True)
+        raise
+    return results
+
+
 def delete_db_association(base_id: str, related_id: str, repo: DBRepository):
     try:
         with repo.Session() as session:

{xmas_app-0.11.3 → xmas_app-0.12.0}/xmas_app/form.py

@@ -627,7 +627,7 @@ class ModelForm:
             class_info.move(self.header if not preview else self.parent, 0)
         with ui.grid(columns="310px auto"):
             for key, field_info in model.model_fields.items():
-                if key == "id" or key == model.get_geom_field():
+                if key == model.get_geom_field():
                     continue
                 prop_info = model.get_property_info(key)
                 if preview and (
@@ -661,7 +661,11 @@ class ModelForm:
                     with ui.expansion(key).props(
                         "expand-icon=o_info dense dense-toggle header-class=text-bold"
                     ):
-                        ui.label(field_info.description or "")
+                        ui.label(
+                            "Identifikator des Features."
+                            if key == "id"
+                            else field_info.description or ""
+                        )
                 with ui.row() as property_row:
                     if main_form and not preview:
                         property_row.bind_visibility_from(
@@ -679,6 +683,16 @@ class ModelForm:
                         if prop_info["nullable"]:
                             marker.append("nullable")
                         property_row.mark(" ".join(marker))
+                    if key == "id":
+                        input = (
+                            ui.label()
+                            .bind_text_from(
+                                bind_obj,
+                                key,
+                            )
+                            .classes("w-full")
+                        )
+                        continue
                     if key == "stylesheetId":
                         input = (
                             ui.label()
@@ -691,7 +705,6 @@ class ModelForm:
                             )
                             .classes("w-full")
                         )
-                        # input.disable()
                         continue
                     match prop_info["stereotype"]:
                         case "BasicType":

{xmas_app-0.11.3 → xmas_app-0.12.0}/xmas_app/main.py

@@ -29,7 +29,7 @@ from xplan_tools.util import (
     get_geometry_type_from_wkt,
 )
 
-from xmas_app.db import get_db_feature_ids, get_nodes
+from xmas_app.db import get_db_feature_ids, get_db_plans, get_nodes
 from xmas_app.deps.version_guard import enforce_plugin_version
 from xmas_app.form import ModelForm
 from xmas_app.models.crud import InsertPayload, UpdatePayload
@@ -257,23 +257,23 @@ async def plan_tree(
                             on_click=lambda e, target=target: confirm_delete(target),
                         )
             elif len(path) == 3:
-                origin_featuretype, origin_id, attr = path
+                origin_featuretype, origin_id, rel = path
                 with action_dialog, ui.card(align_items="stretch"):
                     ui.label(origin_featuretype + " " + origin_id[:8]).classes(
                         "text-bold"
                     )
-                    if attr == "bereich":
-                        ui.label(f"Keine Aktionen für Referenz {repr(attr)} verfügbar")
+                    if rel == "bereich":
+                        ui.label(f"Keine Aktionen für Referenz {repr(rel)} verfügbar")
                     else:
-                        ui.label(f"Neues Feature für Referenz {repr(attr)} erstellen")
+                        ui.label(f"Neues Feature für Referenz {repr(rel)} erstellen")
                         feature = settings.repo.get(origin_id)
-                        prop_info = feature.get_property_info(attr)
+                        prop_info = feature.get_property_info(rel)
                         typename = prop_info["typename"]
                         targets = typename if isinstance(typename, list) else [typename]
                         target_select = ui.select(
                             targets,
                             label="Featuretype auswählen",
-                            value=targets[0],
+                            value=None,
                             with_input=True,
                         )
                         if len(targets) == 1:
@@ -281,17 +281,103 @@ async def plan_tree(
                         with target_select.add_slot("append"):
                             ui.badge(str(len(targets))).props("floating")
                         with target_select.add_slot("after"):
-                            ui.button(
+                            dropdown = ui.dropdown_button(
                                 icon="play_circle",
-                                on_click=lambda _: ui.notify(
-                                    "noch nicht implementiert"
-                                ),
+                                split=True,
                             )
+                            target_select.on_value_change(
+                                lambda e,
+                                origin_featuretype=origin_featuretype,
+                                origin_id=origin_id,
+                                rel=rel: prepare_add_feature(
+                                    dropdown,
+                                    origin_featuretype,
+                                    origin_id,
+                                    rel,
+                                    e.value,
+                                )
+                            )
+                            if len(targets) == 1:
+                                target_select.set_value(targets[0])
+                            else:
+                                dropdown.props("disable")
 
             else:
                 return
             action_dialog.open()
 
+    async def prepare_add_feature(
+        dropdown: ui.dropdown_button,
+        origin_featuretype: str,
+        origin_id: str,
+        rel: str,
+        target_featuretype: str,
+    ):
+        def trigger_add_feature(geometry_type):
+            rel_inv = origin_feature.get_property_info(rel)["assoc_info"]["reverse"]
+            data = {
+                "origin_featuretype": origin_featuretype,
+                "origin_id": origin_id,
+                "rel": rel,
+                "rel_list": origin_feature.get_property_info(rel)["list"],
+                "rel_inv": rel_inv,
+                "rel_inv_list": target_model.get_property_info(rel_inv)["list"]
+                if rel_inv
+                else False,
+                "target_featuretype": target_featuretype,
+                "target_geometrytype": geometry_type,
+            }
+            print(data)
+            try:
+                logger.info("Sending add_feature to QWebChannel handler")
+                ui.run_javascript(f"""new QWebChannel(qt.webChannelTransport, function (channel) {{
+                                            channel.objects.handler.add_feature({data})
+                                    }});""")
+            except Exception as ex:
+                logger.error(f"Exception while add_feature called: {ex}", exc_info=True)
+
+        GEOMETRY_MAP = {
+            "Polygon": {"label": "Fläche", "icon": "o_space_dashboard"},
+            "Line": {"label": "Linie", "icon": "show_chart"},
+            "Point": {"label": "Punkt", "icon": "o_location_on"},
+            "Null": {"label": "Keine Geometrie", "icon": "o_text_snippet"},
+        }
+
+        logger.debug("add_feature called")
+        dropdown.clear()
+        dropdown.props(remove="disable")
+        origin_feature = settings.repo.get(origin_id)
+        target_model = model_factory(
+            target_featuretype,
+            origin_feature.get_version(),
+            origin_feature.get_appschema(),
+        )
+        geometry_types = []
+        if geom_types := target_model.get_geom_types():
+            for geom_type in geom_types:
+                type_name = geom_type.get_name().replace("Multi", "")
+                if type_name not in geometry_types:
+                    geometry_types.append(type_name)
+        else:
+            geometry_types.append("Null")
+        if len(geometry_types) == 1:
+            dropdown.on_click(lambda: trigger_add_feature(geometry_types[0]))
+            dropdown.props("disable-dropdown")
+        else:
+            with dropdown:
+                dropdown.on_click(lambda e: e.sender.open())
+                dropdown.props(remove="disable-dropdown")
+                for geometry_type in geometry_types:
+                    with ui.item(
+                        on_click=lambda geometry_type=geometry_type: trigger_add_feature(
+                            geometry_type
+                        ),
+                    ):
+                        with ui.item_section().props("avatar"):
+                            ui.icon(GEOMETRY_MAP[geometry_type]["icon"])
+                        with ui.item_section():
+                            ui.item_label(GEOMETRY_MAP[geometry_type]["label"])
+
     async def highlight_feature(e: ClickEventArguments, target: str):
         logger.debug("highlight_feature called")
         try:
@@ -426,35 +512,31 @@ async def plans(
         logger.info("Updating plan select options")
         plan_select.props("loading")
         try:
-            feature_ids = await asyncio.wait_for(
-                run.io_bound(
-                    get_db_feature_ids,
-                    settings.repo,
-                    None,
-                    "^.*Plan$",
-                    "name",
-                ),
+            selected = plan_select.options.index(plan_select.value)
+        except ValueError:
+            selected = 0
+        try:
+            plans = await asyncio.wait_for(
+                run.io_bound(get_db_plans),
                 timeout=10,
             )
-            if not feature_ids:  # Handle empty result or None
+            if not plans:  # Handle empty result or None
                 logger.warning("No plans returned from the database.")
                 ui.notify(
                     "Keine Pläne gefunden (möglicherweise keine Verbindung zur Datenbank)!",
                     type="negative",
                 )
-                plan_select.set_options({})
+                plan_select.set_options([])
             else:
-                if feature_ids is not None and feature_ids:
-                    plan_select.set_options(feature_ids)
-                    plan_select.set_value(list(feature_ids.keys())[0])
-                else:
-                    logger.warning("No plans found or database unreachable.")
+                plan_select.set_options(plans)
+                plan_select.set_value(plans[selected])
+
         except asyncio.TimeoutError:
             logger.error("Timeout: DB connection took too long.")
             ui.notify(
                 "Verbindung zur Datenbank dauert zu lange (Timeout)!", type="negative"
             )
-            plan_select.set_options({})
+            plan_select.set_options([])
         except Exception as e:
             print("Fehler beim Laden der Pläne:", e)
             logger.error(f"Fehler beim Laden der Pläne: {e}")
@@ -465,7 +547,7 @@ async def plans(
                 ui.notify("Keine Verbindung zur Datenbank!", type="negative")
             else:
                 ui.notify(f"Fehler beim Laden der Pläne: {e}", type="negative")
-            plan_select.set_options({})
+            plan_select.set_options([])
         finally:
             plan_select.props(remove="loading")
 
@@ -476,10 +558,12 @@ async def plans(
         )
         try:
             download_dropdown.props(add="loading")
-            plan = await run.io_bound(settings.repo.get_plan_by_id, plan_select.value)
+            plan = await run.io_bound(
+                settings.repo.get_plan_by_id, plan_select.value["id"]
+            )
 
-            appschema = plan.features[plan_select.value].get_data_type()
-            version = plan.features[plan_select.value].get_version()
+            appschema = plan.features[plan_select.value["id"]].get_appschema()
+            version = plan.features[plan_select.value["id"]].get_version()
             logger.debug(
                 "Loaded plan metadata: version=%s schema=%s", version, appschema
             )
@@ -490,17 +574,14 @@ async def plans(
                 )  # TODO get data from in-memory sqlite db?
                 logger.debug("Using temporary sqlite file %s", temp_file.name)
                 uri = f"gpkg:///{temp_file.name}"
-                repo = DBRepository(uri, version, appschema)
-                repo.create_tables(srid=plan.srid)
+                repo = DBRepository(uri, srid=plan.srid)
                 repo.save_all(plan)
                 data = Path(temp_file.name).read_bytes()
                 Path(temp_file.name).unlink()
             else:
                 buffer = io.BytesIO()
                 logger.debug("Serializing to %s via repo_factory", format)
-                repo_factory(buffer, version, appschema, repo_type=format).save_all(
-                    plan
-                )
+                repo_factory(buffer, repo_type=format).save_all(plan)
                 data = buffer.getvalue()
 
             logger.info("Prepared download payload (%d bytes)", len(data))
@@ -533,22 +614,23 @@ async def plans(
 
         e.sender.props(add="loading")
         try:
-            await run.io_bound(settings.repo.delete_plan_by_id, plan_select.value)
+            await run.io_bound(settings.repo.delete_plan_by_id, plan_select.value["id"])
             logging.info("Plan %s deleted successfully", plan_select.value)
 
             options = plan_select.options
-            options.pop(plan_select.value)
+            options.remove(plan_select.value)
             plan_select.set_options(options)
 
         except Exception:
             logging.exception("Failed to delete plan %s", plan_select.value)
-            ui.notification.toast("Fehler beim Löschen des Plans.", severity="error")
+            ui.notify("Fehler beim Löschen des Plans.", type="negative")
 
         finally:
             e.sender.props(remove="loading")
 
     async def handle_load_plan(e: ClickEventArguments):
-        """
+        """Load a plan in QGIS.
+
         Handles loading a selected plan and sends the plan data to the QWebChannel handler.
         Fetches the selected plan, retrieves its associated 'bereiche', and passes the structured
         data to the web view. Logs key steps and errors, and provides user feedback on failure.
@@ -560,7 +642,7 @@ async def plans(
         e.sender.props(add="loading")
         try:
             logger.info(f"Attempting to load plan with ID: {plan_select.value}")
-            plan = await run.io_bound(settings.repo.get, plan_select.value)
+            plan = await run.io_bound(settings.repo.get, plan_select.value["id"])
             if plan is None:
                 logger.error(f"No plan found for ID: {plan_select.value}")
                 ui.notify("Fehler: Plan nicht gefunden", type="negative")
@@ -593,7 +675,7 @@ async def plans(
             plan_data = {
                 "plan_id": plan.id,
                 "plan_name": plan.name,
-                "appschema": plan.get_data_type(),
+                "appschema": plan.get_appschema(),
                 "version": plan.get_version(),
                 "plan_type": plan.get_name(),
                 "bereiche": bereiche,
@@ -617,7 +699,7 @@ async def plans(
     async def handle_import_plan(e):
         data = io.BytesIO(e.content.read())
         try:
-            repo = GMLRepository(data, data_type=appschema)
+            repo = GMLRepository(data)
         except Exception as e:
             print(e)
             return ui.notify("Fehler beim Lesen der Datei", type="negative")
@@ -643,10 +725,29 @@ async def plans(
         with ui.column(align_items="start").classes("w-full"):
             ui.label("Vorhandene Pläne").classes("text-h6")
             plan_select = (
-                ui.select({}, label="Plan auswählen", with_input=True)
-                .props("loading")
-                .classes("w-full")
+                ui.select([], label="Plan auswählen", with_input=True)
+                .props("loading :option-label='(opt) => opt.label.label'")
+                .classes("w-full dense")
+            )
+            plan_select.add_slot(
+                "option",
+                r"""
+                <q-item v-bind="props.itemProps">
+                    <q-item-section>
+                        <q-item-label>{{ props.opt.label.label }}</q-item-label>
+                        <q-item-label caption>{{ props.opt.label.updated.date }} {{ props.opt.label.updated.time }}</q-item-label>
+                    </q-item-section>
+                    <q-item-section side top>
+                        <q-item-label caption>{{ props.opt.label.appschema.name }}</q-item-label>
+                        <q-item-label caption>v{{ props.opt.label.appschema.version }}</q-item-label>
+                    </q-item-section>
+                </q-item>
+                """,
             )
+            with plan_select.add_slot("append"):
+                ui.badge().bind_text_from(
+                    plan_select, "options", backward=lambda x: len(x)
+                ).props("floating")
             with plan_select.add_slot("after"):
                 ui.button(icon="refresh", on_click=update_plan_select_options)
             ui.button(

{xmas_app-0.11.3 → xmas_app-0.12.0}/xmas_app/settings.py

@@ -14,7 +14,7 @@ class AppSchema(TypedDict):
 
 
 APPSCHEMAS: Dict[str, AppSchema] = {
-    "XPlanung": {"type": "xplan", "versions": ["5.4", "6.0"]},
+    "XPlanung": {"type": "xplan", "versions": ["5.4", "6.0", "6.1"]},
     "XTrasse": {"type": "xtrasse", "versions": ["2.0"]},
 }
 
@@ -55,7 +55,7 @@ class Settings(BaseSettings):
         "https://registry.gdi-de.org/codelist/de.xleitstelle.xplanung"
     )
     qgis_plugin_name: str = "XMAS-Plugin"
-    qgis_plugin_min_version: _VersionPydanticAnnotation = Version(major=0, minor=10)
+    qgis_plugin_min_version: _VersionPydanticAnnotation = Version(major=0, minor=13)
 
     model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
 
@@ -76,8 +76,6 @@ class Settings(BaseSettings):
         )
         self.repo = DBRepository(
             "postgresql://",
-            self.appschema_version,
-            self.appschema,
             srid=self.srid,
             with_views=True,
         )