add regulation group type selection and short name, fix versined text 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
-    return feature
+def save_plan_feature(plan_feature: PlanFeature, plan_id: str | None = None):
+    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)
+
+
+# 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_group(regulation_group: RegulationGroup, plan_id: str | None = None):
+    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)
 
 
 def save_regulation_grop_assosiation(plan_id: str, regulation_group_id: str):
     pass
+
+
+def save_regulation(regulation: Regulation):
+    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",
+    )

arho_feature_template/gui/plan_regulation_group_widget.py

@@ -10,10 +10,13 @@
 
 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 PlanRegulationGroupType
 
 if TYPE_CHECKING:
     from qgis.PyQt.QtWidgets import QFrame, 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,23 @@ 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_plan_regulation_group: CodeComboBox
+        # 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)
+        self.type_of_plan_regulation_group.populate_from_code_layer(PlanRegulationGroupType)
+        self.type_of_plan_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.type_of_plan_regulation_group.setCurrentText(self.regulation_group_data.type_code)  # TODO: implement
         self.del_btn.setIcon(QgsApplication.getThemeIcon("mActionDeleteSelected.svg"))
         self.del_btn.clicked.connect(lambda: self.delete_signal.emit(self))
 
@@ -54,9 +66,9 @@ 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.type_of_plan_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_,