def test_no_form_parameters_with_non_form_parsers(): # see https://github.com/joellefkowitz/drf-yasg/issues/270 # test that manual form parameters for views that haven't set # all their parsers classes to form parsers are not allowed # even when the request body is empty @method_decorator( name="post", decorator=swagger_auto_schema( operation_description="Logins a user and returns a token", manual_parameters=[ openapi.Parameter( "username", openapi.IN_FORM, required=True, type=openapi.TYPE_STRING, description="Valid username or email for authentication", ), ], ), ) class CustomObtainAuthToken(ObtainAuthToken): throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES urlpatterns = [ url(r"token/$", CustomObtainAuthToken.as_view()), ] generator = OpenAPISchemaGenerator( info=openapi.Info(title="Test generator", default_version="v1"), patterns=urlpatterns, ) with pytest.raises(SwaggerGenerationError): generator.get_schema(None, True)
@method_decorator( name="retrieve", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "with_translation", openapi.IN_QUERY, description= "Boolean that allows you to download or not all translations", type=openapi.TYPE_BOOLEAN, default=True, ), openapi.Parameter( "of_the_language", openapi.IN_QUERY, description="Choose the language to be translated", type=openapi.TYPE_STRING, required=True, ), openapi.Parameter( "for_the_language", openapi.IN_QUERY, description="Which language will be translated", type=openapi.TYPE_STRING, required=True, ), ]), ) class RepositoryTranslatedExporterViewSet( MultipleFieldLookupMixin, mixins.RetrieveModelMixin,
serializer.is_valid(raise_exception=True) return Response(serializer.data) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "feature", openapi.IN_QUERY, "ID of the feature to filter by.", required=False, type=openapi.TYPE_INTEGER, ), openapi.Parameter( "anyIdentity", openapi.IN_QUERY, "Pass any value to get results that have an identity override. " "Do not pass for default behaviour.", required=False, type=openapi.TYPE_STRING, ), ]), ) class FeatureStateViewSet(viewsets.ModelViewSet): """ View set to manage feature states. Nested beneath environments and environments + identities to allow for filtering on both. """
from authentication.models import Subscription, Author from authentication.serializers import SubscriptionSerializer from lessons.models import Lesson, Vote from lessons.pagination import ResultSetPagination from lessons.permissions import IsOwner from lessons.serializers import LessonSerializer from django.http import JsonResponse from rest_framework.response import Response from lessons.task import send_notify_email @method_decorator(name='partial_update', decorator=swagger_auto_schema(auto_schema=None)) class LessonViewSet(viewsets.ModelViewSet): authentication_classes = (JWTAuthentication, ) queryset = Lesson.objects.all() serializer_class = LessonSerializer permission_classes = [permissions.IsAuthenticatedOrReadOnly, IsOwner] filterset_fields = ['creator'] pagination_class = ResultSetPagination def perform_create(self, serializer): """Create lessons""" try: author = Author.objects.get(user=self.request.user) except Author.DoesNotExist: author = Author(user=self.request.user) author.save()
class NoPagingAutoSchema(NoTitleAutoSchema): def should_page(self): return False class ArticlePagination(LimitOffsetPagination): default_limit = 5 max_limit = 25 @method_decorator( name="list", decorator=swagger_auto_schema( operation_description= "description from swagger_auto_schema via method_decorator", filter_inspectors=[DjangoFilterDescriptionInspector], ), ) class ArticleViewSet(viewsets.ModelViewSet): """ ArticleViewSet class docstring retrieve: retrieve class docstring destroy: destroy class docstring partial_update: partial_update class docstring
from rest_framework.permissions import IsAuthenticated from rest_framework.response import Response from environments.serializers import EnvironmentSerializerLight from permissions.serializers import PermissionModelSerializer, MyUserObjectPermissionsSerializer from projects.models import UserPermissionGroupProjectPermission, UserProjectPermission, Project, ProjectPermissionModel from projects.permissions import ProjectPermissions, NestedProjectPermissions from projects.serializers import ProjectSerializer, CreateUpdateUserProjectPermissionSerializer, ListUserProjectPermissionSerializer, \ ListUserPermissionGroupProjectPermissionSerializer, CreateUpdateUserPermissionGroupProjectPermissionSerializer @method_decorator(name='list', decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter('organisation', openapi.IN_QUERY, 'ID of the organisation to filter by.', required=False, type=openapi.TYPE_INTEGER) ])) class ProjectViewSet(viewsets.ModelViewSet): serializer_class = ProjectSerializer permission_classes = [IsAuthenticated, ProjectPermissions] pagination_class = None def get_queryset(self): user = self.request.user queryset = user.get_permitted_projects(permissions=['VIEW_PROJECT']) organisation_id = self.request.query_params.get("organisation") if organisation_id: queryset = queryset.filter(organisation__id=organisation_id)
project_query_param = openapi.Parameter( 'project', openapi.IN_QUERY, description='ID of the project to filter on', type=openapi.TYPE_INTEGER) environment_query_param = openapi.Parameter( 'environment', openapi.IN_QUERY, description='ID of the environment to filter on ' '(Note `id` required, not `api_key`)', type=openapi.TYPE_INTEGER) @method_decorator( name='list', decorator=swagger_auto_schema( manual_parameters=[project_query_param, environment_query_param])) class AuditLogViewSet(mixins.ListModelMixin, viewsets.GenericViewSet): serializer_class = AuditLogSerializer def get_queryset(self): q = Q(project__organisation__in=self.request.user.organisations.all()) if 'project' in self.request.query_params: project_id = self._get_value_as_int( self.request.query_params.get('project')) q = q & Q(project__id=project_id) if 'environment' in self.request.query_params: environment_id = self._get_value_as_int( self.request.query_params.get('environment')) q = q & (Q(environment__id=environment_id) | Q(environment=None)) return AuditLog.objects.filter(q)
EnvironmentPermissionModel, UserEnvironmentPermission, UserPermissionGroupEnvironmentPermission, ) from .serializers import EnvironmentSerializerLight, WebhookSerializer logger = logging.getLogger(__name__) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "project", openapi.IN_QUERY, "ID of the project to filter by.", required=False, type=openapi.TYPE_INTEGER, ) ]), ) class EnvironmentViewSet(viewsets.ModelViewSet): lookup_field = "api_key" permission_classes = [IsAuthenticated, EnvironmentPermissions] def get_serializer_class(self): if self.action == "trait_keys": return TraitKeysSerializer if self.action == "delete_traits": return DeleteAllTraitKeysSerializer return EnvironmentSerializerLight
from .filters import EvaluatesFilter from .filters import EvaluateResultsFilter from .filters import EvaluateResultFilter from .permissions import RepositoryEvaluatePermission from .permissions import RepositoryEvaluateResultPermission @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository UUID, calling " "the parameter through url", type=openapi.TYPE_STRING, required=True, ) ]), ) @method_decorator( name="create", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository UUID, calling " "the parameter through url", type=openapi.TYPE_STRING, required=True,
from rest_framework import mixins, viewsets from rest_framework.decorators import action from rest_framework.response import Response from features.models import FeatureSegment from features.feature_segments.serializers import ( FeatureSegmentCreateSerializer, FeatureSegmentQuerySerializer, FeatureSegmentListSerializer, FeatureSegmentChangePrioritiesSerializer, ) @method_decorator( name="list", decorator=swagger_auto_schema( query_serializer=FeatureSegmentQuerySerializer()), ) @method_decorator( name="update_priorities", decorator=swagger_auto_schema( responses={200: FeatureSegmentListSerializer(many=True)}), ) class FeatureSegmentViewSet( mixins.ListModelMixin, mixins.CreateModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, viewsets.GenericViewSet, ): def get_queryset(self): permitted_projects = self.request.user.get_permitted_projects(
example="example company")), ("accepted_terms", openapi.Schema(type=openapi.TYPE_BOOLEAN)), ( "registration_stage", openapi.Schema(type=openapi.TYPE_STRING, example="CUSTOMER"), ), )), ) ######### # views # ######### @method_decorator( swagger_auto_schema(request_body=_login_schema, responses={status.HTTP_200_OK: KnoxTokenSerializer}), name="post", ) @method_decorator(sensitive_post_parameters("password"), name="dispatch") class LoginView(RestAuthLoginView): """ Just like rest_auth.LoginView but removes all of the JWT logic (no need to override login/save - that is all done in the serializer) """ permission_classes = [IsNotAuthenticated] def get_success_response(self): # this creates a response based on the KnoxTokenSerializer # (and its nested LoginSerializer) serializer_class = self.get_response_serializer()
class RepositoryViewSet( mixins.CreateModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, GenericViewSet, ): """ Manager repository (bot). """ queryset = Repository.objects lookup_field = "uuid" lookup_fields = ["uuid"] serializer_class = RepositorySerializer permission_classes = [IsAuthenticatedOrReadOnly, RepositoryPermission] metadata_class = Metadata @method_decorator(name="list", decorator=swagger_auto_schema(deprecated=True)) @action( detail=True, methods=["GET"], url_name="repository-languages-status", lookup_fields=["uuid"], ) def languagesstatus(self, request, **kwargs): """ Get current language status. """ if self.lookup_field not in kwargs: return Response(status=405) repository = self.get_object() return Response({"languages_status": repository.languages_status}) @action( detail=True, methods=["POST"], url_name="repository-train", lookup_fields=["uuid"], serializer_class=TrainSerializer, ) def train(self, request, **kwargs): """ Train current update using Bothub NLP service """ repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) serializer = TrainSerializer(data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover if not user_authorization.can_write: raise PermissionDenied() request = repository.request_nlp_train( user_authorization, serializer.data) # pragma: no cover if request.status_code != status.HTTP_200_OK: # pragma: no cover raise APIException( # pragma: no cover {"status_code": request.status_code}, code=request.status_code) return Response(request.json()) # pragma: no cover @action( detail=True, methods=["POST"], url_name="repository-analyze", permission_classes=[], lookup_fields=["uuid"], serializer_class=AnalyzeTextSerializer, ) def analyze(self, request, **kwargs): repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) serializer = AnalyzeTextSerializer( data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover request = repository.request_nlp_analyze( user_authorization, serializer.data) # pragma: no cover if request.status_code == status.HTTP_200_OK: # pragma: no cover return Response(request.json()) # pragma: no cover response = None # pragma: no cover try: # pragma: no cover response = request.json() # pragma: no cover except Exception: pass if not response: # pragma: no cover raise APIException( # pragma: no cover detail=_("Something unexpected happened! " + "We couldn't analyze your text.")) error = response.get("error") # pragma: no cover message = error.get("message") # pragma: no cover raise APIException(detail=message) # pragma: no cover @action( detail=True, methods=["POST"], url_name="repository-question-answering", permission_classes=[], lookup_fields=["uuid"], serializer_class=AnalyzeQuestionSerializer, ) def question(self, request, **kwargs): repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) serializer = AnalyzeQuestionSerializer(data=request.data) serializer.is_valid(raise_exception=True) request = repository.request_nlp_qa(user_authorization, serializer.data) if request.status_code == status.HTTP_200_OK: return Response(request.json()) response = None try: response = request.json() except Exception: pass if not response: raise APIException(detail=_("Something unexpected happened! " + "We couldn't analyze your text.")) error = response.get("error") message = error.get("message") raise APIException(detail=message) @action( detail=True, methods=["POST"], url_name="repository-debug-parse", permission_classes=[], lookup_fields=["uuid"], serializer_class=DebugParseSerializer, ) def debug_parse(self, request, **kwargs): repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) serializer = DebugParseSerializer( data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover request = repository.request_nlp_debug_parse( user_authorization, serializer.data) # pragma: no cover if request.status_code == status.HTTP_200_OK: # pragma: no cover return Response(request.json()) # pragma: no cover response = None # pragma: no cover try: # pragma: no cover response = request.json() # pragma: no cover except Exception: pass if not response: # pragma: no cover raise APIException( # pragma: no cover detail=_("Something unexpected happened! " + "We couldn't debug your text.")) error = response.get("error") # pragma: no cover message = error.get("message") # pragma: no cover raise APIException(detail=message) # pragma: no cover @action( detail=True, methods=["POST"], url_name="repository-words-distribution", permission_classes=[], lookup_fields=["uuid"], serializer_class=WordDistributionSerializer, ) def words_distribution(self, request, **kwargs): repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) serializer = WordDistributionSerializer( data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover request = repository.request_nlp_words_distribution( user_authorization, serializer.data) # pragma: no cover if request.status_code == status.HTTP_200_OK: # pragma: no cover return Response(request.json()) # pragma: no cover response = None # pragma: no cover try: # pragma: no cover response = request.json() # pragma: no cover except Exception: pass if not response: # pragma: no cover raise APIException( # pragma: no cover detail=_("Something unexpected happened! " + "We couldn't debug your text.")) error = response.get("error") # pragma: no cover message = error.get("message") # pragma: no cover raise APIException(detail=message) # pragma: no cover @action( detail=True, methods=["POST"], url_name="repository-evaluate", lookup_fields=["uuid"], serializer_class=EvaluateSerializer, ) def evaluate(self, request, **kwargs): """ Manual evaluate repository using Bothub NLP service """ repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) if not user_authorization.can_write: raise PermissionDenied() serializer = EvaluateSerializer(data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover try: request = repository.request_nlp_manual_evaluate( # pragma: no cover user_authorization, serializer.data) except DjangoValidationError as e: raise APIException(e.message, code=400) if request.status_code != status.HTTP_200_OK: # pragma: no cover raise APIException({"status_code": request.status_code}, code=request.status_code) # pragma: no cover return Response(request.json()) # pragma: no cover @action( detail=True, methods=["POST"], url_name="repository-automatic-evaluate", lookup_fields=["uuid"], serializer_class=EvaluateSerializer, ) def automatic_evaluate(self, request, **kwargs): """ Automatic evaluate repository using Bothub NLP service """ repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) if not user_authorization.can_write: raise PermissionDenied() serializer = EvaluateSerializer(data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover try: request = repository.request_nlp_automatic_evaluate( # pragma: no cover user_authorization, serializer.data) except DjangoValidationError as e: raise APIException(e.message, code=400) if request.status_code != status.HTTP_200_OK: # pragma: no cover raise APIException({"status_code": request.status_code}, code=request.status_code) # pragma: no cover return Response(request.json()) # pragma: no cover @action( detail=True, methods=["GET"], url_name="check-can-repository-automatic-evaluate", lookup_fields=["uuid"], ) def check_can_automatic_evaluate(self, request, **kwargs): """ Check if repository can run automatic evaluate. """ repository = self.get_object() user_authorization = repository.get_user_authorization(request.user) if not user_authorization.can_write: raise PermissionDenied() language = request.query_params.get("language") if not language: raise ValidationError(_("Need to pass 'language' in query params")) try: repository.validate_if_can_run_automatic_evaluate( language=language) response = {"can_run_evaluate_automatic": True, "messages": []} except DjangoValidationError as e: response = {"can_run_evaluate_automatic": False, "messages": e} return Response(response) # pragma: no cover
class RepositoryIntentViewSet( mixins.ListModelMixin, mixins.RetrieveModelMixin, mixins.DestroyModelMixin, mixins.UpdateModelMixin, GenericViewSet, ): queryset = RepositoryIntent.objects filter_class = RepositoryIntentFilter serializer_class = RepositoryIntentSerializer permission_classes = [RepositoryIntentPermission] def retrieve(self, request, *args, **kwargs): self.filter_class = None return super().retrieve(request, *args, **kwargs) def destroy(self, request, *args, **kwargs): self.filter_class = None return super().destroy(request, *args, **kwargs) def update(self, request, *args, **kwargs): self.filter_class = None return super().update(request, *args, **kwargs) @method_decorator(decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "language", openapi.IN_QUERY, description="Repository version language to suggest, " "if none, Repository language will be used", type=openapi.TYPE_STRING, ) ])) @action( detail=True, methods=["GET"], url_name="intent-suggestions", serializer_class=RepositoryIntentSerializer, permission_classes=[permissions.IsAuthenticated], ) def intent_suggestions(self, request, **kwargs): """ Get 10 suggestions for intent on your self language """ self.filter_class = None intent = self.get_object() language = self.request.query_params.get("language") authorization = intent.repository_version.repository.get_user_authorization( request.user) if not authorization.can_read: raise PermissionDenied() task = celery_app.send_task( name="intent_suggestions", args=[intent.pk, language, str(authorization.pk)]) task.wait() suggestions = task.result return Response({"suggestions": suggestions})
response = {"can_run_evaluate_automatic": True, "messages": []} except DjangoValidationError as e: response = {"can_run_evaluate_automatic": False, "messages": e} return Response(response) # pragma: no cover @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "user", openapi.IN_QUERY, description="Nickname User to find repositories votes", type=openapi.TYPE_STRING, ), openapi.Parameter( "repository", openapi.IN_QUERY, description="Repository UUID, returns a list of " "users who voted for this repository", type=openapi.TYPE_STRING, ), ]), ) class RepositoryVotesViewSet( mixins.CreateModelMixin, mixins.DestroyModelMixin, mixins.ListModelMixin, GenericViewSet, ): """
auto_schema_kwargs = { "responses": { status.HTTP_200_OK: openapi.Schema( type=openapi.TYPE_OBJECT, properties=OrderedDict(( ("key", openapi.Schema(type=openapi.TYPE_STRING, example="value")), )) ) } } # yapf: disable @method_decorator(swagger_auto_schema(**auto_schema_kwargs), name="get") @method_decorator(swagger_auto_schema(**auto_schema_kwargs), name="put") @method_decorator(swagger_auto_schema(**auto_schema_kwargs), name="patch") class UserProfileView(generics.RetrieveUpdateAPIView): """ API to retrive/update a specific profile; Even though all profiles are output as part of the UserView, this allows the client to access a profile directly. """ permission_classes = [IsAuthenticated, IsAdminOrSelf] @cached_property def user(self): user_id = self.kwargs["user_id"] user = get_object_or_404(get_user_model(), uuid=user_id) return user
from django.utils.decorators import method_decorator from drf_yasg2 import openapi from drf_yasg2.utils import swagger_auto_schema from rest_framework import viewsets from rest_framework import permissions from rest_framework.authtoken.models import Token from rest_framework.decorators import action from rest_framework.response import Response from . import models from . import serializers @method_decorator(name='list', decorator=swagger_auto_schema( operation_summary='获取所有用户资料', operation_id='获取所有用户资料', operation_description='获取所有用户资料')) @method_decorator(name='retrieve', decorator=swagger_auto_schema(operation_summary='获取指定用户资料')) @method_decorator(name='create', decorator=swagger_auto_schema(operation_summary='添加用户资料')) @method_decorator(name='update', decorator=swagger_auto_schema(operation_summary='修改指定用户资料')) @method_decorator(name='partial_update', decorator=swagger_auto_schema(operation_summary='部分修改指定用户资料') ) @method_decorator(name='destroy', decorator=swagger_auto_schema(operation_summary='删除指定用户资料')) class UserProfileViewSet(viewsets.ModelViewSet): serializer_class = serializers.UserProfileSerializer queryset = models.UserProfile.objects.all()
serializer = FeatureInfluxDataSerializer( instance={"events_list": events_list}) return Response(serializer.data) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "feature", openapi.IN_QUERY, "ID of the feature to filter by.", required=False, type=openapi.TYPE_INTEGER, ), openapi.Parameter( "anyIdentity", openapi.IN_QUERY, "Pass any value to get results that have an identity override. " "Do not pass for default behaviour.", required=False, type=openapi.TYPE_STRING, ), ]), ) class FeatureStateViewSet(viewsets.ModelViewSet): """ View set to manage feature states. Nested beneath environments and environments + identities to allow for filtering on both. """
from drf_yasg2 import openapi from drf_yasg2.utils import swagger_auto_schema from bothub.common.models import QAKnowledgeBase, QAtext from .filters import QAKnowledgeBaseFilter, QAtextFilter from .permissions import QAKnowledgeBasePermission, QAtextPermission from .serializers import QAKnowledgeBaseSerializer, QAtextSerializer @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository's UUID", required=True, type=openapi.TYPE_STRING, format="uuid", ), ]), ) class QAKnowledgeBaseViewSet( mixins.ListModelMixin, mixins.CreateModelMixin, mixins.RetrieveModelMixin, mixins.DestroyModelMixin, mixins.UpdateModelMixin, GenericViewSet, ): queryset = QAKnowledgeBase.objects.all() serializer_class = QAKnowledgeBaseSerializer
users is intentionally unsupported outside of the Django Admin. """ pass _user_viewset_params = [ # despite specifying a custom "lookup_field", drf_yasg2 insists on # treating "id" as an IntegerField; so I override the schema params openapi.Parameter("id", openapi.IN_PATH, type=openapi.TYPE_STRING) ] @method_decorator( name="retrieve", decorator=swagger_auto_schema(manual_parameters=_user_viewset_params) ) @method_decorator( name="update", decorator=swagger_auto_schema(manual_parameters=_user_viewset_params) ) class UserViewSet(ListRetrieveUpdateViewSet): permission_classes = [IsAuthenticated, IsAdminOrSelf] serializer_class = UserSerializer filter_backends = (filters.DjangoFilterBackend, ) filterset_class = UserFilterSet queryset = User.objects.prefetch_related("roles", "roles__permissions") lookup_field = "uuid"
from rest_framework.viewsets import GenericViewSet from bothub.api.v2.metadata import Metadata from bothub.authentication.models import User, RepositoryOwner from bothub.common.models import Repository, RepositoryVersion from .serializers import ChangePasswordSerializer from .serializers import LoginSerializer from .serializers import RegisterUserSerializer from .serializers import RequestResetPasswordSerializer from .serializers import ResetPasswordSerializer from .serializers import UserSerializer @method_decorator( name="create", decorator=swagger_auto_schema(responses={201: '{"token":"TOKEN"}'})) class LoginViewSet(mixins.CreateModelMixin, GenericViewSet): """ Login Users """ queryset = User.objects serializer_class = LoginSerializer lookup_field = ("username", "password") metadata_class = Metadata def create(self, request, *args, **kwargs): serializer = self.serializer_class(data=request.data, context={"request": request}) serializer.is_valid(raise_exception=True) user = serializer.validated_data["user"]
from util.views import SDKAPIView from . import serializers from .permissions import SegmentPermissions logger = logging.getLogger() logger.setLevel(logging.INFO) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "identity", openapi.IN_QUERY, "Optionally provide the id of an identity to get only the segments they match", required=False, type=openapi.TYPE_INTEGER, ) ]), ) class SegmentViewSet(viewsets.ModelViewSet): serializer_class = serializers.SegmentSerializer permission_classes = [SegmentPermissions] def get_queryset(self): project = get_object_or_404( self.request.user.get_permitted_projects(["VIEW_PROJECT"]), pk=self.kwargs["project_pk"], ) queryset = project.segments.all()
class ExamplesViewSet(mixins.ListModelMixin, GenericViewSet): queryset = RepositoryExample.objects serializer_class = RepositoryExampleSerializer filter_class = ExamplesFilter filter_backends = [OrderingFilter, SearchFilter, DjangoFilterBackend] search_fields = ["$text", "^text", "=text"] ordering_fields = ["created_at"] permission_classes = [RepositoryExamplePermission] @method_decorator( name="create", decorator=swagger_auto_schema( request_body=openapi.Schema( type=openapi.TYPE_OBJECT, properties={ "repositories": openapi.Schema( description="UUID of the repository", type=openapi.TYPE_ARRAY, items=openapi.Schema(type=openapi.TYPE_STRING), ), "text": openapi.Schema(type=openapi.TYPE_STRING), "language": openapi.Schema(type=openapi.TYPE_STRING, description="Language abbreviation"), "exclude_intents": openapi.Schema( description= "Specify the intentions you want to remove from the search", type=openapi.TYPE_ARRAY, items=openapi.Schema(type=openapi.TYPE_STRING), ), }, ), responses={ 200: RepositoriesSearchExamplesResponseSerializer(many=True) }, ), ) @action( detail=True, methods=["POST"], url_name="repositories-examples", permission_classes=[], ) def search_repositories_examples(self, request, **kwargs): authorization = request.stream.headers.get("Authorization") if not authorization == settings.TOKEN_SEARCH_REPOSITORIES: raise PermissionDenied() serializer = RepositoriesSearchExamplesSerializer( data=request.data) # pragma: no cover serializer.is_valid(raise_exception=True) # pragma: no cover repositories = self.request.data.get("repositories") language = self.request.data.get("language") text = self.request.data.get("text") exclude_intents = self.request.data.get("exclude_intents", []) examples = (RepositoryExample.objects.exclude( intent__text__in=exclude_intents ).filter( Q(repository_version_language__language=language) | Q(translations__repository_version_language__language=language), repository_version_language__repository_version__is_default=True, repository_version_language__repository_version__repository__in= repositories, ).filter( Q(text__unaccent__trigram_similar=text) | Q(translations__text__unaccent__trigram_similar=text)).distinct( )) return Response({ "result": [example.get_text(language=language) for example in examples[:5]] })