Merge branch 'develop' into feature/add_type_repository

bothub/api/v2/nlp/views.py

@@ -500,6 +500,55 @@ def evaluate_results_score(self, request, **kwargs):
         return Response({})
 
 
+class RepositoryAuthorizationAutomaticEvaluateViewSet(
+    mixins.RetrieveModelMixin, GenericViewSet
+):
+    queryset = RepositoryAuthorization.objects
+    serializer_class = NLPSerializer
+    permission_classes = [AllowAny]
+    authentication_classes = [NLPAuthentication]
+
+    def retrieve(self, request, *args, **kwargs):
+        check_auth(request)
+        repository_authorization = self.get_object()
+
+        if not repository_authorization.can_contribute:
+            raise PermissionDenied()
+
+        language = request.query_params.get("language")
+        repository_version = request.query_params.get("repository_version")
+
+        repository = repository_authorization.repository
+
+        if repository_version:
+            repository_version_language = repository.get_specific_version_id(
+                repository_version=repository_version, language=language
+            )
+        else:
+            repository_version_language = repository.get_specific_version_language(
+                language=language
+            )
+
+        try:
+            repository.validate_if_can_run_automatic_evaluate(language=language)
+            can_run_automatic_evaluate = True
+        except ValidationError:
+            can_run_automatic_evaluate = False
+
+        return Response(
+            {
+                "language": repository.language,
+                "repository_version_language_id": repository_version_language.pk,
+                "user_id": repository_authorization.user.pk,
+                "algorithm": repository.algorithm,
+                "use_name_entities": repository.use_name_entities,
+                "use_competing_intents": repository.use_competing_intents,
+                "use_analyze_char": repository.use_analyze_char,
+                "can_run_automatic_evaluate": can_run_automatic_evaluate,
+            }
+        )
+
+
 class NLPLangsViewSet(mixins.ListModelMixin, GenericViewSet):
     queryset = RepositoryAuthorization.objects
     serializer_class = NLPSerializer

bothub/api/v2/repository/filters.py

@@ -1,16 +1,19 @@
 from django.core.exceptions import ValidationError as DjangoValidationError
 from django.db.models import Q
+from django.shortcuts import get_object_or_404
 from django.utils.translation import ugettext_lazy as _
 from django_filters import rest_framework as filters
 from rest_framework.exceptions import NotFound
 from rest_framework.exceptions import PermissionDenied
 
+from bothub.authentication.models import RepositoryOwner
 from bothub.common.models import (
     Repository,
     RepositoryNLPLog,
     RepositoryEntity,
     RepositoryQueueTask,
     RepositoryIntent,
+    OrganizationAuthorization,
 )
 from bothub.common.models import RepositoryAuthorization
 from bothub.common.models import RequestRepositoryAuthorization
@@ -19,15 +22,38 @@
 class RepositoriesFilter(filters.FilterSet):
     class Meta:
         model = Repository
-        fields = ["name", "categories"]
+        fields = ["name", "categories", "org_id", "nickname"]
 
     language = filters.CharFilter(
         field_name="language", method="filter_language", help_text=_("Language")
     )
+    org_id = filters.CharFilter(
+        method="filter_org_id", help_text=_("Repository Owner Id")
+    )
+    nickname = filters.CharFilter(
+        method="filter_nickname", help_text=_("Repository Owner Nickname")
+    )
+
+    def __filter_by_owner(self, queryset, owner):
+        if owner.is_organization:
+            auth_org = OrganizationAuthorization.objects.filter(
+                organization=owner, user=self.request.user
+            ).first()
+            if auth_org.can_read:
+                return queryset.filter(owner=owner).distinct()
+        return queryset.filter(owner=owner, is_private=False).distinct()
 
     def filter_language(self, queryset, name, value):
         return queryset.supported_language(value)
 
+    def filter_org_id(self, queryset, name, value):
+        owner = get_object_or_404(RepositoryOwner, org_id=value)
+        return self.__filter_by_owner(queryset, owner)
+
+    def filter_nickname(self, queryset, name, value):
+        owner = get_object_or_404(RepositoryOwner, nickname=value)
+        return self.__filter_by_owner(queryset, owner)
+
 
 class RepositoryAuthorizationFilter(filters.FilterSet):
     class Meta:

bothub/api/v2/repository/views.py

@@ -627,29 +627,11 @@ class SearchRepositoriesViewSet(mixins.ListModelMixin, GenericViewSet):
 
     def get_queryset(self, *args, **kwargs):
         try:
-            if self.request.query_params.get("nickname", None):
-                owner = get_object_or_404(
-                    RepositoryOwner,
-                    nickname=self.request.query_params.get("nickname", None),
-                )
-                if owner.is_organization:
-                    auth_org = OrganizationAuthorization.objects.filter(
-                        organization=owner, user=self.request.user
-                    ).first()
-                    if auth_org.can_read:
-                        return self.queryset.filter(
-                            owner__nickname=self.request.query_params.get(
-                                "nickname", self.request.user
-                            )
-                        ).distinct()
-                return self.queryset.filter(
-                    owner__nickname=self.request.query_params.get(
-                        "nickname", self.request.user
-                    ),
-                    is_private=False,
-                ).distinct()
-            else:
+            if not self.request.query_params.get(
+                "nickname", None
+            ) and not self.request.query_params.get("org_id", None):
                 return self.queryset.filter(owner=self.request.user).distinct()
+            return super().get_queryset()
         except TypeError:
             return self.queryset.none()
 

bothub/api/v2/routers.py

@@ -36,6 +36,7 @@
     RepositoryNLPLogsViewSet,
     RepositoryAuthorizationKnowledgeBaseViewSet,
     RepositoryAuthorizationExamplesViewSet,
+    RepositoryAuthorizationAutomaticEvaluateViewSet,
 )
 from .nlp.views import RepositoryAuthorizationParseViewSet
 from .nlp.views import RepositoryAuthorizationInfoViewSet
@@ -196,6 +197,10 @@ def get_lookup_regex(self, viewset, lookup_prefix=""):
 router.register(
     "repository/nlp/authorization/evaluate", RepositoryAuthorizationEvaluateViewSet
 )
+router.register(
+    "repository/nlp/authorization/automatic-evaluate",
+    RepositoryAuthorizationAutomaticEvaluateViewSet,
+)
 router.register("repository/nlp/authorization/langs", NLPLangsViewSet)
 router.register(
     "repository/nlp/update_interpreters", RepositoryUpdateInterpretersViewSet

bothub/api/v2/tests/test_nlp.py

@@ -9,6 +9,7 @@
     RepositoryAuthorizationTrainViewSet,
     RepositoryAuthorizationKnowledgeBaseViewSet,
     RepositoryAuthorizationExamplesViewSet,
+    RepositoryAuthorizationAutomaticEvaluateViewSet,
 )
 from bothub.api.v2.nlp.views import RepositoryAuthorizationInfoViewSet
 from bothub.common import languages
@@ -524,3 +525,73 @@ def test_get_examples(self):
         )
         self.assertEqual(response.data.get("count"), 3)
         self.assertEqual(response.data.get("results")[0].get("text"), "goodbye")
+
+
+class RepositoryAuthorizationAutomaticEvaluateTestCase(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+
+        self.owner, self.owner_token = create_user_and_token("owner")
+        self.user, self.user_token = create_user_and_token()
+
+        self.repository = Repository.objects.create(
+            owner=self.owner,
+            name="Testing",
+            slug="test",
+            language=languages.LANGUAGE_EN,
+        )
+
+        self.repository_authorization = RepositoryAuthorization.objects.create(
+            user=self.user, repository=self.repository, role=3
+        )
+
+        self.repository_version = RepositoryVersion.objects.create(
+            repository=self.repository, name="test"
+        )
+
+        self.repository_version_language = RepositoryVersionLanguage.objects.create(
+            repository_version=self.repository_version,
+            language=languages.LANGUAGE_EN,
+            algorithm="neural_network_internal",
+        )
+
+    def request(self, token, repository_version=""):
+        authorization_header = {"HTTP_AUTHORIZATION": "Bearer {}".format(token)}
+        request = self.factory.get(
+            "/v2/repository/nlp/authorization/automatic-evaluate/{}/".format(token),
+            {
+                "repository_version": repository_version,
+                "language": languages.LANGUAGE_EN,
+            },
+            **authorization_header
+        )
+        response = RepositoryAuthorizationAutomaticEvaluateViewSet.as_view(
+            {"get": "retrieve"}
+        )(request, pk=token)
+        response.render()
+        content_data = json.loads(response.content)
+        return (response, content_data)
+
+    def test_ok(self):
+        response, content_data = self.request(
+            str(self.repository_authorization.uuid),
+            repository_version=self.repository_version.pk,
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_not_auth(self):
+        response, content_data = self.request(
+            str(uuid.uuid4()), repository_version=self.repository_version.pk
+        )
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+    def test_route(self):
+        response, content_data = self.request(
+            str(self.repository_authorization.uuid),
+            repository_version=self.repository_version.pk,
+        )
+        self.assertFalse(content_data.get("can_run_automatic_evaluate"))
+        self.assertEqual(
+            content_data.get("repository_version_language_id"),
+            self.repository_version_language.pk,
+        )