Add ops-learning-coverage endpoint with tests

main/urls.py

@@ -137,6 +137,7 @@
 router.register(r"public-per-stats", per_views.CountryPublicPerStatsViewset, basename="public_country_per_stats")
 router.register(r"per-stats", per_views.CountryPerStatsViewset, basename="country_per_stats")
 router.register(r"ops-learning", per_views.OpsLearningViewset, basename="ops_learning")
+router.register(r"ops-learning-coverage", per_views.OpsLearningCoverageViewset, basename="ops_learning_coverage")
 router.register(r"per-document-upload", per_views.PerDocumentUploadViewSet, basename="per_document_upload")
 
 router.register(r"personnel_deployment", deployment_views.PersonnelDeploymentViewset, basename="personnel_deployment")

per/drf_views.py

@@ -78,6 +78,7 @@
     LatestCountryOverviewSerializer,
     ListNiceDocSerializer,
     NiceDocumentSerializer,
+    OpsLearningCoverageSerializer,
     OpsLearningCSVSerializer,
     OpsLearningInSerializer,
     OpsLearningOrganizationTypeSerializer,
@@ -1495,6 +1496,21 @@ def stats(self, request):
         return response.Response(OpsLearningStatSerializer(data).data)
 
 
+class OpsLearningCoverageViewset(viewsets.ReadOnlyModelViewSet):
+    """Public OpsLearning coverage with minimal fields."""
+
+    queryset = OpsLearning.objects.all()
+    permission_classes = [permissions.AllowAny]
+    serializer_class = OpsLearningCoverageSerializer
+    filterset_class = OpsLearningFilter
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        if OpsLearning.is_user_admin(self.request.user):
+            return qs
+        return qs.filter(is_validated=True)
+
+
 class PerDocumentUploadViewSet(viewsets.ModelViewSet):
     queryset = PerDocumentUpload.objects.all()
     serializer_class = PerDocumentUploadSerializer

per/serializers.py

@@ -1139,6 +1139,15 @@ def get_document_name(self, obj):
             return document.name
 
 
+class OpsLearningCoverageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = OpsLearning
+        fields = (
+            "appeal_code",
+            "is_validated",
+        )
+
+
 class PerDocumentUploadSerializer(serializers.ModelSerializer):
     MAX_NUMBER_OF_DOCUMENTS = 10
 

per/test_views.py

@@ -354,3 +354,50 @@ def test_migrate_subcomponents(self):
         ops_learning.refresh_from_db()
         self.assertEqual(ops_learning.per_component.count(), 2)
         self.assertEqual(ops_learning.per_component_validated.count(), 2)
+
+
+class OpsLearningCoverageTestCase(APITestCase):
+
+    def setUp(self):
+        super().setUp()
+        country = CountryFactory.create()
+        self.appeal1 = AppealFactory.create(code="APP-COV-1", country=country)
+        self.appeal2 = AppealFactory.create(code="APP-COV-2", country=country)
+        self.ops_learning1 = OpsLearningFactory.create(is_validated=True, appeal_code=self.appeal1)
+        self.ops_learning2 = OpsLearningFactory.create(is_validated=False, appeal_code=self.appeal2)
+
+    def test_ops_learning_coverage_list(self):
+        url = "/api/v2/ops-learning-coverage/"
+        response = self.client.get(url)
+
+        self.assert_200(response)
+        results = response.data["results"]
+        self.assertEqual(len(results), 1)
+
+        result_keys = set(results[0].keys())
+        self.assertEqual(result_keys, {"appeal_code", "is_validated"})
+
+        appeal_codes = {item["appeal_code"] for item in results}
+        self.assertEqual(appeal_codes, {self.appeal1.code})
+
+    def test_ops_learning_coverage_list_admin(self):
+        url = "/api/v2/ops-learning-coverage/"
+        self.authenticate(self.ifrc_user)
+        response = self.client.get(url)
+
+        self.assert_200(response)
+        results = response.data["results"]
+        self.assertEqual(len(results), 2)
+
+        appeal_codes = {item["appeal_code"] for item in results}
+        self.assertEqual(appeal_codes, {self.appeal1.code, self.appeal2.code})
+
+    def test_ops_learning_coverage_filter_validated(self):
+        url = "/api/v2/ops-learning-coverage/"
+        response = self.client.get(url, {"is_validated": "true"})
+
+        self.assert_200(response)
+        results = response.data["results"]
+        self.assertEqual(len(results), 1)
+        self.assertTrue(results[0]["is_validated"])
+        self.assertEqual(results[0]["appeal_code"], self.appeal1.code)