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

@@ -152,7 +152,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,78 @@
+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 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 and warnings."""
+        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
+
+        # Update the list view with the new errors and warnings
+        self.error_list_model.setStringList(new_errors)

arho_feature_template/gui/validation_dock.ui

@@ -0,0 +1,28 @@
+<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>
+     <layout class="QHBoxLayout" name="buttonLayout">
+      <item>
+       <widget class="QPushButton" name="validate_button">
+        <property name="text">
+         <string>Validoi aktiivinen kaava</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </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,11 @@ def initGui(self) -> None:  # noqa N802
 
         iface.mapCanvas().mapToolSet.connect(self.templater.digitize_map_tool.deactivate)
 
+        self.validation_dock = ValidationDock()
+        iface.addDockWidget(Qt.RightDockWidgetArea, self.validation_dock)
+
+        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 +177,15 @@ def initGui(self) -> None:  # noqa N802
             add_to_toolbar=True,
         )
 
+        self.validation_dock_action = self.add_action(
+            text="Validointi virheet",
+            icon=QgsApplication.getThemeIcon("mActionEditNodesItem.svg"),
+            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"),
@@ -224,13 +239,20 @@ def unload(self) -> None:
         teardown_logger(Plugin.name)
 
         self.templater.template_dock.close()
+        self.validation_dock.close()
 
     def dock_visibility_changed(self, visible: bool) -> None:  # noqa: FBT001
         self.template_dock_action.setChecked(visible)
 
     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_()