improvements and fixes to saving attribute data

- add regulation group type selection and short name
- fix versioned text input widget
- fix numeric input widget
- move data saving funcs to plan manager
- add placeholder mapping logic to target plan feature layer selection

Author: nmaarnio

arho_feature_template/core/feature_template_library.py

@@ -9,6 +9,7 @@
 from qgis.PyQt.QtGui import QStandardItem, QStandardItemModel
 from qgis.utils import iface
 
+from arho_feature_template.core.plan_manager import save_plan_feature
 from arho_feature_template.core.template_library_config import (
     FeatureTemplate,
     TemplateLibraryConfig,
@@ -157,8 +158,9 @@ def ask_for_feature_attributes(self, feature: QgsFeature) -> None:
         if not self.active_template:
             return
 
-        attribute_form = TemplateAttributeForm(self.active_template.config, feature)
-        attribute_form.exec_()
+        attribute_form = TemplateAttributeForm(self.active_template.config, feature.geometry())
+        if attribute_form.exec_():
+            save_plan_feature(attribute_form.model)
 
     def get_library_names(self) -> list[str]:
         return list(self.library_configs.keys())

arho_feature_template/core/models.py

@@ -10,7 +10,6 @@
 import yaml
 
 from arho_feature_template.exceptions import ConfigSyntaxError
-from arho_feature_template.project.layers.plan_layers import PlanFeatureLayer, PlanRegulationLayer, RegulationGroupLayer
 from arho_feature_template.qgis_plugin_tools.tools.resources import resources_path
 from arho_feature_template.utils.misc_utils import get_layer_by_name, iface
 
@@ -226,28 +225,10 @@ class Regulation:
     # value_number: Number | None
     # value_number_pair: tuple[Number, Number] | None
 
-    def save_data(self):
-        feature = PlanRegulationLayer.feature_from_model(self)
-        layer = PlanRegulationLayer.get_from_project()
-
-        if not layer.isEditable():
-            layer.startEditing()
-        layer.beginEditCommand("Kaavamääräyksen lisäys" if self.id_ is None else "Kaavamääräyksen muokkaus")
-
-        if self.id_ is None:
-            layer.addFeature(feature)
-        else:
-            layer.updateFeature(feature)
-
-        layer.endEditCommand()
-        layer.commitChanges(stopEditing=False)
-
-        # TODO: associations?
-
 
 @dataclass
 class RegulationGroup:
-    type_code: str
+    type_code_id: str | None
     name: str | None
     short_name: str | None
     color_code: str | None
@@ -280,68 +261,27 @@ def from_config_data(cls, data: dict) -> RegulationGroup:
             else:
                 iface.messageBar().pushWarning("", f"Could not find plan regulation {reg_code}!")
         return cls(
-            type_code="landUseRegulations",
+            type_code_id=data.get("type"),  # NOTE: Might need to convert type code into type code ID here when
+            # config file has type codes for regulation groups
             name=data.get("name"),
             short_name=data.get("short_name"),
             color_code=data.get("color_code"),
             regulations=regulations,
             id_=None,
         )
 
-    def save_data(self):
-        feature = RegulationGroupLayer.feature_from_model(self)
-        layer = RegulationGroupLayer.get_from_project()
-
-        if not layer.isEditable():
-            layer.startEditing()
-        layer.beginEditCommand("Kaavamääräysryhmän lisäys" if self.id_ is None else "Kaavamääräysryhmän muokkaus")
-
-        if self.id_ is None:
-            layer.addFeature(feature)
-        else:
-            layer.updateFeature(feature)
-
-        layer.endEditCommand()
-        layer.commitChanges(stopEditing=False)
-
-        if self.regulations:
-            for regulation in self.regulations:
-                regulation.regulation_group_id_ = feature["id"]  # Updating regulation group ID
-                regulation.save_data()
-
-        # TODO: associations?
-
-    # @classmethod
-    # def from_database(cls) -> RegulationGroup:
-    #     pass
-
 
 @dataclass
 class PlanFeature:
     geom: QgsGeometry
-    feature_layer_class: type[PlanFeatureLayer]
     type_of_underground_id: str
+    layer_name: str | None = None
     name: str | None = None
     description: str | None = None
+    regulation_groups: list[RegulationGroup] = field(default_factory=list)
     plan_id: int | None = None
     id_: int | None = None
 
-    def save_data(self):
-        feature = self.feature_layer_class.feature_from_model(self)
-        layer = self.feature_layer_class.get_from_project()
-
-        if not layer.isEditable():
-            layer.startEditing()
-        layer.beginEditCommand("Kaavakohteen lisäys" if self.id_ is None else "Kaavakohteen muokkaus")
-
-        if self.id_ is None:
-            layer.addFeature(feature)
-        else:
-            layer.updateFeature(feature)
-
-        layer.endEditCommand()
-        layer.commitChanges(stopEditing=False)
-
 
 @dataclass
 class Plan:

arho_feature_template/core/plan_manager.py

@@ -18,7 +18,18 @@
 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, RegulationGroupLayer, plan_layers
+from arho_feature_template.project.layers.plan_layers import (
+    LandUseAreaLayer,
+    LandUsePointLayer,
+    LineLayer,
+    OtherAreaLayer,
+    OtherPointLayer,
+    PlanFeatureLayer,
+    PlanLayer,
+    PlanRegulationLayer,
+    RegulationGroupLayer,
+    plan_layers,
+)
 from arho_feature_template.utils.db_utils import get_existing_database_connection_names
 from arho_feature_template.utils.misc_utils import (
     check_layer_changes,
@@ -29,7 +40,8 @@
 if TYPE_CHECKING:
     from qgis.core import QgsFeature
 
-    from arho_feature_template.core.models import Plan, RegulationGroup
+    from arho_feature_template.core.models import Plan, PlanFeature, Regulation, RegulationGroup
+
 logger = logging.getLogger(__name__)
 
 
@@ -179,6 +191,20 @@ def save_plan_jsons(self, plan_json, outline_json):
         )
 
 
+def _save_feature(feature: QgsFeature, layer: QgsVectorLayer, id_: int | None, edit_text: str = ""):
+    if not layer.isEditable():
+        layer.startEditing()
+    layer.beginEditCommand(edit_text)
+
+    if id_ is None:
+        layer.addFeature(feature)
+    else:
+        layer.updateFeature(feature)
+
+    layer.endEditCommand()
+    layer.commitChanges(stopEditing=False)
+
+
 def save_plan(plan_data: Plan) -> QgsFeature:
     plan_layer = PlanLayer.get_from_project()
     in_edit_mode = plan_layer.isEditable()
@@ -208,11 +234,76 @@ def save_plan(plan_data: Plan) -> QgsFeature:
     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
+def save_plan_feature(plan_feature: PlanFeature, plan_id: str | None = None) -> QgsFeature:
+    layer_name_to_class_map: dict[str, type[PlanFeatureLayer]] = {
+        LandUsePointLayer.name: LandUsePointLayer,
+        OtherAreaLayer.name: OtherAreaLayer,
+        OtherPointLayer.name: OtherPointLayer,
+        LandUseAreaLayer.name: LandUseAreaLayer,
+        LineLayer.name: LineLayer,
+    }
+
+    if not plan_feature.layer_name:
+        msg = "Cannot save plan feature without a target layer"
+        raise ValueError(msg)
+    layer_class = layer_name_to_class_map.get(plan_feature.layer_name)
+    if not layer_class:
+        msg = f"Could not find plan feature layer class for layer name {plan_feature.layer_name}"
+        raise ValueError(msg)
+    feature = layer_class.feature_from_model(plan_feature)
+    layer = layer_class.get_from_project()
+
+    if plan_id:
+        feature["plan_id"] = plan_id
+
+    _save_feature(
+        feature=feature,
+        layer=layer,
+        id_=plan_feature.id_,
+        edit_text="Kaavakohteen lisäys" if plan_feature.id_ is None else "Kaavakohteen muokkaus",
+    )
+
+    # Handle regulation groups
+    if plan_feature.regulation_groups:
+        for group in plan_feature.regulation_groups:
+            save_regulation_group(group)
+
+    return feature
+
+
+def save_regulation_group(regulation_group: RegulationGroup, plan_id: str | None = None) -> QgsFeature:
+    feature = RegulationGroupLayer.feature_from_model(regulation_group, plan_id)
+    layer = RegulationGroupLayer.get_from_project()
+
+    _save_feature(
+        feature=feature,
+        layer=layer,
+        id_=regulation_group.id_,
+        edit_text="Kaavamääräysryhmän lisäys" if regulation_group.id_ is None else "Kaavamääräysryhmän muokkaus",
+    )
+
+    # Handle regulations
+    if regulation_group.regulations:
+        for regulation in regulation_group.regulations:
+            regulation.regulation_group_id_ = feature["id"]  # Updating regulation group ID
+            save_regulation(regulation)
+
     return feature
 
 
 def save_regulation_grop_assosiation(plan_id: str, regulation_group_id: str):
     pass
+
+
+def save_regulation(regulation: Regulation) -> QgsFeature:
+    feature = PlanRegulationLayer.feature_from_model(regulation)
+    layer = PlanRegulationLayer.get_from_project()
+
+    _save_feature(
+        feature=feature,
+        layer=layer,
+        id_=regulation.id_,
+        edit_text="Kaavamääräyksen lisäys" if regulation.id_ is None else "Kaavamääräyksen muokkaus",
+    )
+
+    return feature

arho_feature_template/gui/plan_regulation_group_widget.py

@@ -10,9 +10,12 @@
 
 from arho_feature_template.core.models import Regulation, RegulationGroup
 from arho_feature_template.gui.plan_regulation_widget import RegulationWidget
+from arho_feature_template.project.layers.code_layers import PlanRegulationGroupTypeLayer
 
 if TYPE_CHECKING:
-    from qgis.PyQt.QtWidgets import QFrame, QLineEdit, QPushButton
+    from qgis.PyQt.QtWidgets import QFormLayout, QFrame, QLabel, QLineEdit, QPushButton
+
+    from arho_feature_template.gui.code_combobox import CodeComboBox
 
 ui_path = resources.files(__package__) / "plan_regulation_group_widget.ui"
 FormClass, _ = uic.loadUiType(ui_path)
@@ -30,14 +33,32 @@ def __init__(self, regulation_group_data: RegulationGroup):
         # TYPES
         self.frame: QFrame
         self.name: QLineEdit
+        self.short_name: QLineEdit
         self.del_btn: QPushButton
+        self.type_of_regulation_group_label: QLabel
+        self.type_of_regulation_group: CodeComboBox
+        self.regulation_group_details_layout: QFormLayout
+        # NOTE: Maybe user input is not needed and wanted for type of plan regulation group and it would be defined
+        # by the plan feature directly (and hidden from user)
 
         # INIT
         self.regulation_group_data = regulation_group_data
         self.regulation_widgets: list[RegulationWidget] = [
             self.add_regulation_widget(regulation) for regulation in self.regulation_group_data.regulations
         ]
-        self.name.setText(self.regulation_group_data.name)
+
+        # If regulation group type code is defined, delete selection for user
+        if regulation_group_data.type_code_id:
+            self.regulation_group_details_layout.removeWidget(self.type_of_regulation_group_label)
+            self.regulation_group_details_layout.removeWidget(self.type_of_regulation_group)
+            self.type_of_regulation_group_label.deleteLater()
+            self.type_of_regulation_group.deleteLater()
+        else:
+            self.type_of_regulation_group.populate_from_code_layer(PlanRegulationGroupTypeLayer)
+            self.type_of_regulation_group.removeItem(0)  # Remove NULL from combobox as underground data is required
+
+        self.name.setText(self.regulation_group_data.name if self.regulation_group_data.name else "")
+        self.short_name.setText(self.regulation_group_data.short_name if self.regulation_group_data.short_name else "")
         self.del_btn.setIcon(QgsApplication.getThemeIcon("mActionDeleteSelected.svg"))
         self.del_btn.clicked.connect(lambda: self.delete_signal.emit(self))
 
@@ -54,9 +75,11 @@ def delete_regulation_widget(self, regulation_widget: RegulationWidget):
 
     def into_model(self) -> RegulationGroup:
         return RegulationGroup(
-            type_code=self.regulation_group_data.type_code,
+            type_code_id=self.regulation_group_data.type_code_id
+            if self.regulation_group_data.type_code_id
+            else self.type_of_regulation_group.value(),
             name=self.name.text(),
-            short_name=self.regulation_group_data.short_name,
+            short_name=self.short_name.text(),
             color_code=self.regulation_group_data.color_code,
             regulations=[widget.into_model() for widget in self.regulation_widgets],
             id_=self.regulation_group_data.id_,