(WIP) refactor plan regulations and plan regulations groups

Author: nmaarnio

arho_feature_template/core/models.py

@@ -1,28 +1,91 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from qgis.core import QgsGeometry
+    from numbers import Number
+    from qgis.core import QgsGeometry, QgsFeature
+
+
+class ValueType(Enum):
+    DECIMAL = "desimaali"
+    POSITIVE_DECIMAL = "positiivinen desimaali"
+    POSITIVE_INTEGER = "positiivinen kokonaisluku"
+    POSITIVE_INTEGER_RANGE = "positiivinen kokonaisluku arvoväli"
+    VERSIONED_TEXT = "kieliversioitu teksti"
+
+
+@dataclass
+class RegulationConfig:
+    """
+    Describes plan regulation type.
+    
+    Initialized from DB/QGIS layer and extended with data from a config file.
+    """
+    id: str
+    regulation_code: str
+    name: str
+    description: str
+    status: str
+    level: int
+    parent_id: str | None
+    child_regulations: list[RegulationConfig] = field(default_factory=list)
+
+    # Data from config file
+    category_only: bool = False
+    value_type: ValueType | None = None
+    unit: str | None = None
+
+    # NOTE: Perhaps this ("model_from_feature") should be method of PlanTypeLayer class?
+    @classmethod
+    def from_feature(cls, feature: QgsFeature, language: str = "fin") -> RegulationConfig:
+        """
+        Initialize PlanRegulationConfig from QgsFeature.
+
+        Child regulations, value type ,category only and unit need to be set separately.
+        """
+        return cls(
+            id=feature["id"],
+            regulation_code=feature["value"],
+            name=feature["name"][language],
+            description=feature["description"][language],
+            status=feature["status"],
+            level=feature["level"],
+            parent_id=feature["parent_id"],
+        )
+
+    def add_to_dictionary(self, dictionary: dict[str, RegulationConfig]):
+        """Add child regulations to dictionary too."""
+        dictionary[self.regulation_code] = self
+        for regulation in self.child_regulations:
+            regulation.add_to_dictionary(dictionary)
 
 
 @dataclass
 class Regulation:
-    type_code: str
-    value_string: str | None
-    value_int: int | None
-    value_float: float | None
-    unit: str | None
+    config: RegulationConfig  # includes regulation_code and unit among other needed data for saving feature
+    value: str | Number | tuple[int, int] | None = None
+    regulation_number: int | None
+    additional_information: dict[str, str | Number | None]
+    files: list[str] = []
+    theme: str | None = None
+    topic_tag: str | None = None
     id_: int | None = None
+    # value_string: str | None
+    # value_number: Number | None
+    # value_number_pair: tuple[Number, Number] | None
 
 
 @dataclass
 class RegulationGroup:
-    name: str
-    short_name: str | None
     type_code: str
-    regulations: list[Regulation]
+    name: str | None
+    short_name: str | None
+    color_code: str | None
+    letter_code: str | None
+    regulations: list[Regulation] | list[RegulationConfig]
     id_: int | None = None
 
 

arho_feature_template/core/plan_regulation_config.py

@@ -199,24 +199,24 @@ def add_to_dictionary(self, dictionary: dict[str, PlanRegulationConfig]):
             regulation.add_to_dictionary(dictionary)
 
 
-@dataclass
-class PlanRegulationDefinition:
-    """Associates a PlanRegulationConfig with an optional default value and additional data."""
-
-    regulation_config: PlanRegulationConfig
-    default_value: str | Number | list[int] | None
-    additional_information: list[
-        dict[str, str | Number | None]
-    ]  # NOTE: Correct typing for additional information values?
-    regulation_number: int | None
-    attached_files: list[Path]
-
-    @classmethod
-    def from_dict(cls, data: dict) -> PlanRegulationDefinition:
-        return cls(
-            regulation_config=data["config"],
-            default_value=data.get("default_value"),
-            additional_information=data.get("additional_information", []),
-            regulation_number=data.get("regulation_number"),
-            attached_files=data.get("attached_files", []),
-        )
+# @dataclass
+# class PlanRegulationDefinition:
+#     """Associates a PlanRegulationConfig with an optional default value and additional data."""
+
+#     regulation_config: PlanRegulationConfig
+#     default_value: str | Number | list[int] | None
+#     additional_information: list[
+#         dict[str, str | Number | None]
+#     ]  # NOTE: Correct typing for additional information values?
+#     regulation_number: int | None
+#     attached_files: list[Path]
+
+#     @classmethod
+#     def from_dict(cls, data: dict) -> PlanRegulationDefinition:
+#         return cls(
+#             regulation_config=data["config"],
+#             default_value=data.get("default_value"),
+#             additional_information=data.get("additional_information", []),
+#             regulation_number=data.get("regulation_number"),
+#             attached_files=data.get("attached_files", []),
+#         )

arho_feature_template/gui/plan_regulation_group_widget.py

@@ -8,51 +8,74 @@
 from qgis.PyQt.QtCore import pyqtSignal
 from qgis.PyQt.QtWidgets import QWidget
 
-from arho_feature_template.gui.plan_regulation_widget import PlanRegulationWidget
+from arho_feature_template.gui.plan_regulation_widget import RegulationWidget
+from arho_feature_template.core.models import Regulation, RegulationGroup
+from arho_feature_template.project.layers.plan_layers import RegulationGroupLayer
 
 if TYPE_CHECKING:
     from qgis.PyQt.QtWidgets import QFrame, QLineEdit, QPushButton
 
-    from arho_feature_template.core.plan_regulation_config import PlanRegulationDefinition
-    from arho_feature_template.core.plan_regulation_group_config import PlanRegulationGroupDefinition
-
 ui_path = resources.files(__package__) / "plan_regulation_group_widget.ui"
 FormClass, _ = uic.loadUiType(ui_path)
 
 
-class PlanRegulationGroupWidget(QWidget, FormClass):  # type: ignore
+class RegulationGroupWidget(QWidget, FormClass):  # type: ignore
     """A widget representation of a plan regulation group."""
 
     delete_signal = pyqtSignal(QWidget)
 
-    def __init__(self, group_definition: PlanRegulationGroupDefinition):
+    def __init__(self, regulation_group_data: RegulationGroup):
         super().__init__()
         self.setupUi(self)
 
         # TYPES
         self.frame: QFrame
-        self.heading: QLineEdit
+        self.name: QLineEdit  # "heading"
         self.del_btn: QPushButton
 
         # INIT
-        self.group_definition = group_definition
-        self.layer = "plan_regulation_group"
-
-        self.heading.setText(self.group_definition.name)
-        self.init_buttons()
-        for plan_regulation_definition in self.group_definition.plan_regulations:
-            _ = self.add_plan_regulation_widget(plan_regulation_definition)
-
-    def init_buttons(self):
+        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.del_btn.setIcon(QgsApplication.getThemeIcon("mActionDeleteSelected.svg"))
         self.del_btn.clicked.connect(lambda: self.delete_signal.emit(self))
-
-    def add_plan_regulation_widget(self, definition: PlanRegulationDefinition) -> PlanRegulationWidget:
-        widget = PlanRegulationWidget.from_definition(definition=definition, parent=self.frame)
-        widget.delete_signal.connect(self.delete_plan_regulation_widget)
+ 
+    def add_regulation_widget(self, regulation: Regulation) -> RegulationWidget:
+        widget = RegulationWidget(regulation_data=regulation, parent=self.frame)
+        widget.delete_signal.connect(self.delete_regulation_widget)
         self.frame.layout().addWidget(widget)
         return widget
 
-    def delete_plan_regulation_widget(self, plan_regulation_widget: PlanRegulationWidget):
-        self.frame.layout().removeWidget(plan_regulation_widget)
-        plan_regulation_widget.deleteLater()
+    def delete_regulation_widget(self, regulation_widget: RegulationWidget):
+        self.frame.layout().removeWidget(regulation_widget)
+        self.regulation_widgets.remove(regulation_widget)
+        regulation_widget.deleteLater()
+
+    def into_model(self, id: str) -> RegulationGroup:
+        return RegulationGroup(
+            type_code=self.regulation_group_data.type_code,
+            name=self.name.text(),
+            short_name=self.regulation_group_data.short_name,
+            color_code=self.regulation_group_data.color_code,
+            letter_code=self.regulation_group_data.letter_code,
+            plan_regulations=[widget.save_data(id) for widget in self.regulation_widgets],
+            id_=id
+        )
+
+    def save_data(self):
+        if not self.regulation_group_data.id_:
+            new_feature = True
+            id_ = "new_id_here"  # TODO
+        else:
+            new_feature = False
+            id_ = self.regulation_group_data.id_
+
+        model = self.into_model(id_)
+        regulation_feature = RegulationGroupLayer.feature_from_model(model)
+        layer = RegulationGroupLayer.get_from_project()
+        if new_feature:
+            layer.addFeature(regulation_feature)
+        else:
+            layer.updateFeature(regulation_feature)

arho_feature_template/gui/plan_regulation_group_widget.ui

@@ -51,7 +51,7 @@
          </widget>
         </item>
         <item>
-         <widget class="QLineEdit" name="heading">
+         <widget class="QLineEdit" name="name">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
             <horstretch>0</horstretch>

arho_feature_template/gui/plan_regulation_input_widgets.py

@@ -0,0 +1,79 @@
+from qgis.PyQt.QtWidgets import QWidget, QLineEdit, QTextEdit, QLineEdit, QSizePolicy
+from qgis.gui import QgsSpinBox, QgsDoubleSpinBox
+
+from numbers import Number
+
+
+def initialize_numeric_input_widget(
+    widget: QgsSpinBox | QgsDoubleSpinBox, default_value: Number | None, unit: str | None, positive: bool
+):
+    if unit:
+        widget.setSuffix(f" {unit}")
+
+    if positive:
+        widget.setMinimum(0)
+    else:
+        widget.setMinimum(-9999)
+
+    if default_value:
+        widget.setValue(default_value)
+
+    widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+
+
+def initialize_text_input_widget(widget: QTextEdit | QLineEdit, default_value: str | None, editable: bool):
+    if default_value:
+        widget.setText(str(default_value))
+
+    if not editable:
+        widget.setReadOnly(True)
+
+
+class DecimalInputWidget(QgsSpinBox):
+    def __init__(self, default_value: float | None = None, unit: str | None = None, positive: bool = False):
+        super().__init__()
+        self.unit = unit
+        initialize_numeric_input_widget(self, default_value, unit, positive)
+
+    def get_value(self) -> float:
+        return self.value()
+
+
+class IntegerInputWidget(QgsDoubleSpinBox):
+    def __init__(self, default_value: int | None = None, unit: str | None = None, positive: bool = False):
+        super().__init__()
+        self.unit = unit
+        initialize_numeric_input_widget(self, default_value, unit, positive)
+
+    def get_value(self) -> int:
+        return self.value()
+
+
+class IntegerRangeInputWidget(QWidget):
+    def __init__(
+        self, default_value: tuple[int, int] | None = None, unit: str | None = None, positive: bool = False
+    ):
+        super().__init__()
+        self.min_widget = IntegerInputWidget(default_value[0], unit, positive)
+        self.max_widget = IntegerInputWidget(default_value[1], unit, positive)
+
+    def get_value(self) -> tuple[int, int]:
+        return (self.min_widget.get_value(), self.max_widget.get_value())
+
+
+class SinglelineTextInputWidget(QLineEdit):
+    def __init__(self, default_value: str | None = None, editable: bool = False):
+        super().__init__()
+        initialize_text_input_widget(self, default_value, editable)
+
+    def get_value(self) -> str | None:
+        return self.text() if self.text() else None
+
+
+class MultilineTextInputWidget(QTextEdit):
+    def __init__(self, default_value: str | None = None, editable: bool = True):
+        super().__init__()
+        initialize_text_input_widget(self, default_value, editable)
+
+    def get_value(self) -> str | None:
+        return self.toPlainText() if self.toPlainText() else None