Present validation errors in a tree view

Author: LKajan

arho_feature_template/gui/validation_dock.py

@@ -5,34 +5,39 @@
 
 from qgis.gui import QgsDockWidget
 from qgis.PyQt import uic
-from qgis.PyQt.QtCore import QStringListModel
 from qgis.utils import iface
 
 from arho_feature_template.core.lambda_service import LambdaService
 from arho_feature_template.utils.misc_utils import get_active_plan_id
 
 if TYPE_CHECKING:
-    from qgis.PyQt.QtWidgets import QListView, QProgressBar
+    from qgis.PyQt.QtWidgets import QProgressBar, QPushButton
+
+    from arho_feature_template.gui.validation_tree_view import ValidationTreeView
 
 ui_path = resources.files(__package__) / "validation_dock.ui"
 DockClass, _ = uic.loadUiType(ui_path)
 
 
 class ValidationDock(QgsDockWidget, DockClass):  # type: ignore
-    error_list_view: QListView
     progress_bar: QProgressBar
+    validation_result_tree_view: ValidationTreeView
+    validate_button: QPushButton
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, parent=None):
+        super().__init__(parent)
         self.setupUi(self)
+
         self.lambda_service = LambdaService()
         self.lambda_service.validation_received.connect(self.list_validation_errors)
-        self.error_list_model = QStringListModel()
-        self.error_list_view.setModel(self.error_list_model)
         self.validate_button.clicked.connect(self.validate)
 
     def validate(self):
         """Handles the button press to trigger the validation process."""
+
+        # Clear the existing errors from the list view
+        self.validation_result_tree_view.clear_errors()
+
         active_plan_id = get_active_plan_id()
         if not active_plan_id:
             iface.messageBar().pushMessage("Virhe", "Ei aktiivista kaavaa.", level=3)
@@ -49,38 +54,33 @@ def list_validation_errors(self, validation_json):
         if not validation_json:
             iface.messageBar().pushMessage("Virhe", "Validaatio json puuttuu.", level=1)
             return
-        # Clear the existing errors from the list view
-        self.error_list_model.setStringList([])
-
-        new_errors = []
 
         if not validation_json:
             # If no errors or warnings, display a message and exit
             iface.messageBar().pushMessage("Virhe", "Ei virheitä havaittu.", level=1)
             return
 
         for error_data in validation_json.values():
-            if isinstance(error_data, dict):
-                # Get the errors for this plan
-                errors = error_data.get("errors", [])
-                for error in errors:
-                    rule_id = error.get("ruleId", "Tuntematon sääntö")
-                    message = error.get("message", "Ei viestiä")
-                    instance = error.get("instance", "Tuntematon instance")
-                    error_message = f"Validointivirhe - Sääntö: {rule_id}, Viesti: {message}, Instance: {instance}"
-                    new_errors.append(error_message)
-
-                # Get any warnings for this plan using list comprehension
-                warnings = error_data.get("warnings", [])
-                new_errors.extend([f"Varoitus: {warning}" for warning in warnings])
-
-        # If no errors or warnings, display a message
-        if not new_errors:
-            new_errors.append("Kaava on validi. Ei virheitä tai varoituksia havaittu.")
-            return
+            if not isinstance(error_data, dict):
+                continue
+            errors = error_data.get("errors", [])
+            for error in errors:
+                self.validation_result_tree_view.add_error(
+                    error.get("ruleId", ""),
+                    error.get("instance", ""),
+                    error.get("message", ""),
+                )
+
+            warnings = error_data.get("warnings", [])
+            for warning in warnings:
+                self.validation_result_tree_view.add_warning(
+                    warning.get("ruleId", ""),
+                    warning.get("instance", ""),
+                    warning.get("message", ""),
+                )
 
-        # Update the list view with the new errors and warnings
-        self.error_list_model.setStringList(new_errors)
         # Hide progress bar and re-enable the button
         self.progress_bar.setVisible(False)
         self.validate_button.setEnabled(True)
+        self.validation_result_tree_view.expandAll()
+        self.validation_result_tree_view.resizeColumnToContents(0)

arho_feature_template/gui/validation_dock.ui

@@ -1,41 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>ValidationDock</class>
  <widget class="QDockWidget" name="ValidationDock">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>269</width>
+    <height>362</height>
+   </rect>
+  </property>
   <property name="windowTitle">
    <string>Validaation tulokset</string>
   </property>
   <widget class="QWidget" name="dockWidgetContents">
    <layout class="QVBoxLayout" name="verticalLayout">
     <item>
-     <layout class="QHBoxLayout" name="buttonLayout">
-      <item>
-       <widget class="QPushButton" name="validate_button">
-        <property name="text">
-         <string>Validoi aktiivinen kaava</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
+     <widget class="QPushButton" name="validate_button">
+      <property name="text">
+       <string>Validoi aktiivinen kaava</string>
+      </property>
+     </widget>
     </item>
     <item>
      <widget class="QProgressBar" name="progress_bar">
+      <property name="visible">
+       <bool>false</bool>
+      </property>
       <property name="minimum">
        <number>0</number>
       </property>
       <property name="maximum">
        <number>0</number>
       </property>
-      <property name="visible">
-       <bool>false</bool>
-      </property>
      </widget>
     </item>
     <item>
-     <widget class="QListView" name="error_list_view"/>
+     <widget class="ValidationTreeView" name="validation_result_tree_view"/>
     </item>
    </layout>
   </widget>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ValidationTreeView</class>
+   <extends>QTreeView</extends>
+   <header>arho_feature_template.gui.validation_tree_view</header>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>

arho_feature_template/gui/validation_tree_view.py

@@ -0,0 +1,103 @@
+import re
+from textwrap import dedent
+from typing import cast
+
+from qgis.PyQt.QtGui import QStandardItem, QStandardItemModel
+from qgis.PyQt.QtWidgets import QTreeView
+
+category_map = {
+    "plan": "Kaava",
+    "geographicalArea": "Kaavan ulkoraja",
+    "planObjects": "Kaavakohteet",
+    "planRegulationGroups": "Kaavamääräysryhmät",
+}
+
+
+class ValidationItem(QStandardItem):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setEditable(False)
+
+
+class ValidationModel(QStandardItemModel):
+    ERROR_INDEX = 0
+    WARNING_INDEX = 1
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._parent_items: dict[str, ValidationItem] = {}
+
+        self.setColumnCount(3)
+        self.setHorizontalHeaderLabels(["", "Attribuutti", "Viesti"])
+
+        self.root = self.invisibleRootItem()
+        self.root.appendRow([ValidationItem("Virheet"), ValidationItem(""), ValidationItem("")])
+        self.root.appendRow([ValidationItem("Varoitukset"), ValidationItem(""), ValidationItem("")])
+
+    def clear(self):
+        self.item(self.ERROR_INDEX, 0).removeRows(0, self.item(self.ERROR_INDEX, 0).rowCount())
+        self.item(self.WARNING_INDEX, 0).removeRows(0, self.item(self.WARNING_INDEX, 0).rowCount())
+        self._parent_items = {}
+
+    def _add_item(self, root_index: int, error: str, instance: str, message: str) -> None:
+        current_parent = cast(ValidationItem, self.item(root_index, 0))
+        # replace '.planObjects[index]' with '.planObjects.index' so it is splittable by '.'
+        instance = re.sub(r"\.(?P<object>\w+)\[(?P<object_num>\d+)\]", r".\g<object>.\g<object_num>", instance)
+        path_parts = []
+        attribute_index = None
+        attribute = ""
+        for i, instance_part in enumerate(instance.split(".")):
+            if instance_part == "planObjects":
+                attribute_index = i + 2
+
+            path_parts.append(instance_part)
+            path = ".".join(path_parts)
+            if i == attribute_index:
+                attribute = instance_part
+                self._parent_items[path] = current_parent
+            elif path not in self._parent_items:
+                new_item = ValidationItem(category_map.get(instance_part, instance_part))
+                current_parent.appendRow([new_item, ValidationItem(""), ValidationItem("")])
+                self._parent_items[path] = new_item
+            current_parent = self._parent_items[path]
+
+        current_parent = self._parent_items[instance]
+        message_item = ValidationItem(message)
+        message_tooltip = dedent(
+            f"""\
+            <p>
+                <span style='font-weight:bold'>Virhe:</span><br/>
+                {error}
+            </p>
+            <p>
+                <span style='font-weight:bold'>Virheviesti:</span><br/>
+                {message}
+            </p>
+            """
+        )
+        message_item.setToolTip(message_tooltip)
+        current_parent.appendRow([ValidationItem(""), ValidationItem(attribute), message_item])
+
+    def add_error(self, error: str, instance: str, message: str) -> None:
+        self._add_item(self.ERROR_INDEX, error, instance, message)
+
+    def add_warning(self, error: str, instance: str, message: str) -> None:
+        self._add_item(self.WARNING_INDEX, error, instance, message)
+
+
+class ValidationTreeView(QTreeView):
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+
+        self._model = ValidationModel()
+        self.setModel(self._model)
+
+    def clear_errors(self) -> None:
+        self._model.clear()
+
+    def add_error(self, error: str, instance: str, message: str) -> None:
+        self._model.add_error(error, instance, message)
+
+    def add_warning(self, error: str, instance: str, message: str) -> None:
+        self._model.add_warning(error, instance, message)