Added plan validation

Added new dock widget for validating plans.
It includes a button to validate plan, and a list view for listing each validation error.

Refactored LambdaService so that it can handle each type of lambda call.

Author: Mtk112

arho_feature_template/core/lambda_service.py

@@ -11,15 +11,24 @@
 
 class LambdaService(QObject):
     jsons_received = pyqtSignal(dict, dict)
+    validation_received = pyqtSignal(dict)
+    ActionAttribute = QNetworkRequest.User + 1
+    ACTION_VALIDATE_PLANS = "validate_plans"
+    ACTION_GET_PLANS = "get_plans"
 
     def __init__(self):
-        super().__init__()  # Ensure QObject initialization
-        # Init network manager
+        super().__init__()
         self.network_manager = QNetworkAccessManager()
+        self.network_manager.finished.connect(self._handle_reply)
 
-    def send_request(self, action: str, plan_id: str):
-        """Sends a request to the lambda function."""
+    def serialize_plan(self, plan_id: str):
+        self._send_request(action=self.ACTION_GET_PLANS, plan_id=plan_id)
+
+    def validate_plan(self, plan_id: str):
+        self._send_request(action=self.ACTION_VALIDATE_PLANS, plan_id=plan_id)
 
+    def _send_request(self, action: str, plan_id: str):
+        """Sends a request to the lambda function."""
         proxy_host, proxy_port, self.lambda_url = get_settings()
 
         # Initialize or reset proxy each time a request is sent. Incase settings have changed.
@@ -35,16 +44,48 @@ def send_request(self, action: str, plan_id: str):
 
         payload = {"action": action, "plan_uuid": plan_id}
         payload_bytes = QByteArray(json.dumps(payload).encode("utf-8"))
-
         request = QNetworkRequest(QUrl(self.lambda_url))
+        request.setAttribute(LambdaService.ActionAttribute, action)
         request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
+        self.network_manager.post(request, payload_bytes)
+
+    def _handle_reply(self, reply: QNetworkReply):
+        action = reply.request().attribute(LambdaService.ActionAttribute)
+        if action == self.ACTION_GET_PLANS:
+            self._process_json_reply(reply)
+        elif action == self.ACTION_VALIDATE_PLANS:
+            self._process_validation_reply(reply)
 
-        reply = self.network_manager.post(request, payload_bytes)
+    def _process_validation_reply(self, reply: QNetworkReply):
+        """Processes the validation reply from the lambda and emits a signal."""
+        if reply.error() != QNetworkReply.NoError:
+            error_string = reply.errorString()
+            QMessageBox.critical(None, "API Error", f"Lambda call failed: {error_string}")
+            reply.deleteLater()
+            return
 
-        # Connect reply signal to handle the response
-        reply.finished.connect(lambda: self._process_reply(reply))
+        try:
+            response_data = reply.readAll().data().decode("utf-8")
+            response_json = json.loads(response_data)
+
+            # Determine if the proxy is set up.
+            if hasattr(self, "network_manager") and self.network_manager.proxy().type() == QNetworkProxy.Socks5Proxy:
+                # If proxy has been set up, retrieve 'ryhti_responses' directly
+                validation_errors = response_json.get("ryhti_responses", {})
+            else:
+                # If proxy has not been set up (using local docker lambda), the response includes 'body'.
+                # In this case we need to retrieve 'ryhti_responses' from 'body' first.
+                body = response_json.get("body", {})
+                validation_errors = body.get("ryhti_responses", {})
+
+            self.validation_received.emit(validation_errors)
+
+        except json.JSONDecodeError as e:
+            QMessageBox.critical(None, "JSON Error", f"Failed to parse response JSON: {e}")
+        finally:
+            reply.deleteLater()
 
-    def _process_reply(self, reply: QNetworkReply):
+    def _process_json_reply(self, reply: QNetworkReply):
         """Processes the reply from the lambda and emits signal."""
         plan_id = get_active_plan_id()
 

arho_feature_template/core/plan_manager.py

@@ -117,10 +117,10 @@ def _feature_added(self):
 
         if plan_layer.isEditable():
             if not plan_layer.commitChanges():
-                iface.messageBar().pushMessage("Error", "Failed to commit changes to the layer.", level=3)
+                iface.messageBar().pushMessage("Virhe", "Muutosten tallennus tasolle epäonnistui.", level=3)
                 return
         else:
-            iface.messageBar().pushMessage("Error", "Layer is not editable.", level=3)
+            iface.messageBar().pushMessage("Virhe", "Taso ei ole muokattavissa.", level=3)
             return
 
         feature_ids_after_commit = plan_layer.allFeatureIds()
@@ -135,9 +135,9 @@ def _feature_added(self):
                 feature_id_value = new_feature["id"]
                 self.set_active_plan(feature_id_value)
             else:
-                iface.messageBar().pushMessage("Error", "Invalid feature retrieved.", level=3)
+                iface.messageBar().pushMessage("Virhe", "Virheellinen kohde (feature).", level=3)
         else:
-            iface.messageBar().pushMessage("Error", "No new feature was added.", level=3)
+            iface.messageBar().pushMessage("Virhe", "Uutta kohdetta (feature) ei lisätty.", level=3)
 
     def set_active_plan(self, plan_id: str | None):
         """Update the project layers based on the selected land use plan."""
@@ -201,7 +201,7 @@ def get_plan_json(self):
 
             self.lambda_service = LambdaService()
             self.lambda_service.jsons_received.connect(self.save_plan_jsons)
-            self.lambda_service.send_request("get_plans", plan_id)
+            self.lambda_service.serialize_plan(plan_id)
 
     def save_plan_jsons(self, plan_json, outline_json):
         """This slot saves the plan and outline JSONs to files."""

arho_feature_template/gui/validation_dock.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from importlib import resources
+from typing import TYPE_CHECKING
+
+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
+
+ui_path = resources.files(__package__) / "validation_dock.ui"
+DockClass, _ = uic.loadUiType(ui_path)
+
+
+class ValidationDock(QgsDockWidget, DockClass):  # type: ignore
+    error_list_view: QListView
+
+    def __init__(self):
+        super().__init__()
+        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 update_errors(self, errors: list[str]):
+        """Updates the list view with the provided validation errors."""
+        self.error_list_model.setStringList(errors)
+
+    def validate(self):
+        """Handles the button press to trigger the validation process."""
+        active_plan_id = get_active_plan_id()
+        if not active_plan_id:
+            iface.messageBar().pushMessage("Virhe", "Ei aktiivista kaavaa.", level=3)
+            return
+
+        self.lambda_service.validate_plan(active_plan_id)
+
+    def list_validation_errors(self, validation_json):
+        """Slot for listing validation errors."""
+        if not validation_json:
+            iface.messageBar().pushMessage("Virhe", "Ei virheitä havaittu.", level=1)
+            return
+
+        current_errors = self.error_list_model.stringList()
+        new_errors = []
+
+        for plan_id, error_data in validation_json.items():
+            if isinstance(error_data, str):
+                new_errors.append(f"Validaatio epäonnistui Kaavalle id {plan_id}: {error_data}")
+            elif isinstance(error_data, dict):
+                title = error_data.get("title", "Tuntematon virhe")
+                status = error_data.get("status", "Tuntematon status")
+                detail = error_data.get("detail", "Tietoja ei saatavilla")
+                new_errors.append(f"Virhe kaavalla: {plan_id} - {title} ({status}): {detail}")
+
+                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 instanssi")
+                    error_message = f"  Sääntö: {rule_id}, Viesti: {message}, Tapaus/instanssi: {instance}"
+                    new_errors.append(error_message)
+
+                warnings = error_data.get("warnings", [])
+                new_errors.extend([f"Varoitus: {warning}" for warning in warnings])
+
+        # Append the new errors to the existing list
+        current_errors.extend(new_errors)
+
+        # Update the model with the combined list of errors
+        self.error_list_model.setStringList(current_errors)

arho_feature_template/gui/validation_dock.ui

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ValidationDock</class>
+ <widget class="QDockWidget" name="ValidationDock">
+  <property name="windowTitle">
+   <string>Validaation tulokset</string>
+  </property>
+  <widget class="QWidget" name="dockWidgetContents">
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <item>
+     <widget class="QPushButton" name="validate_button">
+      <property name="text">
+       <string>Vahvista aktiivinen kaava</string>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <widget class="QListView" name="error_list_view"/>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

arho_feature_template/plugin.py

@@ -12,6 +12,7 @@
 from arho_feature_template.core.plan_manager import PlanManager
 from arho_feature_template.gui.new_plan_regulation_group_form import NewPlanRegulationGroupForm
 from arho_feature_template.gui.plugin_settings import PluginSettings
+from arho_feature_template.gui.validation_dock import ValidationDock
 from arho_feature_template.qgis_plugin_tools.tools.custom_logging import setup_logger, teardown_logger
 from arho_feature_template.qgis_plugin_tools.tools.i18n import setup_translation
 from arho_feature_template.qgis_plugin_tools.tools.resources import plugin_name
@@ -137,6 +138,13 @@ def initGui(self) -> None:  # noqa N802
 
         iface.mapCanvas().mapToolSet.connect(self.templater.digitize_map_tool.deactivate)
 
+        # Instantiate and add the Validation Dock Widget
+        self.validation_dock = ValidationDock()
+        iface.addDockWidget(Qt.BottomDockWidgetArea, self.validation_dock)
+
+        # Connect visibilityChanged signal to sync toggle action
+        self.validation_dock.visibilityChanged.connect(self.validation_dock_visibility_changed)
+
         # icons to consider:
         # icon=QgsApplication.getThemeIcon("mActionStreamingDigitize.svg"),
         # icon=QgsApplication.getThemeIcon("mIconGeometryCollectionLayer.svg"),
@@ -171,6 +179,17 @@ def initGui(self) -> None:  # noqa N802
             add_to_toolbar=True,
         )
 
+        # Add the toggle action for the validation dock widget
+        self.validation_dock_action = self.add_action(
+            "",
+            "Validointi virheet",
+            None,
+            toggled_callback=self.toggle_validation_dock,
+            checkable=True,
+            add_to_menu=True,
+            add_to_toolbar=True,
+        )
+
         self.new_plan_regulation_group = self.add_action(
             text="Luo kaavamääräysryhmä",
             icon=QgsApplication.getThemeIcon("mActionAddManualTable.svg"),
@@ -231,6 +250,12 @@ def dock_visibility_changed(self, visible: bool) -> None:  # noqa: FBT001
     def toggle_template_dock(self, show: bool) -> None:  # noqa: FBT001
         self.templater.template_dock.setUserVisible(show)
 
+    def validation_dock_visibility_changed(self, visible: bool) -> None:  # noqa: FBT001
+        self.validation_dock_action.setChecked(visible)
+
+    def toggle_validation_dock(self, show: bool) -> None:  # noqa: FBT001
+        self.validation_dock.setUserVisible(show)
+
     def open_plan_regulation_group_form(self):
         self.new_plan_regulation_group_dialog = NewPlanRegulationGroupForm()
         self.new_plan_regulation_group_dialog.exec_()