xmas-app 0.15.1__tar.gz → 0.15.2__tar.gz

{xmas_app-0.15.1 → xmas_app-0.15.2}/PKG-INFO

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

{xmas_app-0.15.1 → xmas_app-0.15.2}/pyproject.toml

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

{xmas_app-0.15.1 → xmas_app-0.15.2}/xmas_app/form.py

@@ -1,9 +1,10 @@
+import logging
 import re
 from datetime import date
 from functools import partial
 
 import orjson
-from nicegui import ElementFilter, app, run, ui
+from nicegui import ElementFilter, app, events, run, ui
 from nicegui.binding import BindableProperty
 from pydantic import AnyUrl, ValidationError
 from sqlalchemy import select
@@ -17,6 +18,8 @@ from xmas_app.components.label import LabelWithDescription
 from xmas_app.settings import get_settings
 from xmas_app.util.codelist import get_codelist_options
 
+logger = logging.getLogger("xmas_app")
+
 
 class ModelForm:
     """A dynamic form builder for XPlan features using NiceGUI.
@@ -50,6 +53,35 @@ class ModelForm:
         self.header = header
         self.rendered = False
         self.editable = False
+        self.validation_errors = []
+        self.validation_notification = None
+        ui.on("showValidationDetails", self._show_validation_details)
+
+    async def _show_validation_details(self, _: events.GenericEventArguments):
+        def _go_to_property_row(key: str):
+            validation_dialog.close()
+            for element in ElementFilter(marker=["property_row", key]).not_within(
+                marker="sub_form"
+            ):
+                ui.navigate.to(element)
+                break
+
+        if self.parent:
+            with self.parent, ui.dialog() as validation_dialog, ui.card():
+                ui.label("Validierungsfehler").classes("text-bold")
+                with ui.list():
+                    for error in self.validation_errors:
+                        name = error["loc"][0]
+                        with ui.item(
+                            on_click=lambda key=name: _go_to_property_row(key)
+                        ).tooltip(f"Klicken um zum Attribut {name!r} zu springen"):
+                            with ui.item_section().props("avatar"):
+                                ui.icon("error", color="negative")
+                            with ui.item_section():
+                                ui.item_label(name)
+                                ui.item_label(error["msg"]).props("caption")
+            await validation_dialog
+            validation_dialog.delete()
 
     async def _filter_properties(self):
         """Filter property rows in the UI based on the selected filter option."""
@@ -231,17 +263,35 @@ class ModelForm:
         ):
             setattr(feature, geom_field, geom)
         try:
-            return self.model.model_validate(feature)
-        except ValidationError:
-            if not getattr(self, "validation_error_notification", False):
-                self.validation_error_notification = True
-                ui.notification(
-                    "Fehlende Pflichtattribute",
+            model_instance = self.model.model_validate(feature)
+            if self.validation_notification:
+                self.validation_notification.dismiss()
+            return model_instance
+        except ValidationError as e:
+            logger.debug(
+                "validation error for feature %r with id %r:\n    %s",
+                self.featuretype,
+                self.feature.id,
+                "\n    ".join(str(error) for error in e.errors()),
+            )
+            self.validation_errors = e.errors()
+            if not self.validation_notification:
+                self.validation_notification = ui.notification(
+                    "Validierungsfehler",
                     type="negative",
                     position="bottom",
-                    on_dismiss=lambda: setattr(
-                        self, "validation_error_notification", False
-                    ),
+                    timeout=None,
+                    on_dismiss=lambda: setattr(self, "validation_notification", None),
+                    actions=[
+                        {
+                            "icon": "description",
+                            ":handler": "() => {emitEvent('showValidationDetails')}",
+                            "noDismiss": True,
+                        },
+                        {
+                            "icon": "close",
+                        },
+                    ],
                 )
 
     async def _set_stylesheetId_and_schriftinhalt(self) -> None:
@@ -723,7 +773,10 @@ class ModelForm:
                         case "BasicType":
                             match prop_info["typename"]:
                                 case "CharacterString":
-                                    if key == "art":
+                                    if (
+                                        key == "art"
+                                        and "stylesheetId" in model.model_fields.keys()
+                                    ):
                                         options = {}
                                         if existing := getattr(bind_obj, key, None):
                                             options.update(
@@ -1019,40 +1072,115 @@ class ModelForm:
                         case "Temporal":
                             match prop_info["typename"]:
                                 case "Date":
+                                    property_row.tooltip("Eingabe über Kalender")
                                     with (
                                         ui.input(
-                                            prop_info["typename"],
-                                            validation={
-                                                "ungültiges Datum": self.validate_date
-                                            }
+                                            label=prop_info["typename"],
+                                            validation=None
                                             if prop_info["nullable"]
                                             else {
                                                 "Pflichtfeld": lambda x: x,
-                                                "ungültiges Datum": self.validate_date,
                                             },
                                         )
-                                        .bind_value(
+                                        .bind_value_from(
                                             bind_obj,
                                             key,
-                                            backward=lambda x: None if not x else x,
+                                            backward=lambda x: ", ".join(x)
+                                            if isinstance(x, list)
+                                            else x,
                                         )
                                         .classes("w-full q-pa-none q-gutter-none")
+                                        .style("pointer-events: none;")
                                         .props(
-                                            "stack-label square filled dense mask='####-##-##'"
-                                        ) as date
+                                            """
+                                            stack-label
+                                            square
+                                            dense
+                                            filled
+                                            """
+                                        ) as date_viewer
                                     ):
-                                        with ui.menu().props("no-parent-event") as menu:
-                                            ui.date(on_change=menu.close).bind_value(
-                                                date
-                                            ).bind_enabled_from(self, "editable")
-                                        with date.add_slot("append"):
+                                        with ui.dialog() as menu:
+                                            date_picker = (
+                                                ui.date()
+                                                .bind_value(
+                                                    bind_obj,
+                                                    key,
+                                                    forward=lambda x: sorted(x)
+                                                    if isinstance(x, list)
+                                                    else x or None,
+                                                )
+                                                .bind_enabled_from(self, "editable")
+                                                .classes("w-96")
+                                                .props(
+                                                    f"""
+                                                    title='{key}'
+                                                    :locale='{
+                                                        orjson.dumps(
+                                                            {
+                                                                "daysShort": [
+                                                                    "So",
+                                                                    "Mo",
+                                                                    "Di",
+                                                                    "Mi",
+                                                                    "Do",
+                                                                    "Fr",
+                                                                    "Sa",
+                                                                ],
+                                                                "months": [
+                                                                    "Januar",
+                                                                    "Februar",
+                                                                    "März",
+                                                                    "April",
+                                                                    "Mai",
+                                                                    "Juni",
+                                                                    "Juli",
+                                                                    "August",
+                                                                    "September",
+                                                                    "Oktober",
+                                                                    "November",
+                                                                    "Dezember",
+                                                                ],
+                                                                "monthsShort": [
+                                                                    "Jan",
+                                                                    "Feb",
+                                                                    "Mär",
+                                                                    "Apr",
+                                                                    "Mai",
+                                                                    "Jun",
+                                                                    "Jul",
+                                                                    "Aug",
+                                                                    "Sep",
+                                                                    "Okt",
+                                                                    "Nov",
+                                                                    "Dez",
+                                                                ],
+                                                            }
+                                                        ).decode()
+                                                    }'
+                                                    """
+                                                )
+                                            )
+                                            if prop_info["list"]:
+                                                date_picker.props(
+                                                    "multiple subtitle='Liste von Datumsangaben'"
+                                                )
+                                            else:
+                                                date_picker.props(
+                                                    "subtitle='Datumsangabe'"
+                                                )
+                                                date_picker.on_value_change(menu.close)
+                                        with date_viewer.add_slot("append"):
                                             ui.icon("edit_calendar").on(
                                                 "click", menu.open
-                                            ).classes("cursor-pointer")
-                                        date.bind_enabled_from(
+                                            ).classes("cursor-pointer").style(
+                                                "pointer-events: auto;"
+                                            )
+                                        date_viewer.bind_enabled_from(
                                             self,
                                             "editable",
-                                            backward=lambda v, input=date: input.props(
+                                            backward=lambda v,
+                                            input=date_viewer: input.props(
                                                 **{
                                                     "add"
                                                     if not v
@@ -1060,41 +1188,53 @@ class ModelForm:
                                                 }
                                             ),
                                         )
-                                        date.validate()
+                                        date_viewer.validate()
                                 case "TM_Duration":
-                                    input = (
-                                        ui.number(
-                                            prop_info["typename"],
-                                            value=default,
-                                            suffix="Tage",
-                                            step=1,
-                                            precision=0,
-                                            format="%d",
-                                            validation=None
-                                            if prop_info["nullable"]
-                                            else {
-                                                "Pflichtfeld": lambda x: x is not None
-                                            },
-                                        )
-                                        .bind_value(
-                                            bind_obj,
-                                            key,
-                                            forward=lambda x: x * 86400 if x else None,
-                                            backward=lambda x: x / 86400 if x else None,
+                                    if not prop_info["list"]:
+                                        input = (
+                                            ui.number(
+                                                prop_info["typename"],
+                                                value=default,
+                                                suffix="Tage",
+                                                step=1,
+                                                precision=0,
+                                                format="%d",
+                                                validation=None
+                                                if prop_info["nullable"]
+                                                else {
+                                                    "Pflichtfeld": lambda x: x
+                                                    is not None
+                                                },
+                                            )
+                                            .bind_value(
+                                                bind_obj,
+                                                key,
+                                                forward=lambda x: x * 86400
+                                                if x
+                                                else None,
+                                                backward=lambda x: x / 86400
+                                                if x
+                                                else None,
+                                            )
+                                            .props(
+                                                "stack-label clearable square filled dense"
+                                            )
+                                            .classes("w-full q-pa-none q-gutter-none")
                                         )
-                                        .props(
-                                            "stack-label clearable square filled dense"
+                                        input.bind_enabled_from(
+                                            self,
+                                            "editable",
+                                            backward=lambda v, input=input: input.props(
+                                                **{
+                                                    "add"
+                                                    if not v
+                                                    else "remove": "readonly"
+                                                }
+                                            ),
                                         )
-                                        .classes("w-full q-pa-none q-gutter-none")
-                                    )
-                                    input.bind_enabled_from(
-                                        self,
-                                        "editable",
-                                        backward=lambda v, input=input: input.props(
-                                            **{"add" if not v else "remove": "readonly"}
-                                        ),
-                                    )
-                                    input.validate()
+                                        input.validate()
+                                    else:
+                                        ui.label("TODO")
                                 case _:
                                     ui.label("TODO Temporal")
                         case "DataType":

{xmas_app-0.15.1 → xmas_app-0.15.2}/xmas_app/pages/planmanager.py

@@ -341,6 +341,13 @@ class PlanManagerPage(BasePage):
                 "align": "left",
                 "sortable": True,
             },
+            {
+                "name": "name",
+                "label": "Name",
+                "field": "name",
+                "align": "left",
+                "sortable": True,
+            },
         ]
         table = (
             ui.table(
@@ -357,6 +364,8 @@ class PlanManagerPage(BasePage):
                 dense
                 virtual-scroll
                 bordered
+                visible-columns=['label','featuretype','appschema','updated']
+                :filter-method="(rows, terms) => rows.filter(row => ['featuretype','appschema','updated','name'].some(key => String(row[key] ?? '').toLowerCase().includes((terms || '').toLowerCase())))"
             """
             )
             .classes("w-full h-full")

{xmas_app-0.15.1 → xmas_app-0.15.2}/xmas_app/util/db.py

@@ -54,7 +54,7 @@ def get_db_plans() -> list[dict]:
                 plan_data = {
                     "id": str(feature.id),
                     "name": plan_name,
-                    "label": f"{plan_name[:15]}{'...' if len(plan_name) > 15 else ''}",
+                    "label": f"{plan_name[:20]}{'...' if len(plan_name) > 20 else ''}",
                     "featuretype": feature.featuretype,
                     "appschema": f"{feature.appschema.upper()} {feature.version}",
                     "updated": f"{updated_local.strftime('%d.%m.%Y %H:%M')}",