Merge pull request #577 from Ilhasoft/hotfix/nlp-logs

Added filter by repository version language

bothub/api/v2/repository/filters.py

@@ -11,6 +11,8 @@
     RepositoryEntity,
     RepositoryQueueTask,
     RepositoryIntent,
+    RepositoryVersion,
+    RepositoryVersionLanguage,
 )
 from bothub.common.models import RepositoryAuthorization
 from bothub.common.models import RequestRepositoryAuthorization
@@ -88,7 +90,6 @@ class Meta:
     repository_uuid = filters.CharFilter(
         field_name="repository_uuid",
         method="filter_repository_uuid",
-        required=True,
         help_text=_("Repository's UUID"),
     )
 
@@ -104,6 +105,13 @@ class Meta:
         help_text=_("Filter for examples with version id."),
     )
 
+    repository_version_language = filters.CharFilter(
+        field_name="repository_version_language",
+        method="filter_repository_version_language",
+        required=True,
+        help_text=_("Filter for examples with version language id."),
+    )
+
     intent = filters.CharFilter(
         field_name="repository_version_language",
         method="filter_intent",
@@ -133,7 +141,36 @@ def filter_language(self, queryset, name, value):
         return queryset.filter(repository_version_language__language=value)
 
     def filter_repository_version(self, queryset, name, value):
-        return queryset.filter(repository_version_language__repository_version=value)
+        request = self.request
+        try:
+            repository = RepositoryVersion.objects.get(pk=value).repository
+            authorization = repository.get_user_authorization(request.user)
+            if not authorization.can_contribute:
+                raise PermissionDenied()
+            return queryset.filter(
+                repository_version_language__repository_version=value
+            )
+        except RepositoryVersion.DoesNotExist:
+            raise NotFound(_("RepositoryVersion {} does not exist").format(value))
+        except DjangoValidationError:
+            raise NotFound(_("Invalid repository_version"))
+
+    def filter_repository_version_language(self, queryset, name, value):
+        request = self.request
+        try:
+            repository = RepositoryVersionLanguage.objects.get(
+                pk=value
+            ).repository_version.repository
+            authorization = repository.get_user_authorization(request.user)
+            if not authorization.can_contribute:
+                raise PermissionDenied()
+            return queryset.filter(repository_version_language=value)
+        except RepositoryVersionLanguage.DoesNotExist:
+            raise NotFound(
+                _("RepositoryVersionLanguage {} does not exist").format(value)
+            )
+        except DjangoValidationError:
+            raise NotFound(_("Invalid repository_version_language"))
 
     def filter_intent(self, queryset, name, value):
         return queryset.filter(
@@ -145,7 +182,6 @@ def filter_confidence(self, queryset, name, value):
             Q(repository_nlp_log__confidence__gte=int(value.start) / 100),
             Q(repository_nlp_log__confidence__lte=int(value.stop) / 100),
         )
-        print(query.query)
         return query
 
 

bothub/api/v2/repository/serializers.py

@@ -477,6 +477,7 @@ class Meta:
             "ready_for_parse",
             "count_authorizations",
             "repository_score",
+            "repository_version_language",
         ]
         read_only = [
             "uuid",
@@ -493,6 +494,7 @@ class Meta:
             "is_organization",
             "ready_for_parse",
             "count_authorizations",
+            "repository_version_language",
         ]
         ref_name = None
 
@@ -600,6 +602,7 @@ class Meta:
         style={"show": False}, read_only=True, source="repository.count_authorizations"
     )
     repository_score = serializers.SerializerMethodField(style={"show": False})
+    repository_version_language = serializers.SerializerMethodField(style={"show": False})
 
     def get_authorizations(self, obj):
         auths = RepositoryAuthorization.objects.filter(
@@ -845,13 +848,17 @@ def get_nlp_server(self, obj):
     def get_version_default(self, obj):
         return {
             "id": obj.repository.current_version().repository_version.pk,
+            "repository_version_language_id": obj.repository.current_version().pk,
             "name": obj.repository.current_version().repository_version.name,
         }
 
     def get_repository_score(self, obj):
         score, created = obj.repository.repository_score.get_or_create()
         return RepositoryScoreSerializer(score).data
 
+    def get_repository_version_language(self, obj):
+        return obj.repositoryversionlanguage_set.all().values("id", "language")
+
 
 class RepositoryTrainInfoSerializer(serializers.ModelSerializer):
     class Meta:

bothub/api/v2/tests/test_account.py

@@ -62,15 +62,22 @@ def request(self, data):
         content_data = json.loads(response.content)
         return (response, content_data)
 
-    @override_settings(DRF_RECAPTCHA_SECRET_KEY="6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe")
+    @override_settings(
+        DRF_RECAPTCHA_SECRET_KEY="6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe"
+    )
     def test_okay(self):
         email = "fake@user.com"
         password = "abc!1234"
 
-        response, content_data = self.request({
-            "email": email, "name": "Fake", "nickname": "fake",
-            "password": password, "recaptcha": "RECAPTCHA-TOKEN"
-        })
+        response, content_data = self.request(
+            {
+                "email": email,
+                "name": "Fake",
+                "nickname": "fake",
+                "password": password,
+                "recaptcha": "RECAPTCHA-TOKEN",
+            }
+        )
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         user = User.objects.get(email=email)
         self.assertTrue(user.check_password(password))
@@ -84,14 +91,22 @@ def test_invalid_recaptcha(self):
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertIn("recaptcha", content_data.keys())
 
-        response, content_data = self.request({
-            "email": email, "name": "Fake", "nickname": "fake",
-            "password": password, "recaptcha": "WRONG-RECAPTCHA-TOKEN"
-        })
+        response, content_data = self.request(
+            {
+                "email": email,
+                "name": "Fake",
+                "nickname": "fake",
+                "password": password,
+                "recaptcha": "WRONG-RECAPTCHA-TOKEN",
+            }
+        )
 
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertIn("recaptcha", content_data.keys())
-        self.assertIn(_("The response parameter is invalid or malformed."), content_data.get("recaptcha"))
+        self.assertIn(
+            _("The response parameter is invalid or malformed."),
+            content_data.get("recaptcha"),
+        )
 
     def test_invalid_password(self):
         response, content_data = self.request(

bothub/api/v2/tests/test_logs.py

@@ -179,7 +179,8 @@ def request(self, data, token=None):
 
     def test_okay(self):
         response, content_data = self.request(
-            {"repository_uuid": str(self.repository.uuid)}, self.owner_token
+            {"repository_version_language": int(self.repository.current_version().pk)},
+            self.owner_token,
         )
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(content_data.get("count"), 1)

bothub/common/models.py

@@ -380,9 +380,7 @@ def save(
     def request_nlp_train(self, user_authorization, data):
         try:  # pragma: no cover
             url = f"{self.nlp_server if self.nlp_server else settings.BOTHUB_NLP_BASE_URL}train/"
-            data = {
-                "repository_version": data.get("repository_version")
-            }
+            data = {"repository_version": data.get("repository_version")}
             headers = {"Authorization": f"Bearer {user_authorization.uuid}"}
 
             r = requests.post(url, data=json.dumps(data), headers=headers)