Merge pull request #90 from GispoCoding/new-plan-form

Kaavan lomekkeen yksinkertaistaminen

Author: LKajan

arho_feature_template/core/feature_template_library.py

@@ -20,7 +20,7 @@
 from arho_feature_template.gui.template_attribute_form import TemplateAttributeForm
 from arho_feature_template.gui.template_dock import TemplateLibraryDock
 from arho_feature_template.resources.template_libraries import library_config_files
-from arho_feature_template.utils.project_utils import get_layer_from_project
+from arho_feature_template.utils.project_utils import get_vector_layer_from_project
 
 if TYPE_CHECKING:
     from qgis.core import QgsFeature, QgsVectorLayer
@@ -38,7 +38,7 @@ def is_valid(self) -> bool:
 
         Checks if the layer and attributes defined in the template acutally exists"""
         try:
-            get_layer_from_project(self.config.feature.layer)  # TODO: check child features recursively
+            get_vector_layer_from_project(self.config.feature.layer)  # TODO: check child features recursively
         except (LayerNotFoundError, LayerNotVectorTypeError):
             return False
         else:
@@ -88,7 +88,7 @@ def on_template_item_clicked(self, index):
             return
 
         try:
-            layer = get_layer_from_project(item.config.feature.layer)
+            layer = get_vector_layer_from_project(item.config.feature.layer)
         except (LayerNotFoundError, LayerNotVectorTypeError):
             logger.exception("Failed to activate template")
             return
@@ -160,7 +160,7 @@ def ask_for_feature_attributes(self, feature: QgsFeature) -> None:
         attribute_form = TemplateAttributeForm(self.active_template.config)
 
         if attribute_form.exec_():
-            layer = get_layer_from_project(self.active_template.config.feature.layer)
+            layer = get_vector_layer_from_project(self.active_template.config.feature.layer)
             # Save the feature
             attribute_form.set_feature_attributes(feature)
 

arho_feature_template/core/models.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qgis.core import QgsGeometry
+
+
+@dataclass
+class Regulation:
+    type_code: str
+    value_string: str | None
+    value_int: int | None
+    value_float: float | None
+    unit: str | None
+    id_: int | None = None
+
+
+@dataclass
+class RegulationGroup:
+    name: str
+    short_name: str | None
+    type_code: str
+    regulations: list[Regulation]
+    id_: int | None = None
+
+
+@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
+    organisation_id: str | None = None
+    general_regulations: list[RegulationGroup] = field(default_factory=list)
+    geom: QgsGeometry | None = None
+    id_: int | None = None

arho_feature_template/core/plan_manager.py

@@ -2,161 +2,112 @@
 
 import json
 import logging
-from string import Template
-from textwrap import dedent
-
-from qgis.core import QgsExpressionContextUtils, QgsProject, QgsVectorLayer
+from typing import TYPE_CHECKING
+
+from qgis.core import (
+    QgsExpressionContextUtils,
+    QgsProject,
+    QgsVectorLayer,
+)
+from qgis.gui import QgsMapToolDigitizeFeature
 from qgis.PyQt.QtWidgets import QDialog, QMessageBox
 from qgis.utils import iface
 
 from arho_feature_template.core.lambda_service import LambdaService
+from arho_feature_template.exceptions import UnsavedChangesError
 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.utils.db_utils import get_existing_database_connection_names
-from arho_feature_template.utils.misc_utils import get_active_plan_id, get_layer_by_name, handle_unsaved_changes
+from arho_feature_template.utils.misc_utils import (
+    check_layer_changes,
+    get_active_plan_id,
+    handle_unsaved_changes,
+)
+
+if TYPE_CHECKING:
+    from qgis.core import QgsFeature
 
+    from arho_feature_template.core.models import Plan, RegulationGroup
 logger = logging.getLogger(__name__)
 
-LAYER_NAME_PLAN = "Kaava"
-LAYER_NAME_LAND_USE_POINT = "Maankäytön kohteet"
-LAYER_NAME_OTHER_POINT = "Muut pisteet"
-LAYER_NAME_LINE = "Viivat"
-LAYER_NAME_OTHER_AREA = "Osa-alue"
-LAYER_NAME_LAND_USE_AREA = "Aluevaraus"
-LAYER_NAME_PLAN_REGULATION_GROUP = "Kaavamääräysryhmät"
-LAYER_NAME_PLAN_REGULATION = "Kaavamääräys"
-LAYER_NAME_PLAN_PROPOSITION = "Kaavasuositus"
-LAYER_NAME_DOCUMENT = "Asiakirjat"
-LAYER_NAME_SOURCE_DATA = "Lähtötietoaineistot"
-LAYER_NAME_REGULATION_GROUP_ASSOCIATION = "Kaavamääräysryhmien assosiaatiot"
-
-PLAN_FILTER_TEMPLATES = {
-    LAYER_NAME_PLAN: Template("id = '$plan_id'"),
-    LAYER_NAME_LAND_USE_POINT: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_OTHER_POINT: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_LINE: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_LAND_USE_AREA: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_OTHER_AREA: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_PLAN_REGULATION_GROUP: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_REGULATION_GROUP_ASSOCIATION: Template(
-        dedent(
-            """\
-            EXISTS (
-                SELECT 1
-                FROM hame.plan_regulation_group prg
-                WHERE
-                    hame.regulation_group_association.plan_regulation_group_id = prg.id
-                    AND prg.plan_id = '$plan_id'
-            )"""
-        )
-    ),
-    LAYER_NAME_PLAN_REGULATION: Template(
-        dedent(
-            """\
-            EXISTS (
-                SELECT 1
-                FROM hame.plan_regulation_group prg
-                WHERE
-                    hame.plan_regulation.plan_regulation_group_id = prg.id
-                    AND prg.plan_id = '$plan_id'
-            )"""
-        )
-    ),
-    LAYER_NAME_PLAN_PROPOSITION: Template(
-        dedent(
-            """\
-            EXISTS (
-                SELECT 1
-                FROM hame.plan_regulation_group rg
-                WHERE
-                    hame.plan_proposition.plan_regulation_group_id = rg.id
-                    AND rg.plan_id = '$plan_id'
-            )"""
-        )
-    ),
-    LAYER_NAME_DOCUMENT: Template("plan_id = '$plan_id'"),
-    LAYER_NAME_SOURCE_DATA: Template("plan_id = '$plan_id'"),
-}
+
+class PlanDigitizeMapTool(QgsMapToolDigitizeFeature): ...
 
 
 class PlanManager:
     def __init__(self):
         self.json_plan_path = None
         self.json_plan_outline_path = None
 
+        self.digitize_map_tool = PlanDigitizeMapTool(iface.mapCanvas(), iface.cadDockWidget())
+        self.digitize_map_tool.digitizingCompleted.connect(self._plan_geom_digitized)
+
     def add_new_plan(self):
         """Initiate the process to add a new plan to the Kaava layer."""
+
+        self.previous_map_tool = iface.mapCanvas().mapTool()
+        self.previous_active_plan_id = get_active_plan_id()
+
         if not handle_unsaved_changes():
             return
 
-        plan_layer = get_layer_by_name(LAYER_NAME_PLAN)
-
+        plan_layer = PlanLayer.get_from_project()
         if not plan_layer:
             return
-        self.set_active_plan(None)
+        self.previously_editable = plan_layer.isEditable()
 
-        if not plan_layer.isEditable():
-            plan_layer.startEditing()
-
-        iface.setActiveLayer(plan_layer)
-        iface.actionAddFeature().trigger()
+        self.set_active_plan(None)
 
-        # Connect the featureAdded signal to a callback method
-        plan_layer.featureAdded.connect(self._feature_added)
+        plan_layer.startEditing()
+        self.digitize_map_tool.setLayer(plan_layer)
+        iface.mapCanvas().setMapTool(self.digitize_map_tool)
 
-    def _feature_added(self):
+    def _plan_geom_digitized(self, feature: QgsFeature):
         """Callback for when a new feature is added to the Kaava layer."""
-        plan_layer = get_layer_by_name(LAYER_NAME_PLAN)
+        plan_layer = PlanLayer.get_from_project()
         if not plan_layer:
             return
 
-        # Disconnect the signal to avoid repeated triggers
-        plan_layer.featureAdded.disconnect(self._feature_added)
-
-        feature_ids_before_commit = plan_layer.allFeatureIds()
-
-        if plan_layer.isEditable():
-            if not plan_layer.commitChanges():
-                iface.messageBar().pushMessage("Error", "Failed to commit changes to the layer.", level=3)
-                return
+        attribute_form = PlanAttributeForm()
+        if attribute_form.exec_():
+            plan_attributes = attribute_form.get_plan_attributes()
+            plan_attributes.geom = feature.geometry()
+            feature = save_plan(plan_attributes)
+            plan_to_be_activated = feature["id"]
         else:
-            iface.messageBar().pushMessage("Error", "Layer is not editable.", level=3)
-            return
+            plan_to_be_activated = self.previous_active_plan_id
 
-        feature_ids_after_commit = plan_layer.allFeatureIds()
-        new_feature_id = next(
-            (fid for fid in feature_ids_after_commit if fid not in feature_ids_before_commit),
-            None,
-        )
+        self.set_active_plan(plan_to_be_activated)
 
-        if new_feature_id is not None:
-            new_feature = plan_layer.getFeature(new_feature_id)
-            if new_feature.isValid():
-                feature_id_value = new_feature["id"]
-                self.set_active_plan(feature_id_value)
-            else:
-                iface.messageBar().pushMessage("Error", "Invalid feature retrieved.", level=3)
-        else:
-            iface.messageBar().pushMessage("Error", "No new feature was added.", level=3)
+        if self.previously_editable:
+            plan_layer.startEditing()
+
+        iface.mapCanvas().setMapTool(self.previous_map_tool)
 
     def set_active_plan(self, plan_id: str | None):
-        """Update the project layers based on the selected land use plan."""
+        """Update the project layers based on the selected land use plan.
+
+        Layers to be filtered cannot be in edit mode.
+        This method disables edit mode temporarily if needed.
+        Therefore if there are unsaved changes, this method will raise an exception.
+        """
+
+        if check_layer_changes():
+            raise UnsavedChangesError
+
+        plan_layer = PlanLayer.get_from_project()
+        previously_in_edit_mode = plan_layer.isEditable()
+        if previously_in_edit_mode:
+            plan_layer.rollBack()
+
         QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(), "active_plan_id", plan_id)
+        for layer in plan_layers:
+            layer.apply_filter(plan_id)
 
-        for layer_name, filter_template in PLAN_FILTER_TEMPLATES.items():
-            """Set a filter for the given vector layer."""
-            filter_expression = filter_template.substitute(plan_id=plan_id) if plan_id else None
-            layer = get_layer_by_name(layer_name)
-            if not layer:
-                logger.warning("Layer %s not found", layer_name)
-                continue
-            result = layer.setSubsetString(filter_expression)
-            if result is False:
-                iface.messageBar().pushMessage(
-                    "Error",
-                    f"Failed to filter layer {layer_name} with query {filter_expression}",
-                    level=3,
-                )
+        if previously_in_edit_mode:
+            plan_layer.startEditing()
 
     def load_land_use_plan(self):
         """Load an existing land use plan using a dialog selection."""
@@ -221,4 +172,47 @@ def save_plan_jsons(self, plan_json, outline_json):
         with open(self.json_plan_outline_path, "w", encoding="utf-8") as outline_file:
             json.dump(outline_json, outline_file, ensure_ascii=False, indent=2)
 
-        QMessageBox.information(None, "Tallennus onnistui", "Kaava ja sen ulkoraja tallennettu onnistuneesti.")
+        QMessageBox.information(
+            None,
+            "Tallennus onnistui",
+            "Kaava ja sen ulkoraja tallennettu onnistuneesti.",
+        )
+
+
+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)
+
+    if plan_data.id_ is None:
+        plan_layer.addFeature(plan_feature)
+    else:
+        plan_layer.updateFeature(plan_feature)
+
+    plan_layer.endEditCommand()
+    plan_layer.commitChanges(stopEditing=False)
+
+    if plan_data.general_regulations:
+        for regulation_group in plan_data.general_regulations:
+            plan_id = plan_feature["id"]
+            regulation_group_feature = save_regulation_group(regulation_group, plan_id)
+            save_regulation_grop_assosiation(plan_id, regulation_group_feature["id"])
+
+    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_regulation_grop_assosiation(plan_id: str, regulation_group_id: str):
+    pass

arho_feature_template/exceptions.py

@@ -3,6 +3,19 @@ def __init__(self, layer_name: str):
         super().__init__(f"Layer {layer_name} not found")
 
 
+class LayerIoError(IOError): ...
+
+
+class LayerEditableError(LayerIoError):
+    def __init__(self, layer_name: str):
+        super().__init__(f"Layer {layer_name} is editable, when it should not be.")
+
+
+class UnsavedChangesError(LayerIoError):
+    def __init__(self):
+        super().__init__("Unsaved changes found")
+
+
 class LayerNotVectorTypeError(Exception):
     def __init__(self, layer_name: str):
         super().__init__(f"Layer {layer_name} is not a vector layer")