add multiple verbal regulation types for regulation widget

Author: nmaarnio

arho_feature_template/core/models.py

@@ -435,7 +435,7 @@ class Regulation:
     files: list[str] = field(default_factory=list)
     theme: str | None = None
     topic_tag: str | None = None
-    verbal_regulation_type_id: str | None = None
+    verbal_regulation_type_ids: list[str] = field(default_factory=list)
     regulation_group_id: str | None = None
     id_: str | None = None
 

arho_feature_template/core/plan_manager.py

@@ -47,6 +47,7 @@
     PlanRegulationLayer,
     RegulationGroupAssociationLayer,
     RegulationGroupLayer,
+    TypeOfVerbalRegulationAssociationLayer,
     plan_layers,
 )
 from arho_feature_template.resources.libraries.feature_templates import feature_template_library_config_files
@@ -700,22 +701,57 @@ def save_regulation(regulation: Regulation) -> QgsFeature | None:
     regulation_feature = PlanRegulationLayer.feature_from_model(regulation)
     layer = PlanRegulationLayer.get_from_project()
 
+    editing = regulation.id_ is not None
     if not _save_feature(
         feature=regulation_feature,
         layer=layer,
         id_=regulation.id_,
-        edit_text="Kaavamääräyksen lisäys" if regulation.id_ is None else "Kaavamääräyksen muokkaus",
+        edit_text="Kaavamääräyksen muokkaus" if editing else "Kaavamääräyksen lisäys",
     ):
         iface.messageBar().pushCritical("", "Kaavamääräyksen tallentaminen epäonnistui.")
         return None
 
+    reg_id = regulation_feature["id"]
+
+    # Check for deleted verbal regulation types
+    if editing:
+        for association in TypeOfVerbalRegulationAssociationLayer.get_dangling_associations(
+            reg_id, regulation.verbal_regulation_type_ids
+        ):
+            if not _delete_feature(
+                association,
+                TypeOfVerbalRegulationAssociationLayer.get_from_project(),
+                "Sanallisen kaavamääräyksen lajin assosiaation poisto",
+            ):
+                iface.messageBar().pushCritical(
+                    "", "Sanallisen kaavamääräyksen lajin assosiaation poistaminen epäonnistui."
+                )
+
     for additional_information in regulation.additional_information:
-        additional_information.plan_regulation_id = regulation_feature["id"]
+        additional_information.plan_regulation_id = reg_id
         save_additional_information(additional_information)
 
+    for verbal_regulation_type_id in regulation.verbal_regulation_type_ids:
+        save_type_of_verbal_regulation_association(reg_id, verbal_regulation_type_id)
+
     return regulation_feature
 
 
+def save_type_of_verbal_regulation_association(regulation_id: str, verbal_regulation_type_id: str) -> bool:
+    if TypeOfVerbalRegulationAssociationLayer.association_exists(regulation_id, verbal_regulation_type_id):
+        return True
+    feature = TypeOfVerbalRegulationAssociationLayer.feature_from(regulation_id, verbal_regulation_type_id)
+    layer = TypeOfVerbalRegulationAssociationLayer.get_from_project()
+
+    if not _save_feature(
+        feature=feature, layer=layer, id_=None, edit_text="Sanallisen kaavamääräyksen lajin assosiaation lisäys"
+    ):
+        iface.messageBar().pushCritical("", "Sanallisen kaavamääräyksen lajin assosiaation tallentaminen epäonnistui.")
+        return False
+
+    return True
+
+
 def save_additional_information(additional_information: AdditionalInformation) -> QgsFeature | None:
     feature = AdditionalInformationLayer.feature_from_model(additional_information)
     layer = AdditionalInformationLayer.get_from_project()

arho_feature_template/gui/components/plan_regulation_widget.py

@@ -1,33 +1,39 @@
 from __future__ import annotations
 
 from importlib import resources
-from typing import TYPE_CHECKING
+from typing import cast
 
 from qgis.core import QgsApplication
 from qgis.gui import QgsFileWidget
 from qgis.PyQt import uic
 from qgis.PyQt.QtCore import Qt, pyqtSignal
-from qgis.PyQt.QtWidgets import QFormLayout, QFrame, QLabel, QLineEdit, QMenu, QToolButton, QVBoxLayout, QWidget
+from qgis.PyQt.QtWidgets import (
+    QFormLayout,
+    QFrame,
+    QLabel,
+    QLineEdit,
+    QMenu,
+    QPushButton,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
 
 from arho_feature_template.core.models import (
     AdditionalInformation,
     AdditionalInformationConfigLibrary,
     Regulation,
 )
 from arho_feature_template.gui.components.additional_information_widget import AdditionalInformationWidget
-from arho_feature_template.gui.components.code_combobox import HierarchicalCodeComboBox
 from arho_feature_template.gui.components.required_field_label import RequiredFieldLabel
 from arho_feature_template.gui.components.value_input_widgets import (
     IntegerInputWidget,
     SinglelineTextInputWidget,
+    TypeOfVerbalRegulationWidget,
     ValueWidgetManager,
 )
-from arho_feature_template.project.layers.code_layers import VerbalRegulationType
 from arho_feature_template.utils.misc_utils import LANGUAGE, get_layer_by_name
 
-if TYPE_CHECKING:
-    from qgis.PyQt.QtWidgets import QPushButton
-
 ui_path = resources.files(__package__) / "plan_regulation_widget.ui"
 FormClass, _ = uic.loadUiType(ui_path)
 
@@ -69,7 +75,7 @@ def __init__(self, regulation: Regulation, parent=None):
         self.file_widgets: list[QgsFileWidget] = []
         self.theme_widget: SinglelineTextInputWidget | None = None
         self.topic_tag_widget: SinglelineTextInputWidget | None = None
-        self.type_of_verbal_regulation_widget: HierarchicalCodeComboBox | None = None
+        self.type_of_verbal_regulation_widgets: list[TypeOfVerbalRegulationWidget] = []
 
         self.expanded = True
         self.additional_information_frame.hide()
@@ -88,11 +94,10 @@ def _init_widgets(self):
             self._add_widget(RequiredFieldLabel("Arvo"), self.value_widget_manager.value_widget)
 
         if self.config.regulation_code == "sanallinenMaarays":
-            self.type_of_verbal_regulation_widget = HierarchicalCodeComboBox()
-            self.type_of_verbal_regulation_widget.populate_from_code_layer(VerbalRegulationType)
-            self._add_widget(RequiredFieldLabel("Sanallisen määräyksen laji"), self.type_of_verbal_regulation_widget)
-            if self.regulation.verbal_regulation_type_id is not None:
-                self.type_of_verbal_regulation_widget.set_value(self.regulation.verbal_regulation_type_id)
+            for type_id in self.regulation.verbal_regulation_type_ids:
+                self._add_type_of_verbal_regulation(type_id)
+            if len(self.type_of_verbal_regulation_widgets) == 0:
+                self._add_type_of_verbal_regulation()
 
         # Additional information
         for info in self.regulation.additional_information:
@@ -197,7 +202,31 @@ def _add_theme(self, theme_name: str):
         self.theme_widget = SinglelineTextInputWidget(theme_name, False)
         self._add_widget(QLabel("Kaavoitusteema"), self.theme_widget)
 
+    def _add_type_of_verbal_regulation(self, type_id: str | None = None):
+        if len(self.type_of_verbal_regulation_widgets) == 0:
+            widget = TypeOfVerbalRegulationWidget(with_add_btn=True)
+            btn = cast(QPushButton, widget.add_btn)
+            btn.clicked.connect(self._add_type_of_verbal_regulation)
+        else:
+            widget = TypeOfVerbalRegulationWidget(with_del_btn=True)
+            btn = cast(QPushButton, widget.del_btn)
+            btn.clicked.connect(lambda: self._delete_type_of_verbal_regulation(widget))
+
+        if type_id:
+            widget.set_value(type_id)
+
+        self.type_of_verbal_regulation_widgets.append(widget)
+        self._add_widget(RequiredFieldLabel("Sanallisen määräyksen laji"), widget)
+
+    def _delete_type_of_verbal_regulation(self, widget_to_delete: TypeOfVerbalRegulationWidget):
+        self.type_of_verbal_regulation_widgets.remove(widget_to_delete)
+        for label, widget in self.widgets:
+            if widget is widget_to_delete:
+                widget.deleteLater()
+                label.deleteLater()
+
     def into_model(self) -> Regulation:
+        verbal_regulation_type_ids = [widget.get_value() for widget in self.type_of_verbal_regulation_widgets]
         return Regulation(
             config=self.config,
             value=self.value_widget_manager.into_model() if self.value_widget_manager else None,
@@ -206,8 +235,6 @@ def into_model(self) -> Regulation:
             files=[file.filePath() for file in self.file_widgets],
             theme=self.theme_widget.get_value() if self.theme_widget else None,
             topic_tag=self.topic_tag_widget.get_value() if self.topic_tag_widget else None,
-            verbal_regulation_type_id=self.type_of_verbal_regulation_widget.value()
-            if self.type_of_verbal_regulation_widget
-            else None,
+            verbal_regulation_type_ids=[value for value in verbal_regulation_type_ids if value is not None],
             id_=self.regulation.id_,
         )

arho_feature_template/gui/components/value_input_widgets.py

@@ -2,10 +2,22 @@
 
 import logging
 
+from qgis.core import QgsApplication
 from qgis.gui import QgsDoubleSpinBox, QgsSpinBox
-from qgis.PyQt.QtWidgets import QFormLayout, QHBoxLayout, QLabel, QLineEdit, QSizePolicy, QTextEdit, QWidget
+from qgis.PyQt.QtWidgets import (
+    QFormLayout,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QSizePolicy,
+    QTextEdit,
+    QWidget,
+)
 
 from arho_feature_template.core.models import AttributeValue, AttributeValueDataType
+from arho_feature_template.gui.components.code_combobox import HierarchicalCodeComboBox
+from arho_feature_template.project.layers.code_layers import VerbalRegulationType
 
 logger = logging.getLogger(__name__)
 
@@ -144,6 +156,44 @@ def get_value(self) -> tuple[str | None, str | None, str | None]:
         return (title if title else None, code_list if code_list else None, code_value if code_value else None)
 
 
+class TypeOfVerbalRegulationWidget(QWidget):
+    def __init__(
+        self,
+        with_add_btn: bool = False,  # noqa: FBT001, FBT002
+        with_del_btn: bool = False,  # noqa: FBT001, FBT002
+        parent=None,
+    ):
+        super().__init__(parent)
+
+        layout = QHBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.input_widget = HierarchicalCodeComboBox()
+        self.input_widget.populate_from_code_layer(VerbalRegulationType)
+        layout.addWidget(self.input_widget)
+
+        self.add_btn: QPushButton | None = None
+        if with_add_btn:
+            self.add_btn = QPushButton()
+            self.add_btn.setMaximumWidth(30)
+            self.add_btn.setIcon(QgsApplication.getThemeIcon("mActionAdd.svg"))
+            layout.addWidget(self.add_btn)
+
+        self.del_btn: QPushButton | None = None
+        if with_del_btn:
+            self.del_btn = QPushButton()
+            self.del_btn.setMaximumWidth(30)
+            self.del_btn.setIcon(QgsApplication.getThemeIcon("mActionDeleteSelected.svg"))
+            layout.addWidget(self.del_btn)
+
+        self.setLayout(layout)
+
+    def set_value(self, value: str | None):
+        self.input_widget.set_value(value)
+
+    def get_value(self) -> str | None:
+        return self.input_widget.value()
+
+
 class ValueWidgetManager:
     def __init__(self, value: AttributeValue | None, default_value: AttributeValue):
         if value is None:

arho_feature_template/project/layers/plan_layers.py

@@ -377,7 +377,6 @@ def feature_from_model(cls, model: Regulation) -> QgsFeature:
         feature["type_of_plan_regulation_id"] = model.config.id
 
         feature["subject_identifiers"] = model.topic_tag.split(",") if model.topic_tag else None
-        feature["type_of_verbal_plan_regulation_id"] = model.verbal_regulation_type_id
 
         update_feature_from_attribute_value_model(model.value, feature)
 
@@ -393,6 +392,7 @@ def model_from_feature(cls, feature: QgsFeature) -> Regulation:
         if not config:
             msg = f"Regulation config not found for {regulation_code}"
             raise ValueError(msg)
+
         return Regulation(
             config=config,
             value=attribute_value_model_from_feature(feature),
@@ -407,7 +407,9 @@ def model_from_feature(cls, feature: QgsFeature) -> Regulation:
             theme=None,
             topic_tag=None,
             regulation_group_id=feature["plan_regulation_group_id"],
-            verbal_regulation_type_id=feature["type_of_verbal_plan_regulation_id"],
+            verbal_regulation_type_ids=(
+                list(TypeOfVerbalRegulationAssociationLayer.get_verbal_type_ids_for_regulation(feature["id"]))
+            ),
             id_=feature["id"],
         )
 
@@ -425,6 +427,42 @@ def get_regulations_to_delete(cls, regulations: list[Regulation], group_id: str)
         ]
 
 
+class TypeOfVerbalRegulationAssociationLayer(AbstractPlanLayer):
+    name = "Sanallisten kaavamääräyksien lajien assosiaatiot"
+    filter_template = None
+
+    @classmethod
+    def feature_from(cls, regulation_id: str, type_of_verbal_regulation_id: str) -> QgsFeature | None:
+        layer = cls.get_from_project()
+
+        feature = QgsVectorLayerUtils.createFeature(layer)
+        feature["plan_regulation_id"] = regulation_id
+        feature["type_of_verbal_plan_regulation_id"] = type_of_verbal_regulation_id
+        return feature
+
+    @classmethod
+    def association_exists(cls, regulation_id: str, type_of_verbal_regulation_id: str) -> bool:
+        for feature in cls.get_features_by_attribute_value("plan_regulation_id", regulation_id):
+            if feature["type_of_verbal_plan_regulation_id"] == type_of_verbal_regulation_id:
+                return True
+        return False
+
+    @classmethod
+    def get_associations_for_regulation(cls, regulation_id: str) -> Generator[QgsFeature]:
+        return cls.get_features_by_attribute_value("plan_regulation_id", regulation_id)
+
+    @classmethod
+    def get_verbal_type_ids_for_regulation(cls, regulation_id: str) -> Generator[QgsFeature]:
+        return cls.get_attribute_values_by_another_attribute_value(
+            "type_of_verbal_plan_regulation_id", "plan_regulation_id", regulation_id
+        )
+
+    @classmethod
+    def get_dangling_associations(cls, regulation_id: str, updated_type_ids: list[str]) -> list[QgsFeature]:
+        associations = cls.get_associations_for_regulation(regulation_id)
+        return [assoc for assoc in associations if assoc["type_of_verbal_plan_regulation_id"] not in updated_type_ids]
+
+
 class PlanPropositionLayer(AbstractPlanLayer):
     name = "Kaavasuositus"
     filter_template = Template(