Implement a custom form for a new plan

Author: LKajan

arho_feature_template/core/models.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qgis.core import QgsGeometry
+
+
+@dataclass
+class Regulation:
+    type_code: str
+    value_string: str | None
+    value_int: int | None
+    value_float: float | None
+    unit: str | None
+    id_: int | None = None
+
+
+@dataclass
+class RegulationGroup:
+    name: str
+    short_name: str | None
+    type_code: str
+    regulations: list[Regulation]
+    id_: int | None = None
+
+
+@dataclass
+class Plan:
+    name: str
+    description: str | None
+    plan_type_id: str
+    lifecycle_status_id: str
+    record_number: str | None
+    matter_management_identifier: str | None
+    permanent_plan_identifier: str | None
+    producers_plan_identifier: str | None
+    organisation_id: str | None = None
+    general_regulations: list[RegulationGroup] = field(default_factory=list)
+    geom: QgsGeometry | None = None
+    id_: int | None = None

arho_feature_template/core/plan_manager.py

@@ -2,80 +2,87 @@
 
 import json
 import logging
-
-from qgis.core import QgsExpressionContextUtils, QgsProject, QgsVectorLayer
+from typing import TYPE_CHECKING
+
+from qgis.core import (
+    QgsExpressionContextUtils,
+    QgsProject,
+    QgsVectorLayer,
+)
+from qgis.gui import QgsMapToolDigitizeFeature
 from qgis.PyQt.QtWidgets import QDialog, QMessageBox
 from qgis.utils import iface
 
 from arho_feature_template.core.lambda_service import LambdaService
 from arho_feature_template.gui.load_plan_dialog import LoadPlanDialog
+from arho_feature_template.gui.plan_attribure_form import PlanAttributeForm
 from arho_feature_template.gui.serialize_plan import SerializePlan
-from arho_feature_template.project.layers.plan_layers import PlanLayer, plan_layers
+from arho_feature_template.project.layers.plan_layers import PlanLayer, RegulationGroupLayer, plan_layers
 from arho_feature_template.utils.db_utils import get_existing_database_connection_names
-from arho_feature_template.utils.misc_utils import get_active_plan_id, handle_unsaved_changes
+from arho_feature_template.utils.misc_utils import (
+    get_active_plan_id,
+    handle_unsaved_changes,
+)
+
+if TYPE_CHECKING:
+    from qgis.core import QgsFeature
 
+    from arho_feature_template.core.models import Plan, RegulationGroup
 logger = logging.getLogger(__name__)
 
 
+class PlanDigitizeMapTool(QgsMapToolDigitizeFeature): ...
+
+
 class PlanManager:
     def __init__(self):
         self.json_plan_path = None
         self.json_plan_outline_path = None
 
+        self.digitize_map_tool = PlanDigitizeMapTool(iface.mapCanvas(), iface.cadDockWidget())
+        self.digitize_map_tool.digitizingCompleted.connect(self._plan_geom_digitized)
+
     def add_new_plan(self):
         """Initiate the process to add a new plan to the Kaava layer."""
+
+        self.previous_map_tool = iface.mapCanvas().mapTool()
+        self.previous_active_plan_id = get_active_plan_id()
+
         if not handle_unsaved_changes():
             return
 
         plan_layer = PlanLayer.get_from_project()
-
         if not plan_layer:
             return
+
         self.set_active_plan(None)
 
+        self.previously_editable = plan_layer.isEditable()
         if not plan_layer.isEditable():
             plan_layer.startEditing()
 
-        iface.setActiveLayer(plan_layer)
-        iface.actionAddFeature().trigger()
-
-        # Connect the featureAdded signal to a callback method
-        plan_layer.featureAdded.connect(self._feature_added)
+        self.digitize_map_tool.setLayer(plan_layer)
+        iface.mapCanvas().setMapTool(self.digitize_map_tool)
 
-    def _feature_added(self):
+    def _plan_geom_digitized(self, feature: QgsFeature):
         """Callback for when a new feature is added to the Kaava layer."""
         plan_layer = PlanLayer.get_from_project()
         if not plan_layer:
             return
 
-        # Disconnect the signal to avoid repeated triggers
-        plan_layer.featureAdded.disconnect(self._feature_added)
-
-        feature_ids_before_commit = plan_layer.allFeatureIds()
-
-        if plan_layer.isEditable():
-            if not plan_layer.commitChanges():
-                iface.messageBar().pushMessage("Error", "Failed to commit changes to the layer.", level=3)
-                return
-        else:
-            iface.messageBar().pushMessage("Error", "Layer is not editable.", level=3)
-            return
+        attribute_form = PlanAttributeForm()
+        if attribute_form.exec_():
+            plan_attributes = attribute_form.get_plan_attributes()
+            plan_attributes.geom = feature.geometry()
+            feature = save_plan(plan_attributes)
+            plan_layer = PlanLayer.get_from_project()
+            if plan_layer.isEditable():
+                plan_layer.commitChanges()
+            self.set_active_plan(feature["id"])
+            if self.previously_editable:
+                plan_layer.startEditing()
 
-        feature_ids_after_commit = plan_layer.allFeatureIds()
-        new_feature_id = next(
-            (fid for fid in feature_ids_after_commit if fid not in feature_ids_before_commit),
-            None,
-        )
-
-        if new_feature_id is not None:
-            new_feature = plan_layer.getFeature(new_feature_id)
-            if new_feature.isValid():
-                feature_id_value = new_feature["id"]
-                self.set_active_plan(feature_id_value)
-            else:
-                iface.messageBar().pushMessage("Error", "Invalid feature retrieved.", level=3)
-        else:
-            iface.messageBar().pushMessage("Error", "No new feature was added.", level=3)
+        iface.mapCanvas().setMapTool(self.previous_map_tool)
 
     def set_active_plan(self, plan_id: str | None):
         """Update the project layers based on the selected land use plan."""
@@ -147,4 +154,47 @@ def save_plan_jsons(self, plan_json, outline_json):
         with open(self.json_plan_outline_path, "w", encoding="utf-8") as outline_file:
             json.dump(outline_json, outline_file, ensure_ascii=False, indent=2)
 
-        QMessageBox.information(None, "Tallennus onnistui", "Kaava ja sen ulkoraja tallennettu onnistuneesti.")
+        QMessageBox.information(
+            None,
+            "Tallennus onnistui",
+            "Kaava ja sen ulkoraja tallennettu onnistuneesti.",
+        )
+
+
+def save_plan(plan_data: Plan) -> QgsFeature:
+    plan_layer = PlanLayer.get_from_project()
+    in_edit_mode = plan_layer.isEditable()
+    if not in_edit_mode:
+        plan_layer.startEditing()
+
+    edit_message = "Kaavan lisäys" if plan_data.id_ is None else "Kaavan muokkaus"
+    plan_layer.beginEditCommand(edit_message)
+
+    plan_data.organisation_id = "99e20d66-9730-4110-815f-5947d3f8abd3"
+    plan_feature = PlanLayer.feature_from_model(plan_data)
+
+    if plan_data.id_ is None:
+        plan_layer.addFeature(plan_feature)
+    else:
+        plan_layer.updateFeature(plan_feature)
+
+    plan_layer.endEditCommand()
+    plan_layer.commitChanges(stopEditing=False)
+
+    if plan_data.general_regulations:
+        for regulation_group in plan_data.general_regulations:
+            plan_id = plan_feature["id"]
+            regulation_group_feature = save_regulation_group(regulation_group, plan_id)
+            save_regulation_grop_assosiation(plan_id, regulation_group_feature["id"])
+
+    return plan_feature
+
+
+def save_regulation_group(regulation_group: RegulationGroup, plan_id: str) -> QgsFeature:
+    feature = RegulationGroupLayer.feature_from_model(regulation_group)
+    feature["plan_id"] = plan_id
+    return feature
+
+
+def save_regulation_grop_assosiation(plan_id: str, regulation_group_id: str):
+    pass

arho_feature_template/gui/code_combobox.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from qgis.PyQt.QtCore import Qt
+from qgis.PyQt.QtWidgets import QComboBox, QTreeWidget, QTreeWidgetItem
+
+from arho_feature_template.exceptions import LayerNotFoundError
+
+if TYPE_CHECKING:
+    from arho_feature_template.project.layers.code_layers import (
+        AbstractCodeLayer,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class CodeComboBox(QComboBox):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+    def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
+        try:
+            layer = layer_type.get_from_project()
+        except LayerNotFoundError:
+            logger.warning("Layer % not found.", layer_type.name)
+            return
+
+        self.addItem("NULL")
+        self.setItemData(0, None)
+
+        for i, feature in enumerate(layer.getFeatures(), start=1):
+            self.addItem(feature["name"]["fin"])
+            self.setItemData(i, feature["id"])
+
+    def value(self) -> str:
+        return self.currentData()
+
+
+class HierarchicalCodeComboBox(QComboBox):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.tree_widget = QTreeWidget()
+        self.tree_widget.setColumnCount(1)
+        self.tree_widget.setHeaderHidden(True)
+
+        self.setModel(self.tree_widget.model())
+        self.setView(self.tree_widget)
+
+        self.tree_widget.viewport().installEventFilter(self)
+
+    def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
+        try:
+            layer = layer_type.get_from_project()
+        except LayerNotFoundError:
+            logger.warning("Layer % not found.", layer_type.name)
+            return
+
+        null_item = QTreeWidgetItem(["NULL"])
+        self.tree_widget.addTopLevelItem(null_item)
+
+        codes = {feature["id"]: feature for feature in layer.getFeatures()}
+        items: dict[str, QTreeWidgetItem] = {}
+        for code_feature in sorted(codes.values(), key=lambda feature: feature["level"]):
+            item = QTreeWidgetItem()
+            items[code_feature["id"]] = item
+
+            text = code_feature["name"]["fin"]
+            item.setText(0, text)
+            description = code_feature["description"]["fin"]
+            item.setToolTip(0, description)
+            item.setData(0, Qt.UserRole, code_feature["id"])
+
+            if code_feature["level"] == 1:
+                self.tree_widget.addTopLevelItem(item)
+                item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
+            else:
+                parent = items[code_feature["parent_id"]]
+                parent.addChild(item)
+
+        self.tree_widget.expandAll()
+
+    def value(self) -> str:
+        item = self.tree_widget.selectedItems()[0]
+        return item.data(0, Qt.UserRole)

arho_feature_template/gui/plan_attribure_form.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from importlib import resources
+from typing import TYPE_CHECKING
+
+from qgis.PyQt import uic
+from qgis.PyQt.QtWidgets import QDialog
+
+from arho_feature_template.core.models import Plan
+from arho_feature_template.project.layers.code_layers import (
+    LifeCycleStatusLayer,
+    PlanTypeLayer,
+)
+
+if TYPE_CHECKING:
+    from qgis.PyQt.QtWidgets import QLineEdit, QTextEdit
+
+    from arho_feature_template.gui.code_combobox import CodeComboBox, HierarchicalCodeComboBox
+
+ui_path = resources.files(__package__) / "plan_attribute_form.ui"
+FormClass, _ = uic.loadUiType(ui_path)
+
+
+class PlanAttributeForm(QDialog, FormClass):  # type: ignore
+    permanent_identifier_line_edit: QLineEdit
+    name_line_edit: QLineEdit
+    description_text_edit: QTextEdit
+    plan_type_combo_box: HierarchicalCodeComboBox
+    lifecycle_status_combo_box: CodeComboBox
+    record_number_line_edit: QLineEdit
+    producers_plan_identifier_line_edit: QLineEdit
+    matter_management_identifier_line_edit: QLineEdit
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.setupUi(self)
+
+        self.plan_type_combo_box.populate_from_code_layer(PlanTypeLayer)
+        self.lifecycle_status_combo_box.populate_from_code_layer(LifeCycleStatusLayer)
+
+    def get_plan_attributes(self) -> Plan:
+        return Plan(
+            id_=None,
+            name=self.name_line_edit.text(),
+            description=self.description_text_edit.toPlainText() or None,
+            plan_type_id=self.plan_type_combo_box.value(),
+            permanent_plan_identifier=self.permanent_identifier_line_edit.text() or None,
+            record_number=self.record_number_line_edit.text() or None,
+            producers_plan_identifier=self.producers_plan_identifier_line_edit.text() or None,
+            matter_management_identifier=self.matter_management_identifier_line_edit.text() or None,
+            lifecycle_status_id=self.lifecycle_status_combo_box.value(),
+            general_regulations=[],
+        )