add editing for plan layer

- add toolbar action for editing plan attributes
- modify plan model to allow Nones for all attributes
- add set_value methods for CodeComboBoxes

Author: nmaarnio

arho_feature_template/core/models.py

@@ -331,14 +331,14 @@ def from_config_data(cls, data: dict) -> PlanFeature:
 
 @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
+    name: str | None = None
+    description: str | None = None
+    plan_type_id: str | None = None
+    lifecycle_status_id: str | None = None
+    record_number: str | None = None
+    matter_management_identifier: str | None = None
+    permanent_plan_identifier: str | None = None
+    producers_plan_identifier: str | None = None
     organisation_id: str | None = None
     general_regulations: list[RegulationGroup] = field(default_factory=list)
     geom: QgsGeometry | None = None

arho_feature_template/core/plan_manager.py

@@ -11,6 +11,7 @@
 from arho_feature_template.core.lambda_service import LambdaService
 from arho_feature_template.core.models import (
     FeatureTemplateLibrary,
+    Plan,
     PlanFeature,
     RegulationGroupCategory,
     RegulationGroupLibrary,
@@ -50,7 +51,7 @@
 if TYPE_CHECKING:
     from qgis.core import QgsFeature
 
-    from arho_feature_template.core.models import Plan, Regulation, RegulationGroup
+    from arho_feature_template.core.models import Regulation, RegulationGroup
 
 logger = logging.getLogger(__name__)
 
@@ -154,6 +155,22 @@ def add_new_plan(self):
         self.digitize_map_tool.setLayer(plan_layer)
         iface.mapCanvas().setMapTool(self.digitize_map_tool)
 
+    def edit_plan(self):
+        plan_layer = PlanLayer.get_from_project()
+        if not plan_layer:
+            return
+
+        active_plan_id = QgsExpressionContextUtils.projectScope(QgsProject.instance()).variable("active_plan_id")
+        feature = PlanLayer.get_feature_by_id(active_plan_id)
+        if feature is None:
+            iface.messageBar().pushWarning("", "No active/open plan found!")
+            return
+        plan_model = PlanLayer.model_from_feature(feature)
+
+        attribute_form = PlanAttributeForm(plan_model, self.regulation_group_libraries)
+        if attribute_form.exec_():
+            feature = save_plan(attribute_form.model)
+
     def add_new_plan_feature(self):
         if not handle_unsaved_changes():
             return
@@ -180,11 +197,10 @@ def _plan_geom_digitized(self, feature: QgsFeature):
         if not plan_layer:
             return
 
-        attribute_form = PlanAttributeForm(self.regulation_group_libraries)
+        plan_model = Plan(geom=feature.geometry())
+        attribute_form = PlanAttributeForm(plan_model, self.regulation_group_libraries)
         if attribute_form.exec_():
-            plan_attributes = attribute_form.get_plan_attributes()
-            plan_attributes.geom = feature.geometry()
-            feature = save_plan(plan_attributes)
+            feature = save_plan(attribute_form.model)
             plan_to_be_activated = feature["id"]
         else:
             plan_to_be_activated = self.previous_active_plan_id
@@ -379,33 +395,37 @@ def _delete_feature(feature: QgsFeature, layer: QgsVectorLayer, delete_text: str
     layer.commitChanges(stopEditing=False)
 
 
-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)
+def save_plan(plan: Plan) -> QgsFeature:
+    feature = PlanLayer.feature_from_model(plan)
+    layer = PlanLayer.get_from_project()
 
-    if plan_data.id_ is None:
-        plan_layer.addFeature(plan_feature)
-    else:
-        plan_layer.updateFeature(plan_feature)
+    editing = plan.id_ is not None
+    _save_feature(
+        feature=feature,
+        layer=layer,
+        id_=plan.id_,
+        edit_text="Kaavan muokkaus" if editing else "Kaavan luominen",
+    )
 
-    plan_layer.endEditCommand()
-    plan_layer.commitChanges(stopEditing=False)
+    # Check for deleted general regulations
+    if editing:
+        for association in RegulationGroupAssociationLayer.get_dangling_associations(
+            plan.general_regulations, feature["id"], PlanLayer.name
+        ):
+            _delete_feature(
+                association,
+                RegulationGroupAssociationLayer.get_from_project(),
+                "Kaavamääräysryhmän assosiaation poisto",
+            )
 
-    if plan_data.general_regulations:
-        for regulation_group in plan_data.general_regulations:
-            plan_id = plan_feature["id"]
+    # Save general regulations
+    if plan.general_regulations:
+        for regulation_group in plan.general_regulations:
+            plan_id = feature["id"]
             regulation_group_feature = save_regulation_group(regulation_group, plan_id)
             save_regulation_group_association(regulation_group_feature["id"], PlanLayer.name, plan_id)
 
-    return plan_feature
+    return feature
 
 
 def save_plan_feature(plan_feature: PlanFeature, plan_id: str | None = None) -> QgsFeature:

arho_feature_template/gui/components/code_combobox.py

@@ -39,6 +39,17 @@ def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
     def value(self) -> str:
         return self.currentData()
 
+    def set_value(self, value: str | None) -> None:
+        if value is None:
+            self.setCurrentIndex(0)
+            return
+
+        index = self.findData(value)
+        if index != -1:
+            self.setCurrentIndex(index)
+        else:
+            self.setCurrentIndex(0)  # Set NULL if not found
+
 
 class HierarchicalCodeComboBox(QComboBox):
     def __init__(self, parent=None):
@@ -56,8 +67,8 @@ def __init__(self, parent=None):
         null_item = QTreeWidgetItem(["NULL"])
         null_item.setData(0, Qt.UserRole, None)
         self.tree_widget.addTopLevelItem(null_item)
-        null_index = self.tree_widget.indexFromItem(null_item)
-        self.tree_widget.setCurrentIndex(null_index)
+        self.null_index = self.tree_widget.indexFromItem(null_item)
+        self.tree_widget.setCurrentIndex(self.null_index)
 
     def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
         try:
@@ -90,3 +101,30 @@ def populate_from_code_layer(self, layer_type: type[AbstractCodeLayer]) -> None:
     def value(self) -> str:
         item = self.tree_widget.selectedItems()[0]
         return item.data(0, Qt.UserRole)
+
+    def set_value(self, value: str | None) -> None:
+        # NOTE: Does not work fully currently
+
+        def find_item_recursive(item: QTreeWidgetItem, value: str) -> QTreeWidgetItem:
+            if item.data(0, Qt.UserRole) == value:
+                return item
+            for i in range(item.childCount()):
+                found_item = find_item_recursive(item.child(i), value)
+                if found_item:
+                    return found_item
+            return None
+
+        if value is None:
+            self.setCurrentIndex(0)
+            return
+
+        for i in range(self.count()):
+            found_item = find_item_recursive(self.tree_widget.topLevelItem(i), value)
+            if found_item:
+                idx = self.tree_widget.indexFromItem(found_item)
+                self.setRootModelIndex(idx.parent())
+                self.setCurrentIndex(idx.row())
+                self.setRootModelIndex(self.null_index.parent())
+                return
+
+        self.setCurrentIndex(0)  # Set combobox index to NULL

arho_feature_template/gui/dialogs/plan_attribute_form.py

@@ -51,15 +51,33 @@ class PlanAttributeForm(QDialog, FormClass):  # type: ignore
 
     button_box: QDialogButtonBox
 
-    def __init__(self, regulation_group_libraries: list[RegulationGroupLibrary], parent=None):
+    def __init__(self, plan: Plan, regulation_group_libraries: list[RegulationGroupLibrary], parent=None):
         super().__init__(parent)
 
         self.setupUi(self)
 
+        self.plan = plan
+
         self.plan_type_combo_box.populate_from_code_layer(PlanTypeLayer)
         self.lifecycle_status_combo_box.populate_from_code_layer(LifeCycleStatusLayer)
         self.organisation_combo_box.populate_from_code_layer(OrganisationLayer)
 
+        self.plan_type_combo_box.set_value(plan.plan_type_id)
+        self.lifecycle_status_combo_box.set_value(plan.lifecycle_status_id)
+        self.organisation_combo_box.set_value(plan.organisation_id)
+        self.name_line_edit.setText(plan.name if plan.name else "")
+        self.description_text_edit.setText(plan.description if plan.description else "")
+        self.permanent_identifier_line_edit.setText(
+            plan.permanent_plan_identifier if plan.permanent_plan_identifier else ""
+        )
+        self.record_number_line_edit.setText(plan.record_number if plan.record_number else "")
+        self.producers_plan_identifier_line_edit.setText(
+            plan.producers_plan_identifier if plan.producers_plan_identifier else ""
+        )
+        self.matter_management_identifier_line_edit.setText(
+            plan.matter_management_identifier if plan.matter_management_identifier else ""
+        )
+
         self.name_line_edit.textChanged.connect(self._check_required_fields)
         self.organisation_combo_box.currentIndexChanged.connect(self._check_required_fields)
         self.plan_type_combo_box.currentIndexChanged.connect(self._check_required_fields)
@@ -74,7 +92,13 @@ def __init__(self, regulation_group_libraries: list[RegulationGroupLibrary], par
 
         self.regulation_groups_selection_widget.tree.itemDoubleClicked.connect(self.add_selected_plan_regulation_group)
 
+        for regulation_group in plan.general_regulations:
+            self.add_plan_regulation_group(regulation_group)
+
         self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
+        self.button_box.accepted.connect(self._on_ok_clicked)
+
+        self._check_required_fields()
 
     def _check_required_fields(self) -> None:
         ok_button = self.button_box.button(QDialogButtonBox.Ok)
@@ -129,9 +153,9 @@ def init_plan_regulation_group_library(self, library: RegulationGroupLibrary):
 
     # ---
 
-    def get_plan_attributes(self) -> Plan:
+    def into_model(self) -> Plan:
         return Plan(
-            id_=None,
+            id_=self.plan.id_,
             name=self.name_line_edit.text(),
             description=self.description_text_edit.toPlainText() or None,
             plan_type_id=self.plan_type_combo_box.value(),
@@ -142,4 +166,9 @@ def get_plan_attributes(self) -> Plan:
             matter_management_identifier=self.matter_management_identifier_line_edit.text() or None,
             lifecycle_status_id=self.lifecycle_status_combo_box.value(),
             general_regulations=[reg_group_widget.into_model() for reg_group_widget in self.regulation_group_widgets],
+            geom=self.plan.geom,
         )
+
+    def _on_ok_clicked(self):
+        self.model = self.into_model()
+        self.accept()

arho_feature_template/plugin.py

@@ -167,6 +167,16 @@ def initGui(self) -> None:  # noqa N802
             status_tip="Lataa/avaa kaava",
         )
 
+        self.edit_land_use_plan_action = self.add_action(
+            text="Muokkaa kaavaa",
+            # icon=QgsApplication.getThemeIcon("mActionFileOpen.svg"),
+            triggered_callback=self.plan_manager.edit_plan,
+            parent=iface.mainWindow(),
+            add_to_menu=True,
+            add_to_toolbar=True,
+            status_tip="Muokkaa aktiivisen kaavan tietoja",
+        )
+
         self.new_feature_dock_action = self.add_action(
             text="Luo kaavakohde",
             icon=QgsApplication.getThemeIcon("mIconFieldGeometry.svg"),

arho_feature_template/project/layers/plan_layers.py

@@ -5,21 +5,18 @@
 from numbers import Number
 from string import Template
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import Any, ClassVar
 
 from qgis.core import NULL, QgsExpressionContextUtils, QgsFeature, QgsProject, QgsVectorLayerUtils
 from qgis.utils import iface
 
-from arho_feature_template.core.models import PlanFeature, Regulation, RegulationGroup, RegulationLibrary
+from arho_feature_template.core.models import Plan, PlanFeature, Regulation, RegulationGroup, RegulationLibrary
 from arho_feature_template.exceptions import FeatureNotFoundError, LayerEditableError
 from arho_feature_template.project.layers import AbstractLayer
 from arho_feature_template.project.layers.code_layers import PlanRegulationTypeLayer
 
 logger = logging.getLogger(__name__)
 
-if TYPE_CHECKING:
-    from arho_feature_template.core.models import Plan
-
 
 class AbstractPlanLayer(AbstractLayer):
     filter_template: ClassVar[Template]
@@ -65,13 +62,12 @@ class PlanLayer(AbstractPlanLayer):
 
     @classmethod
     def feature_from_model(cls, model: Plan) -> QgsFeature:
-        layer = cls.get_from_project()
+        feature = cls.initialize_feature_from_model(model)
 
         if not model.geom:
             message = "Plan must have a geometry to be added to the layer"
             raise ValueError(message)
 
-        feature = QgsVectorLayerUtils.createFeature(layer, model.geom)
         feature["name"] = {"fin": model.name}
         feature["description"] = {"fin": model.description}
         feature["permanent_plan_identifier"] = model.permanent_plan_identifier
@@ -84,6 +80,26 @@ def feature_from_model(cls, model: Plan) -> QgsFeature:
 
         return feature
 
+    @classmethod
+    def model_from_feature(cls, feature: QgsFeature) -> Plan:
+        return Plan(
+            geom=feature.geometry(),
+            name=feature["name"]["fin"],
+            description=feature["description"]["fin"],
+            permanent_plan_identifier=feature["permanent_plan_identifier"],
+            record_number=feature["record_number"],
+            producers_plan_identifier=feature["producers_plan_identifier"],
+            matter_management_identifier=feature["matter_management_identifier"],
+            plan_type_id=feature["plan_type_id"],
+            lifecycle_status_id=feature["lifecycle_status_id"],
+            organisation_id=feature["organisation_id"],
+            general_regulations=[
+                RegulationGroupLayer.model_from_feature(RegulationGroupLayer.get_feature_by_id(group_id))
+                for group_id in RegulationGroupAssociationLayer.get_group_ids_for_feature(feature["id"], cls.name)
+            ],
+            id_=feature["id"],
+        )
+
 
 class PlanFeatureLayer(AbstractPlanLayer):
     @classmethod