class BlogPostHeaderView(views.APIView):
permission_classes = (IsAuthenticated,
IsStaffBlogCreator | IsStaffBlogModerator)
parser_classes = (MultiPartParser, )
@swagger_auto_schema(
manual_parameters=[
Parameter('post_id', IN_PATH, type='string($uuid)'),
Parameter('file', IN_FORM, type='file')
],
responses={
200: '"message": "Nagłówek został pomyślnie utworzony"',
400: '"error": "Nie znaleziono pliku"',
404: '"error": "Nie znaleziono podanego posta"'
},
)
def post(self, request, post_id):
existing_header = BlogPostHeader.objects.filter(blog_post_id=post_id)
existing_header.delete()
blog_post = BlogPost.objects.filter(id=post_id).first()
if not blog_post:
return ErrorResponse('Nie znaleziono podanego posta',
status.HTTP_404_NOT_FOUND)
try:
data = {'blog_post': post_id, 'file': request.FILES['file']}
except MultiValueDictKeyError:
return ErrorResponse(
'Nie znaleziono pliku. Upewnij się, że został on załączony pod kluczem file',
status.HTTP_400_BAD_REQUEST)
serializer = BlogPostHeaderSerializer(data=data)
if serializer.is_valid():
serializer.save()
else:
return ErrorResponse(serializer.errors,
status.HTTP_400_BAD_REQUEST)
response_data = {"message": "Nagłówek został pomyślnie utworzony"}
return Response(response_data, status.HTTP_200_OK)
@swagger_auto_schema(manual_parameters=[
Parameter('post_id', IN_PATH, type='string($uuid)'),
],
responses={
200:
'"message": "Nagłówek został pomyślnie usunięty"',
404: '"error": "Post o danym id nie ma nagłówka"'
})
def delete(self, request, post_id):
header = BlogPostHeader.objects.filter(blog_post_id=post_id)
if not header:
return ErrorResponse("Post o danym id nie ma nagłówka",
status.HTTP_404_NOT_FOUND)
header = BlogPostHeader.objects.get(blog_post_id=post_id)
header.delete()
response_data = {"message": "Nagłówek został pomyślnie usunięty"}
return Response(response_data, status.HTTP_200_OK)
class ConnectedDeviceViewSet(ViewSet):
"""
This endpoint allows a user to determine what device (if any) is connected to a given peer device and peer
interface. This is useful in a situation where a device boots with no configuration, but can detect its neighbors
via a protocol such as LLDP. Two query parameters must be included in the request:
* `peer-device`: The name of the peer device
* `peer-interface`: The name of the peer interface
"""
permission_classes = [IsAuthenticatedOrLoginNotRequired]
_device_param = Parameter('peer-device', 'query',
description='The name of the peer device', required=True, type=openapi.TYPE_STRING)
_interface_param = Parameter('peer-interface', 'query',
description='The name of the peer interface', required=True, type=openapi.TYPE_STRING)
def get_view_name(self):
return "Connected Device Locator"
@swagger_auto_schema(
manual_parameters=[_device_param, _interface_param], responses={'200': serializers.DeviceSerializer})
def list(self, request):
peer_device_name = request.query_params.get(self._device_param.name)
peer_interface_name = request.query_params.get(self._interface_param.name)
if not peer_device_name or not peer_interface_name:
raise MissingFilterException(detail='Request must include "peer-device" and "peer-interface" filters.')
# Determine local interface from peer interface's connection
peer_interface = get_object_or_404(Interface, device__name=peer_device_name, name=peer_interface_name)
local_interface = peer_interface.connected_interface
if local_interface is None:
return Response()
return Response(serializers.DeviceSerializer(local_interface.device, context={'request': request}).data)
class OrganizationCreateView(GenericAPIView):
queryset = Organization.objects.all()
serializer_class = OrganizationSerializer
initial_date_parameter = Parameter('initial_date',
IN_QUERY,
'Querystring initial_date',
format='YYYY-MM-DD',
type=TYPE_STRING,
required=False)
end_date_parameter = Parameter('end_date',
IN_QUERY,
'Querystring end_date',
format='YYYY-MM-DD',
type=TYPE_STRING,
required=False)
slug_parameter = Parameter('slug',
IN_PATH,
'Nome da empresa a ser operada.',
type=TYPE_STRING,
required=True)
@swagger_auto_schema(operation_summary="Deletar organização.",
manual_parameters=[slug_parameter])
def delete(self, request, slug: str):
if organization := Organization.objects.filter(slug=slug).first():
organization.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(data={"error": "Org não cadastrada!"},
status=status.HTTP_404_NOT_FOUND)
class CourseByNameSemesterYearView(AlwaysIsAuthenticatedMixin, APIView):
swagger_schema = AGModelViewAutoSchema
api_tags = [APITags.courses]
@swagger_auto_schema(request_body_parameters=[
Parameter('name', in_='path', type='string', required=True),
Parameter(
'semester',
in_='path',
type='string',
required=True,
description='Must be one of: ' +
f'{", ".join((semester.value for semester in ag_models.Semester))}'
),
Parameter('year', in_='path', type='integer', required=True)
])
def get(self, request: Request, *args, **kwargs):
name = kwargs.get('name')
semester = kwargs.get('semester')
try:
semester = ag_models.Semester(semester)
except ValueError:
return response.Response(status=status.HTTP_400_BAD_REQUEST,
data=f'Invalid semester: {semester}')
year = kwargs.get('year')
course = get_object_or_404(ag_models.Course.objects,
name=name,
semester=semester,
year=year)
return response.Response(course.to_dict())
class EventsViewSet(ListModelFilterBetweenDatesMixin, mixins.CreateModelMixin,
mixins.RetrieveModelMixin, mixins.UpdateModelMixin,
mixins.DestroyModelMixin, viewsets.GenericViewSet):
serializer_class = EventModelSerializer
permission_classes = [IsAuthenticated, IsAccountOwner]
lookup_field = 'code'
def get_queryset(self):
return Event.objects.filter(owner=self.request.user)
def perform_create(self, serializer):
serializer.save(owner=self.request.user)
@swagger_auto_schema(manual_parameters=[
Parameter('from',
IN_QUERY,
description='Beginning date of events',
type=TYPE_STRING),
Parameter('to',
IN_QUERY,
description='End date of events',
type=TYPE_STRING),
])
def list(self, request, *args, **kwargs):
return super().list(request, *args, **kwargs)
class PhoneBillView(viewsets.GenericViewSet, mixins.ListModelMixin):
queryset = TelephoneBill.objects.all()
serializer_class = TelephoneBillSerializer
pagination_class = DefaultPagination
@swagger_auto_schema(manual_parameters=[
Parameter(
'subscriber_telephone_number',
'query',
description='The subscriber telephone number. Ex: 48984359057',
required=True,
type='string'),
Parameter('reference_period',
'query',
description='The reference period (month/year). Ex: 08/2019',
required=False,
type='string')
])
def list(self, request, *args, **kwargs):
filters = (Q())
subscriber_telephone_number = self.request.query_params.get(
'subscriber_telephone_number')
if subscriber_telephone_number:
validate_phone_number(subscriber_telephone_number)
filters.add(Q(source=subscriber_telephone_number), Q.AND)
reference_period = self.request.query_params.get('reference_period')
if reference_period:
if '/' not in reference_period:
return Response(
{
'message':
'The reference period is not in the correct format.',
'correct_format': '(month/year). Ex: 08/2019'
}, HTTP_400_BAD_REQUEST)
month, year = reference_period.split('/')
filters.add(
Q(call_end_timestamp__month=month,
call_end_timestamp__year=year), Q.AND)
else:
today = datetime.date.today()
first_day_month = today.replace(day=1)
last_month = first_day_month - datetime.timedelta(days=1)
filters.add(
Q(call_end_timestamp__month=last_month.strftime("%m"),
call_end_timestamp__year=last_month.strftime("%Y")), Q.AND)
result_page = self.paginator.paginate_queryset(
self.queryset.filter(filters), request)
serializer = TelephoneBillSerializer(result_page, many=True)
return self.paginator.get_paginated_response(serializer.data)
class EmailVerify(views.APIView):
serializer_class = EmailVerifySerializer
token_param_config = Parameter('token',
in_=IN_QUERY,
description='Token',
type=TYPE_STRING)
@swagger_auto_schema(manual_parameters=[token_param_config])
def get(self, request):
token = request.GET.get('token')
try:
payload = decode(token,
os.environ.get('SECRET_KEY'),
algorithms='HS256')
user = User.objects.get(id=payload['user_id'])
message = 'El usuario ya ha sido activado anteriormente'
if not user.is_verified:
message = 'El usuario ha sido activado'
user.is_verified = True
user.save()
return Response({'success': message}, status=status.HTTP_200_OK)
except ExpiredSignatureError:
return Response({'error': 'El token ha expirado'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except DecodeError:
return Response({'error': 'Token incorrecto'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class BlogPostCommentUpdateView(views.APIView):
permission_classes = [IsUserCommentAuthor | IsStaffBlogModerator]
@swagger_auto_schema(manual_parameters=[
Parameter('comment_id', IN_PATH, type='string($uuid)')
],
responses={
200: "Komentarz o podanym id został usunięty",
403:
"Nie masz uprawnień, by usunąć ten komentarz",
400: "Nie znaleziono komentarza o podanym id"
})
def delete(self, request, comment_id):
try:
comment = BlogPostComment.objects.get(pk=comment_id)
except ObjectDoesNotExist:
return ErrorResponse("Nie znaleziono komentarza o podanym id",
status.HTTP_404_NOT_FOUND)
if IsUserCommentAuthor().has_object_permission(request, self, comment) or \
IsStaffBlogModerator().has_object_permission(request, self, comment):
comment.delete()
return MessageResponse("Komentarz o podanym id został usunięty")
else:
return ErrorResponse("Nie masz uprawnień, by usunąć ten komentarz",
status.HTTP_403_FORBIDDEN)
class AGTestSuiteOrderView(AGModelAPIView):
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda project: project.course)
]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related('course')
api_tags = [APITags.ag_test_suites]
@swagger_auto_schema(responses={
'200':
'Returns a list of AGTestSuite IDs, in their assigned order.'
})
def get(self, *args, **kwargs):
project = self.get_object()
return response.Response(list(project.get_agtestsuite_order()))
@swagger_auto_schema(
request_body_parameters=[
Parameter(name='',
in_='body',
type='List[string]',
description=
'A list of AGTestSuite IDs, in the new order to set.')
],
responses={
'200': 'Returns a list of AGTestSuite IDs, in their new order.'
})
def put(self, request, *args, **kwargs):
with transaction.atomic():
project = self.get_object()
project.set_agtestsuite_order(request.data)
return response.Response(list(project.get_agtestsuite_order()))
class ListCreateGroupInvitationViewSet(ListCreateNestedModelViewSet):
serializer_class = ag_serializers.SubmissionGroupInvitationSerializer
permission_classes = (list_create_invitation_permissions, )
model_manager = ag_models.Project.objects
to_one_field_name = 'project'
reverse_to_one_field_name = 'group_invitations'
@swagger_auto_schema(request_body_parameters=[
Parameter(
name='invited_usernames',
in_='body',
type='List[string]',
required=True,
description=
'The usernames to invite to be in a group with the current user.')
])
@method_decorator(require_body_params('invited_usernames'))
@transaction.atomic()
def create(self, *args, **kwargs):
for key in self.request.data:
if key != 'invited_usernames':
raise exceptions.ValidationError({'invalid_fields': [key]})
invited_users = [
User.objects.get_or_create(username=username)[0]
for username in self.request.data.pop('invited_usernames')
]
utils.lock_users(itertools.chain([self.request.user], invited_users))
self.request.data['invitation_creator'] = self.request.user
self.request.data['invited_users'] = invited_users
return super().create(self.request, *args, **kwargs)
class JobOfferApplicationView(views.APIView):
permission_classes = [IsStandardUser]
@swagger_auto_schema(
responses={
'200': JobOfferApplicationSerializer,
'403': "You do not have permission to perform this action.",
'404': "Nie posiadasz takiej aplikacji"
},
manual_parameters=[
Parameter(
'offer_id',
IN_PATH,
type='string($uuid)',
description='ID oferty, na którą aplikował obecny użytkownik')
],
operation_description=
"Zwraca aplikację obecnego użytkownika na daną ofertę pracy",
)
def get(self, request, offer_id):
user = DefaultAccount.objects.get(user=request.user)
application = JobOfferApplication.objects.filter(
cv__cv_user=user, job_offer__id=offer_id)
if not application:
return ErrorResponse("Nie posiadasz takiej aplikacji",
status.HTTP_404_NOT_FOUND)
serializer = JobOfferApplicationSerializer(application.first())
return Response(serializer.data, status.HTTP_200_OK)
def get_lookup_parameter(self):
"""Helper function that creates a `Parameter` for the lookup parameter."""
if not getattr(self.view, 'request_serializer_class', None):
for field in [
'lookup_query_field', 'lookup_arg_field', 'lookup_field'
]:
lookup_field = getattr(self.view, field, None)
if lookup_field:
description = self.get_help_text(lookup_field)
if not description:
if lookup_field == 'id':
description = 'The ID of the object'
else:
description = 'The lookup field'
return Parameter(
name=lookup_field,
in_='query',
type='string',
required=True,
description=description,
)
return None
class TileView(views.APIView):
permission_classes = [IsStaffMember]
@swagger_auto_schema(
manual_parameters=[Parameter('tile_id', IN_PATH, type='integer')],
responses={
200: '"message": "Kafelek o podanym id został zaktualizowany"',
403: 'Forbidden - no permissions',
404: '"error": "Nie znaleziono kafelka o podanym id"'
})
def put(self, request, tile_id):
try:
instance = Tile.objects.get(id=tile_id)
serializer = TileSerializer(instance,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.update(instance, serializer.validated_data)
response_data = {
"message": "Kafelek o podanym id został zaktualizowany"
}
return Response(response_data, status.HTTP_200_OK)
else:
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist:
return ErrorResponse("Nie znaleziono kafelka o podanym id",
status.HTTP_404_NOT_FOUND)
@swagger_auto_schema(
manual_parameters=[
Parameter('tile_id', IN_PATH, type='integer'),
],
responses={
200: sample_message_response('Kafelek został pomyślnie usunięty'),
404: sample_message_response("Nie znaleziono kafelka o podanym id")
})
def delete(self, request, tile_id):
try:
instance = Tile.objects.get(pk=tile_id)
except ObjectDoesNotExist:
return ErrorResponse("Nie znaleziono kafelka o podanym id",
status.HTTP_404_NOT_FOUND)
instance.delete()
return MessageResponse("Kafelek został pomyślnie usunięty")
class BlogPostCategoryHeaderUploadView(views.APIView):
permission_classes = (
IsAuthenticated,
IsStaffBlogCreator | IsStaffBlogModerator,
)
parser_classes = (MultiPartParser, )
@swagger_auto_schema(
manual_parameters=[Parameter('category_id', IN_PATH, type='integer')],
responses={
200: "message: Pomyślnie dodano zdjęcie do kategorii",
400: "Błędy walidacji",
404: ''
})
def post(self, request, category_id):
category = self.__get_category(category_id)
serializer = BlogPostCategoryHeaderSerializer(
data=request.data, context={'category': category})
if serializer.is_valid():
serializer.save()
return Response(
{"message": "Pomyślnie dodano zdjęcie do kategorii"},
status.HTTP_200_OK)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
@swagger_auto_schema(
manual_parameters=[Parameter('category_id', IN_PATH, type='integer')],
responses={
200: "message: Zdjęcie kategorii zostało usunięte",
404: ''
})
def delete(self, request, category_id):
category = self.__get_category(category_id)
is_success = category.delete_header_if_exists()
return Response({"message": "Zdjęcie kategorii zostało usunięte."}, status.HTTP_200_OK) if is_success \
else ErrorResponse('Kategoria nie ma zdjęcia', status.HTTP_404_NOT_FOUND)
@staticmethod
def __get_category(category_id):
try:
return BlogPostCategory.objects.get(pk=category_id)
except BlogPostCategory.DoesNotExist:
raise Http404()
class BlogPostAttachmentUploadView(views.APIView):
permission_classes = [IsStaffBlogCreator]
parser_classes = [MultiPartParser]
@swagger_auto_schema(
manual_parameters=[
Parameter('post_id', IN_PATH, type='string($uuid)'),
Parameter('file', IN_FORM, type='file')
],
responses={
200: '"attachment_url": url',
400: '"error": "Nie znaleziono pliku"',
404: '"error": "Nie znaleziono podanej rezerwacji"'
},
)
def post(self, request, post_id):
try:
reservation = BlogPostReservation.objects.get(pk=post_id)
except BlogPostReservation.DoesNotExist:
return ErrorResponse("Nie znaleziono podanej rezerwacji",
status.HTTP_404_NOT_FOUND)
try:
data = {'blog_post': post_id, 'file': request.FILES['file']}
except MultiValueDictKeyError:
return ErrorResponse(
'Nie znaleziono pliku. Upewnij się, że został on załączony pod kluczem file',
status.HTTP_400_BAD_REQUEST)
serializer = BlogPostAttachmentSerializer(data=data)
if serializer.is_valid():
attachment = serializer.save()
else:
return ErrorResponse(serializer.errors,
status.HTTP_400_BAD_REQUEST)
response_data = {
"id": attachment.id,
"attachment_url": attachment.file.url
}
return Response(response_data, status.HTTP_200_OK)
def coreapi_field_to_parameter(self, field):
if field.name == "tags":
return Parameter(
name=field.name,
in_=IN_QUERY,
required=field.required,
description=TAGS_DESCRIPTION,
type=TYPE_ARRAY,
items=Items(type=TYPE_STRING, format=FORMAT_SLUG),
)
return super().coreapi_field_to_parameter(field=field)
def converted_parameters_from(schemas):
result = {}
for name, schema in schemas.items():
description = schema.description
type_ = schema.type
format_ = schema.format if hasattr(schema, 'format') else None
result[name] = Parameter(name=name,
description=description,
type=type_,
format=format_,
in_=openapi.IN_QUERY)
return result
def get_pagination_parameters(self):
if self.should_page():
return [
Parameter(
name="page",
in_=IN_QUERY,
description=
"Use este parâmetro para obter o resultado com paginação.",
type=TYPE_INTEGER,
)
]
return super().get_pagination_parameters()
class FindView(APIView):
"""A view to find submissions or transcriptions by their URL."""
@csrf_exempt
@swagger_auto_schema(
manual_parameters=[
Parameter(
"url",
"query",
type="string",
description="The URL to find the object of. "
"Can be a submission URL, a ToR submission URL or a transcription URL.",
required=True,
),
],
required=["url"],
responses={
200: DocResponse(
"The URL has been found!",
schema=Schema(
type="object",
# TODO: Use the schemas of the corresponding models
properties={
"submission": Schema(type="object"),
"author": Schema(type="object"),
"transcription": Schema(type="object"),
"ocr": Schema(type="object"),
},
),
),
400: "The given URL has an invalid format.",
404: "The corresponding submission/transcription could not be found.",
},
)
def get(self, request: Request) -> Response:
"""Find the submission/transcription corresponding to the URL."""
url = request.query_params.get("url")
normalized_url = normalize_url(url)
if normalized_url is None:
return Response(data="Invalid URL.", status=status.HTTP_400_BAD_REQUEST,)
data = find_by_url(normalized_url)
if data is None:
return Response(
data="No submission or transcription found for the given URL.",
status=status.HTTP_404_NOT_FOUND,
)
return Response(
data=FindResponseSerializer(data, context={"request": request}).data,
status=status.HTTP_200_OK,
)
class ExchangeRateLogsViewSet(ListModelMixin, GenericViewSet):
permission_classes = [AllowAny]
queryset = ExchangeRateLog.objects.all().select_related("currency")
serializer_class = ExchangeRateLogSerializer
def get_queryset(self):
queryset = super().get_queryset()
currency_code = self.request.query_params.get("code")
if currency_code:
queryset = queryset.filter(currency__code=currency_code)
return queryset
@swagger_auto_schema(manual_parameters=[Parameter("code", in_="query", type="str")])
def list(self, request, *args, **kwargs):
return super().list(request, *args, **kwargs)
def get_query_parameters(self):
""" Automatically adding `fields` to query parameters """
query_params = super().get_query_parameters()
if (isinstance(self.get_view_serializer(),
DynamicFieldsModelSerializer)
and self.method in self.implicit_list_response_methods):
query_params.append(
Parameter(
'fields',
IN_QUERY,
description=
'Specify the list of fields to be included in the request. Example: id,name',
type=TYPE_STRING))
return query_params
def get_schema(cls, title) -> Schema:
"""
Returns a schema for this class to be used in generating API
documentation.
"""
properties = OrderedDict()
for field_name in cls.get_serializable_fields():
properties[field_name] = Parameter(
field_name,
'body',
description=cls.get_field_descriptions().get(field_name, ''),
type=cls.get_field_type(field_name).__name__,
required=cls.field_is_required(field_name),
default=cls.get_field_default(field_name))
return Schema(title=title, type='object', properties=properties)
class SearchView(APIView):
@swagger_auto_schema(manual_parameters=[
Parameter('q', 'query', 'Search query', type='string')
])
def get(self, request):
query = request.query_params.get('q')
apiaries = models.Apiary.search(query)
hives = models.Hive.search(query)
return Response({
'apiaries':
serializers.ApiarySerializer(apiaries, many=True).data,
'hives':
serializers.HiveSerializer(hives, many=True).data,
})
class GroupsViewSet(ListCreateNestedModelViewSet):
serializer_class = ag_serializers.SubmissionGroupSerializer
permission_classes = (
P(ag_permissions.is_admin())
| ((P(ag_permissions.is_staff()) | P(ag_permissions.is_handgrader()))
& ag_permissions.IsReadOnly), )
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related('course')
to_one_field_name = 'project'
reverse_to_one_field_name = 'groups'
def get_queryset(self):
queryset = super().get_queryset()
if self.request.method.lower() == 'get':
queryset = queryset.prefetch_related('submissions')
return queryset
@swagger_auto_schema(request_body_parameters=[
Parameter(name='member_names',
in_='body',
description='Usernames to add to the new Group.',
type='List[string]',
required=True)
])
@transaction.atomic()
@method_decorator(require_body_params('member_names'))
def create(self, request, *args, **kwargs):
project = self.get_object()
request.data['project'] = project
users = [
User.objects.get_or_create(username=username)[0]
for username in request.data.pop('member_names')
]
utils.lock_users(users)
# Keep this hook immediately after locking the users.
test_ut.mocking_hook()
request.data['members'] = users
request.data['check_group_size_limits'] = (not project.course.is_admin(
request.user))
return super().create(request, *args, **kwargs)
def get_company_id_parameter(self):
"""
Helper function that creates a `Parameter` for the company id.
Returns None if the view doesn't use company_id (has set `company_id_field' to None`).
"""
company_id_field = self.view.company_id_field
if company_id_field:
return Parameter(
name=company_id_field,
in_='query',
type='integer',
description='The ID of the company to manage',
required=True,
)
return None
class CopyProjectView(AGModelGenericViewSet):
api_tags = [APITags.projects]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects
serializer_class = ag_serializers.ProjectSerializer
permission_classes = (ag_permissions.is_admin(), )
@swagger_auto_schema(
operation_description="""Makes a copy of the specified project and
all of its instructor file, expected student file, test case,
and handgrading data.
Note that groups, submissions, and results (test case, handgrading,
etc.) are NOT copied.
""",
request_body_parameters=[
Parameter('new_project_name',
in_='query',
type='string',
required=False),
])
@convert_django_validation_error
@transaction.atomic()
def copy_project(self, request: Request, *args, **kwargs):
project: ag_models.Project = self.get_object()
target_course = get_object_or_404(ag_models.Course.objects,
pk=kwargs['target_course_pk'])
if not target_course.is_admin(request.user):
return response.Response(status=status.HTTP_403_FORBIDDEN)
new_project_name = request.query_params.get('new_project_name', None)
new_project = copy_project(project=project,
target_course=target_course,
new_project_name=new_project_name)
return response.Response(status=status.HTTP_201_CREATED,
data=new_project.to_dict())
@classmethod
def as_view(cls, actions=None, **initkwargs):
return super().as_view(actions={'post': 'copy_project'}, **initkwargs)
def _build_api_parameter(field, field_name: str) -> Parameter:
type_ = _get_django_field_type(field)
description = field.help_text if hasattr(field, 'help_text') else ''
try:
required = (not field.many_to_many and not field.blank
and field.default == fields.NOT_PROVIDED)
except AttributeError:
required = False
allowed_vals = None
if type(field) == ag_fields.EnumField:
allowed_vals = [item.value for item in field.enum_type]
return Parameter(field_name,
'body',
description=description,
type=type_,
required=required,
enum=allowed_vals)
class BlogPostAttachmentDeleteView(views.APIView):
permission_classes = [IsStaffBlogCreator]
@swagger_auto_schema(
manual_parameters=[
Parameter('attachment_id', IN_PATH, type='string($uuid)')
],
responses={
200: '"message": "Załącznik o podanym id został usunięty"',
404: '"error": "Nie znaleziono załącznika o podanym id"'
})
def delete(self, request, attachment_id):
attachment = BlogPostAttachment.objects.get(pk=attachment_id)
if not attachment:
return ErrorResponse('Nie znaleziono załącznika o podanym id',
status.HTTP_404_NOT_FOUND)
attachment.delete()
response_data = {"message": "Załącznik o podanym id został usunięty"}
return Response(response_data, status.HTTP_200_OK)
class PhoneContactView(views.APIView):
permission_classes = [IsStaffBlogModerator]
@swagger_auto_schema(
manual_parameters=[
Parameter('contact_id', IN_PATH, type='integer'),
],
responses={
200: sample_message_response('Kontakt został pomyślnie usunięty'),
404:
sample_message_response("Nie znaleziono kontaktu o podanym id")
})
def delete(self, request, contact_id):
try:
instance = PhoneContact.objects.get(pk=contact_id)
except ObjectDoesNotExist:
return ErrorResponse("Nie znaleziono kontaktu o podanym id",
status.HTTP_404_NOT_FOUND)
instance.delete()
return MessageResponse("Kontakt został pomyślnie usunięty")
class AdminConfirmJobOfferView(views.APIView):
permission_classes = [IsStaffResponsibleForJobs]
@swagger_auto_schema(
manual_parameters=[
Parameter('offer_id', IN_PATH, type='string', format='byte')
],
request_body=Schema(type='object',
properties={'confirmed': Schema(type='boolean')}),
responses={
'200':
sample_message_response('Ustawiono potwierdzenie oferty pracy'),
'400': sample_error_response('Oferta jest usunięta'),
'401': 'No authorization token',
'403': sample_error_response('Brak uprawnień do tej czynności'),
'404': sample_error_response('Nie znaleziono oferty')
},
operation_description="Ustawianie potwierdzenia ofert pracy",
)
def post(self, request, offer_id):
try:
instance = JobOffer.objects.get(pk=offer_id)
except ObjectDoesNotExist:
return ErrorResponse("Nie znaleziono oferty",
status.HTTP_404_NOT_FOUND)
if instance.removed:
return ErrorResponse("Oferta jest usunięta",
status.HTTP_400_BAD_REQUEST)
if 'confirmed' in request.data:
confirmed = request.data['confirmed']
instance.confirmed = confirmed
instance.save()
notify.send(request.user,
recipient=instance.employer.user,
verb=f'Twoja oferta pracy została zatwierdzona',
app='job/job-offer/',
object_id=instance.id)
return MessageResponse("Ustawiono potwierdzenie oferty pracy")
return ErrorResponse("Błędy walidacji (np. brakujące pole)",
status.HTTP_400_BAD_REQUEST)