Merge dev

api/data_workspace/v2/serializers.py

@@ -14,6 +14,7 @@
 from api.licences.models import GoodOnLicence
 from api.staticdata.control_list_entries.models import ControlListEntry
 from api.staticdata.countries.models import Country
+from api.staticdata.denial_reasons.models import DenialReason
 from api.staticdata.report_summaries.models import ReportSummary
 
 
@@ -163,3 +164,12 @@ class Meta:
             "good_id",
             "rating",
         )
+
+
+class LicenceRefusalCriteriaSerializer(serializers.ModelSerializer):
+    criteria = serializers.CharField(source="display_value")
+    licence_decision_id = serializers.UUIDField()
+
+    class Meta:
+        model = DenialReason
+        fields = ("criteria", "licence_decision_id")

api/data_workspace/v2/tests/bdd/conftest.py

@@ -623,3 +623,61 @@ def _issue_licence(application):
         assert response.status_code == 201
 
     return _issue_licence
+
+
+@pytest.fixture()
+def refuse_application(
+    api_client,
+    lu_case_officer,
+    siel_refusal_template,
+    gov_headers,
+):
+    def _refuse_application(application, denial_reasons=None):
+        if not denial_reasons:
+            denial_reasons = ["1a", "1b", "1c"]
+
+        data = {"action": AdviceType.REFUSE}
+        for good_on_app in application.goods.all():
+            good_on_app.quantity = 100
+            good_on_app.value = 10000
+            good_on_app.save()
+            data[f"quantity-{good_on_app.id}"] = str(good_on_app.quantity)
+            data[f"value-{good_on_app.id}"] = str(good_on_app.value)
+            FinalAdviceFactory(
+                user=lu_case_officer,
+                case=application,
+                good=good_on_app.good,
+                type=AdviceType.REFUSE,
+                denial_reasons=denial_reasons,
+            )
+
+        application.flags.remove(SystemFlags.ENFORCEMENT_CHECK_REQUIRED)
+
+        url = reverse("applications:finalise", kwargs={"pk": application.pk})
+        response = api_client.put(url, data=data, **gov_headers)
+        assert response.status_code == 200, response.content
+        response = response.json()
+
+        data = {
+            "template": str(siel_refusal_template.id),
+            "text": "",
+            "visible_to_exporter": False,
+            "advice_type": AdviceType.REFUSE,
+        }
+        url = reverse(
+            "cases:generated_documents:generated_documents",
+            kwargs={"pk": str(application.pk)},
+        )
+        response = api_client.post(url, data=data, **gov_headers)
+        assert response.status_code == 201, response.content
+
+        url = reverse(
+            "cases:finalise",
+            kwargs={"pk": str(application.pk)},
+        )
+        response = api_client.put(url, data={}, **gov_headers)
+        assert response.status_code == 201, response.content
+
+        application.refresh_from_db()
+
+    return _refuse_application

api/data_workspace/v2/tests/bdd/scenarios/licence_refusal_criteria.feature

@@ -0,0 +1,28 @@
+@db
+Feature: licence_refusal_criteria Table
+
+Scenario: Draft application
+    Given a draft standard application
+    Then the `licence_refusal_criteria` table is empty
+
+Scenario: Submit an application
+    Given a draft standard application
+    When the application is submitted
+    Then the `licence_refusal_criteria` table is empty
+
+Scenario: Issuing an application
+    Given a draft standard application
+    When the application is submitted
+    And the application is issued
+    Then the `licence_refusal_criteria` table is empty
+
+Scenario: Refusing an application
+    Given a draft standard application
+    When the application is submitted
+    And the application is refused with criteria:
+        | 1  |
+        | 2c |
+    Then the `licence_refusal_criteria` table has the following rows:
+        | licence_decision_id                  | criteria |
+        | 03fb08eb-1564-4b68-9336-3ca8906543f9 | 1        |
+        | 03fb08eb-1564-4b68-9336-3ca8906543f9 | 2c       |

api/data_workspace/v2/tests/bdd/test_applications.py

@@ -22,8 +22,6 @@
     AdviceLevel,
     AdviceType,
 )
-from api.cases.tests.factories import FinalAdviceFactory
-from api.flags.enums import SystemFlags
 from api.licences.enums import LicenceStatus
 from api.parties.tests.factories import (
     PartyDocumentFactory,
@@ -112,21 +110,6 @@ def _exporter_change_status(application, status):
     return _exporter_change_status
 
 
-@given("a draft standard application", target_fixture="draft_standard_application")
-def given_draft_standard_application(organisation):
-    application = DraftStandardApplicationFactory(
-        organisation=organisation,
-    )
-
-    PartyDocumentFactory(
-        party=application.end_user.party,
-        s3_key="party-document",
-        safe=True,
-    )
-
-    return application
-
-
 @given(
     parsers.parse("a draft temporary standard application with attributes:{attributes}"),
     target_fixture="draft_standard_application",
@@ -174,14 +157,6 @@ def given_a_good_is_onward_incorporated(draft_standard_application):
     )
 
 
-@when(
-    "the application is submitted",
-    target_fixture="submitted_standard_application",
-)
-def when_the_application_is_submitted(submit_application, draft_standard_application):
-    return submit_application(draft_standard_application)
-
-
 @when(
     parsers.parse("the application is submitted at {submission_time}"),
     target_fixture="submitted_standard_application",
@@ -210,61 +185,19 @@ def when_the_application_is_issued_at(
 
 @when(parsers.parse("the application is refused at {timestamp}"), target_fixture="refused_application")
 def when_the_application_is_refused_at(
-    api_client,
-    lu_case_officer,
-    siel_refusal_template,
-    gov_headers,
     submitted_standard_application,
+    refuse_application,
     timestamp,
 ):
     run_processing_time_task(submitted_standard_application.submitted_at, timestamp)
 
     with freeze_time(timestamp):
-        data = {"action": AdviceType.REFUSE}
-        for good_on_app in submitted_standard_application.goods.all():
-            good_on_app.quantity = 100
-            good_on_app.value = 10000
-            good_on_app.save()
-            data[f"quantity-{good_on_app.id}"] = str(good_on_app.quantity)
-            data[f"value-{good_on_app.id}"] = str(good_on_app.value)
-            FinalAdviceFactory(
-                user=lu_case_officer,
-                case=submitted_standard_application,
-                good=good_on_app.good,
-                type=AdviceType.REFUSE,
-            )
-
-        submitted_standard_application.flags.remove(SystemFlags.ENFORCEMENT_CHECK_REQUIRED)
-
-        url = reverse("applications:finalise", kwargs={"pk": submitted_standard_application.pk})
-        response = api_client.put(url, data=data, **gov_headers)
-        assert response.status_code == 200, response.content
-        response = response.json()
-
-        data = {
-            "template": str(siel_refusal_template.id),
-            "text": "",
-            "visible_to_exporter": False,
-            "advice_type": AdviceType.REFUSE,
-        }
-        url = reverse(
-            "cases:generated_documents:generated_documents",
-            kwargs={"pk": str(submitted_standard_application.pk)},
-        )
-        response = api_client.post(url, data=data, **gov_headers)
-        assert response.status_code == 201, response.content
+        refuse_application(submitted_standard_application)
 
-        url = reverse(
-            "cases:finalise",
-            kwargs={"pk": str(submitted_standard_application.pk)},
-        )
-        response = api_client.put(url, data={}, **gov_headers)
-        assert response.status_code == 201, response.content
-
-        submitted_standard_application.refresh_from_db()
-        refused_application = submitted_standard_application
+    submitted_standard_application.refresh_from_db()
+    refused_application = submitted_standard_application
 
-        return refused_application
+    return refused_application
 
 
 @when(parsers.parse("the application is appealed at {timestamp}"), target_fixture="appealed_application")

api/data_workspace/v2/tests/bdd/test_licence_refusal_criteria.py

@@ -0,0 +1,39 @@
+import uuid
+
+from pytest_bdd import (
+    parsers,
+    scenarios,
+    when,
+)
+
+
+scenarios("./scenarios/licence_refusal_criteria.feature")
+
+
+@when(parsers.parse("the application is refused with criteria:{criteria}"))
+def when_the_application_is_refused_with_criteria(
+    submitted_standard_application, refuse_application, parse_table, criteria
+):
+    criteria = [c[0] for c in parse_table(criteria)]
+    refuse_application(submitted_standard_application, criteria)
+    refused_application = submitted_standard_application
+    licence_decision = refused_application.licence_decisions.get()
+    old_pk = licence_decision.pk
+    licence_decision.pk = uuid.UUID("03fb08eb-1564-4b68-9336-3ca8906543f9")  # /PS-IGNORE
+    licence_decision.save()
+    licence_decision.denial_reasons.through.objects.filter(licencedecision_id=old_pk).update(
+        licencedecision_id=licence_decision.pk
+    )
+
+
+@when("the application is issued")
+def when_the_application_is_issued(
+    issue_licence,
+    submitted_standard_application,
+):
+    issue_licence(submitted_standard_application)
+
+    submitted_standard_application.refresh_from_db()
+    issued_application = submitted_standard_application
+
+    return issued_application

api/data_workspace/v2/urls.py

@@ -12,3 +12,4 @@
 router_v2.register(views.UnitViewSet)
 router_v2.register(views.FootnoteViewSet)
 router_v2.register(views.AssessmentViewSet)
+router_v2.register(views.LicenceRefusalCriteriaViewSet)

api/data_workspace/v2/views.py

@@ -39,12 +39,14 @@
     GoodSerializer,
     LicenceDecisionSerializer,
     UnitSerializer,
+    LicenceRefusalCriteriaSerializer,
 )
 from api.licences.enums import LicenceStatus
 from api.licences.models import GoodOnLicence
 from api.staticdata.control_list_entries.models import ControlListEntry
 from api.staticdata.countries.models import Country
 from api.staticdata.report_summaries.models import ReportSummary
+from api.staticdata.denial_reasons.models import DenialReason
 from api.staticdata.statuses.enums import CaseStatusEnum
 from api.staticdata.units.enums import Units
 
@@ -198,3 +200,13 @@ def get_queryset(self):
 
     class DataWorkspace:
         table_name = "goods_ratings"
+
+
+class LicenceRefusalCriteriaViewSet(BaseViewSet):
+    serializer_class = LicenceRefusalCriteriaSerializer
+    queryset = DenialReason.objects.exclude(licencedecision__denial_reasons__isnull=True).annotate(
+        licence_decision_id=F("licencedecision__id")
+    )
+
+    class DataWorkspace:
+        table_name = "licence_refusal_criteria"

pii-secret-exclude.txt

@@ -118,3 +118,4 @@ api/cases/generated_documents/tests/data/dummy.pdf
 api/cases/generated_documents/tests/data/signed.pdf
 api/data_workspace/v2/tests/bdd/scenarios/applications.feature
 api/data_workspace/v2/tests/bdd/scenarios/goods_on_licences.feature
+api/data_workspace/v2/tests/bdd/scenarios/licence_refusal_criteria.feature