Merge pull request #4250 from bcgov/bug-4234-registration-purpose-change-effects

chore: updated supplementary report create logic

Author: ayeshmcg

bc_obps/reporting/api/report_supplementary_version.py

@@ -2,12 +2,13 @@
 from django.http import HttpRequest
 from reporting.constants import EMISSIONS_REPORT_TAGS
 from reporting.schema.generic import Message
-from reporting.service.report_supplementary_version_service import ReportSupplementaryVersionService
+from reporting.service.report_supplementary_version_service.report_supplementary_version_service import (
+    ReportSupplementaryVersionService,
+)
 from service.report_version_service import ReportVersionService
 from service.error_service.custom_codes_4xx import custom_codes_4xx
 from .router import router
 from reporting.api.permissions import approved_industry_user_report_version_composite_auth
-from ..models import ReportVersion, ReportOperation
 
 
 @router.get(
@@ -34,17 +35,5 @@ def is_supplementary_report_version(request: HttpRequest, version_id: int) -> Tu
     auth=approved_industry_user_report_version_composite_auth,
 )
 def create_report_supplementary_version(request: HttpRequest, version_id: int) -> Tuple[Literal[201], int]:
-    # Get registration_purpose from Operation
-    report_version = ReportVersion.objects.select_related("report__operation").get(id=version_id)
-    operation_registration_purpose = report_version.report.operation.registration_purpose
-
-    # Get registration_purpose from ReportOperation
-    report_operation = ReportOperation.objects.get(report_version_id=version_id)
-    report_operation_registration_purpose = report_operation.registration_purpose
-
-    if operation_registration_purpose == report_operation_registration_purpose:
-        new_version = ReportSupplementaryVersionService.create_report_supplementary_version(version_id)
-    else:
-        new_version = ReportVersionService.create_report_version(report_version.report)
-
+    new_version = ReportSupplementaryVersionService.create_or_clone_report_version(version_id)
     return 201, new_version.id

bc_obps/reporting/service/report_supplementary_version_service.py

@@ -0,0 +1,3 @@
+# ruff: noqa: F401
+
+from .report_supplementary_version_service import ReportSupplementaryVersionService

bc_obps/reporting/service/report_supplementary_version_service/__init__.py

@@ -0,0 +1,122 @@
+from django.db import transaction
+
+from reporting.models import ReportOperation, ReportVersion
+from reporting.service.report_supplementary_version_service.report_supplementary_cloning import clone_all
+from service.reporting_year_service import ReportingYearService
+
+
+class ReportSupplementaryVersionService:
+
+    @staticmethod
+    @transaction.atomic
+    def create_or_clone_report_version(report_version_id: int) -> ReportVersion:
+        """
+        Creates a supplementary (cloned copy) or blank report version depending on whether
+        the registration purpose, operator, or reporting year have changed.
+        """
+        report_version = ReportVersion.objects.select_related(
+            "report__operation", "report__reporting_year", "report_operation"
+        ).get(id=report_version_id)
+        operation = report_version.report.operation
+        operator_changed = operation.operator_id != report_version.report.operator_id
+        purpose_changed = operation.registration_purpose != report_version.report_operation.registration_purpose
+
+        current_year = ReportingYearService.get_current_reporting_year()
+        is_past_year = report_version.report.reporting_year.reporting_year < current_year.reporting_year
+
+        should_clone = not purpose_changed or operator_changed or is_past_year
+
+        if should_clone:
+            return ReportSupplementaryVersionService._create_supplementary_version(
+                report_version, operator_changed, purpose_changed
+            )
+
+        return ReportSupplementaryVersionService._create_blank_report_version(report_version)
+
+    @staticmethod
+    @transaction.atomic
+    def _create_blank_report_version(report_version: ReportVersion) -> ReportVersion:
+        """
+        Creates a new blank Draft report version with a ReportOperation reflecting the
+        current operation's registration purpose, but no pre-populated facility or
+        personal data.
+        """
+        operation = report_version.report.operation
+        operator = report_version.report.operator
+
+        new_version = ReportVersion.objects.create(
+            report=report_version.report,
+            report_type=report_version.report_type,
+            status=ReportVersion.ReportVersionStatus.Draft,
+            is_latest_submitted=False,
+        )
+
+        report_operation = ReportOperation.objects.create(
+            operator_legal_name=operator.legal_name,
+            operator_trade_name=operator.trade_name,
+            operation_name=operation.name,
+            operation_type=operation.type,
+            operation_bcghgid=operation.bcghg_id.id if operation.bcghg_id else None,
+            bc_obps_regulated_operation_id=(
+                operation.bc_obps_regulated_operation.id if operation.bc_obps_regulated_operation else ""
+            ),
+            report_version=new_version,
+            registration_purpose=operation.registration_purpose or 'OBPS Regulated Operation',
+        )
+        report_operation.activities.add(*list(operation.activities.all()))
+        report_operation.regulated_products.add(*list(operation.regulated_products.all()))
+
+        return new_version
+
+    @staticmethod
+    @transaction.atomic
+    def _create_supplementary_version(
+        report_version: ReportVersion,
+        operator_changed: bool = False,
+        purpose_changed: bool = False,
+    ) -> ReportVersion:
+        """
+        Creates a new Draft version by cloning the data from the source version..
+        """
+        source = ReportSupplementaryVersionService._resolve_source_version(
+            report_version, operator_changed, purpose_changed
+        )
+
+        if source is None:
+            raise ValueError(
+                "Cannot create supplementary version: no submitted version found matching the new registration purpose."
+            )
+
+        new_version = ReportVersion.objects.create(
+            report=report_version.report,
+            report_type=source.report_type,
+            status=ReportVersion.ReportVersionStatus.Draft,
+            is_latest_submitted=False,
+        )
+
+        clone_all(source, new_version)
+        return new_version
+
+    @staticmethod
+    def _resolve_source_version(
+        report_version: ReportVersion,
+        operator_changed: bool,
+        purpose_changed: bool,
+    ) -> ReportVersion | None:
+        """
+        Returns the version to clone from.
+        - If both the operator and registration purpose have changed, returns the latest
+          submitted version from the original operator with the matching registration purpose.
+        - Otherwise, returns the current report version.
+        """
+        if purpose_changed:
+            matching_versions = ReportVersion.objects.filter(
+                report__operation=report_version.report.operation,
+                report__reporting_year=report_version.report.reporting_year,
+                report_operation__registration_purpose=report_version.report_operation.registration_purpose,
+                status=ReportVersion.ReportVersionStatus.Submitted,
+            )
+            if operator_changed:
+                matching_versions = matching_versions.filter(report__operator_id=report_version.report.operator_id)
+            return matching_versions.order_by("-created_at").first()
+        return report_version

bc_obps/reporting/service/report_supplementary_version_service/report_supplementary_cloning.py

@@ -1,9 +1,11 @@
 import logging
 from typing import Type, Any
+from django.db.models import F
 from django.dispatch import receiver
 from registration.signals.signals import operation_registration_purpose_changed
 from reporting.models import ReportVersion
 from service.report_version_service import ReportVersionService
+from service.reporting_year_service import ReportingYearService
 
 logger = logging.getLogger(__name__)
 
@@ -14,22 +16,33 @@ def handle_registration_purpose_changed(sender: Type[Any], **kwargs: Any) -> Non
     Signal handler that deletes the draft report version for an operation
     whose registration purpose has changed.
 
-    Args:
-        sender: The class that sent the signal
-        **kwargs: Signal arguments including operation_id and user_guid
+    Skips deletion if:
+    - No draft report version exists for the current reporting year
+    - The draft belongs to a previous operator (operation was transferred)
     """
-    operation_id = kwargs.get('operation_id')
+    operation_id = kwargs.get("operation_id")
     if not operation_id:
-        logger.warning("Missing operation_id in signal kwargs")
+        logger.warning("Signal received without operation_id in kwargs")
         return
 
-    draft_version = ReportVersion.objects.filter(
-        report__operation_id=operation_id, status=ReportVersion.ReportVersionStatus.Draft
-    ).first()
+    current_reporting_year = ReportingYearService.get_current_reporting_year()
+
+    draft_version = (
+        ReportVersion.objects.select_related("report__operation", "report__reporting_year", "report__operator")
+        .filter(
+            report__operation_id=operation_id,
+            report__operation__operator_id=F("report__operator_id"),
+            status=ReportVersion.ReportVersionStatus.Draft,
+            report__reporting_year=current_reporting_year,
+        )
+        .first()
+    )
 
     if not draft_version:
-        logger.info(f"No draft report version found for operation_id={operation_id}")
+        logger.info("No draft report version found for operation_id=%s", operation_id)
         return
 
-    logger.info(f"Deleting draft report version ID={draft_version.id} for operation_id={operation_id}")
-    ReportVersionService.delete_report_version(draft_version.id)
+    version_id = draft_version.id
+
+    logger.info("Deleting draft report version id=%s for operation_id=%s", version_id, operation_id)
+    ReportVersionService.delete_report_version(version_id)

bc_obps/reporting/service/report_supplementary_version_service/report_supplementary_version_service.py

@@ -1,10 +1,7 @@
-import pytest
 from unittest.mock import patch, MagicMock
 from model_bakery import baker
-from registration.models import Operation
 from registration.tests.utils.helpers import CommonTestSetup, TestUtils
 from registration.utils import custom_reverse_lazy
-from reporting.models import ReportEmission, ReportProduct
 from reporting.tests.utils.report_access_validation import assert_report_version_ownership_is_validated
 
 
@@ -20,43 +17,17 @@ def setup_method(self):
         self.new_report_version = baker.make_recipe("reporting.tests.utils.report_version")
         TestUtils.authorize_current_user_as_operator_user(self, operator=self.old_report_version.report.operator)
 
-    @pytest.mark.parametrize(
-        "existing_purpose, new_purpose, expected_called_method",
-        [
-            # Purpose is same → create_report_supplementary_version is called
-            (Operation.Purposes.OBPS_REGULATED_OPERATION, Operation.Purposes.OBPS_REGULATED_OPERATION, "supplementary"),
-            # Purpose is different → create_report_version is called
-            (Operation.Purposes.OBPS_REGULATED_OPERATION, "different-purpose", "new_version"),
-        ],
-    )
     @patch(
         "reporting.service.report_supplementary_version_service.ReportSupplementaryVersionService"
-        ".create_report_supplementary_version"
+        ".create_or_clone_report_version"
     )
-    @patch("service.report_version_service.ReportVersionService.create_report_version")
-    def test_create_version_based_on_purpose(
+    def test_create_or_clone_report_version_is_called(
         self,
-        mock_create_report_version: MagicMock,
-        mock_create_supplementary: MagicMock,
-        existing_purpose,
-        new_purpose,
-        expected_called_method,
+        mock_create_or_clone: MagicMock,
     ):
+        """Test that create_or_clone_report_version is called with the correct version ID."""
         report_version = self.old_report_version
-
-        report_version.report.operation.registration_purpose = existing_purpose
-        report_version.report.operation.save()
-
-        baker.make_recipe(
-            "reporting.tests.utils.report_operation",
-            report_version=report_version,
-            registration_purpose=new_purpose,
-        )
-
-        if expected_called_method == "supplementary":
-            mock_create_supplementary.return_value = self.new_report_version
-        else:
-            mock_create_report_version.return_value = self.new_report_version
+        mock_create_or_clone.return_value = self.new_report_version
 
         response = TestUtils.mock_post_with_auth_role(
             self,
@@ -71,51 +42,7 @@ def test_create_version_based_on_purpose(
 
         assert response.status_code == 201
         assert response.json() == self.new_report_version.id
-
-        if expected_called_method == "supplementary":
-            mock_create_supplementary.assert_called_once_with(report_version.id)
-            mock_create_report_version.assert_not_called()
-        else:
-            mock_create_report_version.assert_called_once_with(report_version.report)
-            mock_create_supplementary.assert_not_called()
-
-    def test_new_version_has_no_emission_or_product_records(self):
-        baker.make_recipe(
-            "reporting.tests.utils.report_operation",
-            report_version=self.old_report_version,
-            registration_purpose="different-purpose",
-        )
-        baker.make_recipe("reporting.tests.utils.report_emission", report_version=self.old_report_version, _quantity=3)
-
-        facility_report = baker.make_recipe(
-            "reporting.tests.utils.facility_report",
-            report_version=self.old_report_version,
-        )
-        baker.make_recipe(
-            "reporting.tests.utils.report_product",
-            report_version=self.old_report_version,
-            facility_report=facility_report,
-            product_id=1,
-        )
-
-        self.old_report_version.status = "Submitted"
-        self.old_report_version.save()
-
-        response = TestUtils.mock_post_with_auth_role(
-            self,
-            "industry_user",
-            self.content_type,
-            {},
-            custom_reverse_lazy(
-                "create_report_supplementary_version",
-                kwargs={"version_id": self.old_report_version.id},
-            ),
-        )
-        assert response.status_code == 201
-        new_report_version_id = response.json()
-        # Verify that the new report version has no related entries
-        assert not ReportEmission.objects.filter(report_version_id=new_report_version_id).exists()
-        assert not ReportProduct.objects.filter(report_version_id=new_report_version_id).exists()
+        mock_create_or_clone.assert_called_once_with(report_version.id)
 
     @patch("service.report_version_service.ReportVersionService.is_initial_report_version")
     def test_returns_data_as_provided_by_is_initial_version(self, mock_is_initial_report_version: MagicMock):