Fixed saving lifecycles

Moved contents of lifecycle_layers.py to plan_layers.py. Added lifecycles to plan model. Refactored saving lifecycles. Removed unused classmethod from LifeCycleStatusLayer.

Author: Mtk112

arho_feature_template/core/models.py

@@ -328,7 +328,6 @@ class LifeCycle:
     status_id: str | None
     id_: int | None = None
     plan_id: str | None = None
-    # plan_id_: int | None = None
     plan_regulation_id: str | None = None
     plan_proposition_id: str | None = None
     starting_at: datetime | None = None
@@ -364,7 +363,7 @@ class Plan:
     description: str | None = None
     plan_type_id: str | None = None
     lifecycle_status_id: str | None = None
-    # lifecycle: list[LifeCycle] = field(default_factory=list)
+    lifecycles: list[LifeCycle] = field(default_factory=list)
     record_number: str | None = None
     matter_management_identifier: str | None = None
     permanent_plan_identifier: str | None = None

arho_feature_template/core/plan_manager.py

@@ -26,10 +26,10 @@
 from arho_feature_template.gui.docks.new_feature_dock import NewFeatureDock
 from arho_feature_template.gui.tools.inspect_plan_features_tool import InspectPlanFeatures
 from arho_feature_template.project.layers.code_layers import PlanRegulationGroupTypeLayer
-from arho_feature_template.project.layers.lifecycle_layers import LifeCycleLayer
 from arho_feature_template.project.layers.plan_layers import (
     LandUseAreaLayer,
     LandUsePointLayer,
+    LifeCycleLayer,
     LineLayer,
     OtherAreaLayer,
     OtherPointLayer,
@@ -216,8 +216,6 @@ def _plan_geom_digitized(self, feature: QgsFeature):
         attribute_form = PlanAttributeForm(plan_model, self.get_regulation_group_libraries())
         if attribute_form.exec_():
             feature = save_plan(attribute_form.model)
-            lifecycle_features = save_lifecycle(attribute_form.lifecycle_model, feature["id"])
-            # print(lifecycle_features)
             plan_to_be_activated = feature["id"]
         else:
             plan_to_be_activated = self.previous_active_plan_id
@@ -465,6 +463,11 @@ def save_plan(plan: Plan) -> QgsFeature:
             regulation_group_feature = save_regulation_group(regulation_group, plan_id)
             save_regulation_group_association(regulation_group_feature["id"], PlanLayer.name, plan_id)
 
+    # loop lifecycles and save
+    for lifecycle in plan.lifecycles:
+        lifecycle.plan_id = feature["id"]
+        save_lifecycle(lifecycle)
+
     # Save plan lifecycles
     # if hasattr(plan, "lifecycle"):
     # print("Has attribute lifecycle!")
@@ -574,21 +577,18 @@ def save_regulation(regulation: Regulation) -> QgsFeature:
     return feature
 
 
-def save_lifecycle(lifecycles: list[LifeCycle]) -> list[QgsFeature]:
+def save_lifecycle(lifecycle: LifeCycle) -> QgsFeature:
     """Save a list of LifeCycle objects to the layer."""
-    lifecycle_layer = LifeCycleLayer.get_from_project()
-    if not lifecycle_layer:
-        raise RuntimeError("Lifecycle layer not found in the project.")
-
-    saved_features = []
-    for lifecycle in lifecycles:
-        # Create or update a feature from the model
-        feature = LifeCycleLayer.feature_from_model(lifecycle)
-        lifecycle_layer.addFeature(feature)
-        saved_features.append(feature)
-
-    lifecycle_layer.commitChanges()
-    return saved_features
+    feature = LifeCycleLayer.feature_from_model(lifecycle)
+    layer = LifeCycleLayer.get_from_project()
+
+    _save_feature(
+        feature=feature,
+        layer=layer,
+        id_=lifecycle.id_,
+        edit_text="Elinkaaren lisäys" if lifecycle.id_ is None else "Elinkaaren muokkaus",
+    )
+    return feature
 
 
 def save_proposition(proposition: Proposition) -> QgsFeature:

arho_feature_template/gui/dialogs/plan_attribute_form.py

@@ -180,43 +180,31 @@ def save_lifecycle(self):
 
         # Add to the model
         item = QStandardItem(lifecycle_entry)
+        item.setData(self.lifecycle_status_combo_box.value(), Qt.UserRole + 1)
         self.lifecycle_model.appendRow(item)
 
         # Optionally, check required fields again
         self._check_required_fields()
 
     def into_lifecycle_model(self) -> list[LifeCycle]:
-        print("Calling into_lifecycle_model at plan_attribute_form.py")
         lifecycles = []
 
         for row in range(self.lifecycle_model.rowCount()):
             item = self.lifecycle_model.item(row)
             if item:
                 lifecycle_entry = item.text()
                 parts = lifecycle_entry.split(" | ")
-                status = parts[0]
                 date_range = parts[1]
                 date_parts = date_range.split(" - ")
                 start_date = date_parts[0]
                 end_date = date_parts[1] if len(date_parts) > 1 else None  # End date is optional
 
-                print(f"Got status: {status}")
-                print(f"Got status_id: {LifeCycleStatusLayer.get_id_by_value(status)}")
-
                 # Add the lifecycle to the list
                 lifecycles.append(
                     LifeCycle(
-                        status_id=LifeCycleStatusLayer.get_id_by_value(status),
-                        plan_id="52aadc88-feb0-443b-a423-f5a50d0bb9fc",
-                        land_use_are_id=None,
-                        other_area_id=None,
-                        line_id=None,
-                        land_use_point_id=None,
-                        other_point_id=None,
+                        status_id=item.data(Qt.UserRole + 1),
                         starting_at=start_date,
                         ending_at=end_date,
-                        plan_regulation_id=None,
-                        plan_proposition_id=None,
                     )
                 )
 
@@ -234,12 +222,12 @@ def into_model(self) -> Plan:
             producers_plan_identifier=self.producers_plan_identifier_line_edit.text() or None,
             matter_management_identifier=self.matter_management_identifier_line_edit.text() or None,
             lifecycle_status_id=self.lifecycle_status_combo_box.value(),  # Need to get the lifecycle with the latest lifecycle
-            # lifecycle=self.get_lifecycles(),
+            lifecycles=self.into_lifecycle_model(),
             general_regulations=[reg_group_widget.into_model() for reg_group_widget in self.regulation_group_widgets],
             geom=self.plan.geom,
         )
 
     def _on_ok_clicked(self):
         self.model = self.into_model()
-        self.lifecycle_model = self.into_lifecycle_model()
+        # self.lifecycle_model = self.into_lifecycle_model()
         self.accept()

arho_feature_template/project/layers/code_layers.py

@@ -17,13 +17,6 @@ class PlanTypeLayer(AbstractCodeLayer):
 class LifeCycleStatusLayer(AbstractCodeLayer):
     name = "Elinkaaren tila"
 
-    @classmethod
-    def get_id_by_value(cls, value: str) -> str | None:
-        """Fetch the id based on the provided value."""
-        print(f"Searching for UUID for lifecycle_statis of: {value}")
-        attribute_value = cls.get_attribute_value_by_another_attribute_value("id", "name", value)
-        return cast(str, attribute_value) if attribute_value else attribute_value
-
 
 class OrganisationLayer(AbstractCodeLayer):
     name = "Toimija"

arho_feature_template/project/layers/lifecycle_layers.py

@@ -11,6 +11,7 @@
 from qgis.utils import iface
 
 from arho_feature_template.core.models import (
+    LifeCycle,
     Plan,
     PlanFeature,
     Proposition,
@@ -27,11 +28,13 @@
 
 
 class AbstractPlanLayer(AbstractLayer):
-    filter_template: ClassVar[Template]
+    filter_template: ClassVar[Template | None]
 
     @classmethod
     def apply_filter(cls, plan_id: str | None) -> None:
         """Apply a filter to the layer based on the plan_id."""
+        if cls.filter_template is None:
+            return
         filter_expression = cls.filter_template.substitute(plan_id=plan_id) if plan_id else ""
         layer = cls.get_from_project()
         if layer.isEditable():
@@ -406,6 +409,47 @@ class SourceDataLayer(AbstractPlanLayer):
     filter_template = Template("plan_id = '$plan_id'")
 
 
+class LifeCycleLayer(AbstractPlanLayer):
+    name = "Elinkaaren päiväykset"
+    filter_template = None
+
+    @classmethod
+    def feature_from_model(cls, model: LifeCycle) -> QgsFeature:
+        feature = cls.initialize_feature_from_model(model)
+        # feature["id"] = model.id_
+        feature["id"] = model.id_ if model.id_ else feature["id"]
+        feature["lifecycle_status_id"] = model.status_id
+        feature["starting_at"] = model.starting_at
+        feature["ending_at"] = model.ending_at if model.ending_at else None
+        feature["plan_id"] = model.plan_id
+        feature["land_use_area_id"] = model.land_use_are_id
+        feature["other_area_id"] = model.other_area_id
+        feature["line_id"] = model.line_id
+        feature["land_use_point_id"] = model.land_use_point_id
+        feature["other_point_id"] = model.other_point_id
+        feature["plan_regulation_id"] = model.plan_regulation_id
+        feature["plan_proposition_id"] = model.plan_proposition_id
+
+        return feature
+
+    @classmethod
+    def model_from_feature(cls, feature: QgsFeature) -> LifeCycle:
+        return LifeCycle(
+            id_=feature["id"],
+            status_id=feature["lifecycle_status_id"],
+            starting_at=feature["starting_at"],
+            ending_at=feature["ending_at"] if feature["ending_at"] else None,
+            plan_id=feature["plan_id"],
+            land_use_are_id=feature["land_use_area_id"] if feature["land_use_area_id"] else None,
+            other_area_id=feature["other_area_id"] if feature["other_area_id"] else None,
+            line_id=feature["line_id"] if feature["line_id"] else None,
+            land_use_point_id=feature["land_use_point_id"] if feature["land_use_point_id"] else None,
+            other_point_id=feature["other_point_id"] if feature["other_point_id"] else None,
+            plan_regulation_id=feature["plan_regulation_id"] if feature["plan_regulation_id"] else None,
+            plan_proposition_id=feature["plan_proposition_id"] if feature["plan_proposition_id"] else None,
+        )
+
+
 plan_layers = AbstractPlanLayer.__subclasses__()
 plan_layers.remove(PlanFeatureLayer)