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]]
})
