def post(self, request, slug):
try:
instance = request.user.notifications.get(id=slug2id(slug))
except Notification.DoesNotExist:
return ErrorResponse('Nie ma takiego powiadomienia!',
status.HTTP_404_NOT_FOUND)
if instance.unread:
instance.mark_as_read()
return MessageResponse('Oznaczono powiadomienie jako przeczytane')
else:
instance.mark_as_unread()
return MessageResponse(
'Oznaczono powiadomienie jako nieprzeczytane')
def post(self, request, cv_id):
try:
cv = CV.objects.get(cv_id=cv_id)
if not IsCVOwner().has_object_permission(request, self, cv):
return ErrorResponse("Nie masz uprawnień do wykonania tej czynności", status.HTTP_403_FORBIDDEN)
except CV.DoesNotExist:
return ErrorResponse('Nie znaleziono CV. Upewnij się, że uwzględniono cv_id w url-u', status.HTTP_404_NOT_FOUND)
serializer = CVSerializer(instance=cv)
data = serializer.data
try:
pict = request.FILES['picture']
ext = pict.name.split('.')[-1]
pict.name = create_unique_filename('cv_pics', ext)
data['basic_info']['picture'] = pict
cv.has_picture = True
cv.save()
except MultiValueDictKeyError:
ErrorResponse('Upewnij się, że form key to "picture"', status.HTTP_400_BAD_REQUEST)
serializer = CVSerializer(data=data)
delete_previous_cv_file(cv)
delete_previous_picture(cv.basic_info)
if serializer.is_valid():
serializer.update(cv, serializer.validated_data)
return MessageResponse('Zdjęcie dodano pomyślnie')
else:
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def patch(self, request, pk):
try:
account = Account.objects.get(pk=pk)
except Account.DoesNotExist:
return ErrorResponse(
'Użytkownik o podanym id nie został znaleziony',
status.HTTP_404_NOT_FOUND)
if account.type == AccountType.STANDARD.value:
serializer = DefaultAccountSerializer(account,
data=request.data,
partial=True)
elif account.type == AccountType.EMPLOYER.value:
serializer = EmployerAccountSerializer(account,
data=request.data,
partial=True)
elif account.type == AccountType.STAFF.value:
return ErrorResponse("Nie możesz edytować danych tego użytkownika",
status.HTTP_403_FORBIDDEN)
if serializer.is_valid():
serializer.update(account, serializer.validated_data)
send_account_data_change_email(pk, request.data)
return MessageResponse("Dane konta zostały zaktualizowane")
else:
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
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")
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")
def delete(self, request, slug):
try:
instance = request.user.notifications.get(id=slug2id(slug))
except Notification.DoesNotExist:
return ErrorResponse('Nie ma takiego powiadomienia!',
status.HTTP_404_NOT_FOUND)
instance.delete()
return MessageResponse('Pomyślnie usunięto powiadomienie!')
def patch(self, request):
account = request.user
serializer = StaffAccountSerializer(account, data=request.data, partial=True)
if serializer.is_valid():
serializer.update(account, serializer.validated_data)
else:
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
return MessageResponse("Dane zostały pomyślnie zmienione")
def delete(self, request, pk):
try:
account = Account.objects.get(pk=pk)
if account.type == AccountType.STAFF.value:
return ErrorResponse("Nie możesz wykonać tej operacji", status.HTTP_403_FORBIDDEN)
account.delete()
return MessageResponse("Konto zostało usunięte")
except Account.DoesNotExist:
return ErrorResponse("Użytkownik o podanym id nie został znaleziony", status.HTTP_404_NOT_FOUND)
def delete(self, request, category_id):
try:
category = BlogPostCategory.objects.get(pk=category_id)
except BlogPostCategory.DoesNotExist:
return ErrorResponse("Kategoria o podanym id nie istnieje",
status.HTTP_404_NOT_FOUND)
category.delete_header_if_exists()
category.delete()
return MessageResponse("Kategoria została usunięta")
def delete(self, request, cv_id):
try:
cv = CV.objects.get(cv_id=cv_id)
if not IsCVOwner().has_object_permission(request, self, cv) \
and not IsStaffResponsibleForCVs().has_object_permission(request, self, cv):
return ErrorResponse("Nie masz uprawnień do wykonania tej czynności", status.HTTP_403_FORBIDDEN)
cv.delete()
except CV.DoesNotExist:
return ErrorResponse("Nie znaleziono CV. Upewnij się, że uwzględniono cv_id w url-u", status.HTTP_404_NOT_FOUND)
return MessageResponse('CV usunięto pomyślnie')
def patch(self, request):
account = request.user
serializer = PasswordChangeRequestSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
old_pass = request.data['old_password']
new_pass = request.data['new_password']
if check_password(old_pass, account.password):
account.set_password(new_pass)
account.save()
account.auth_token_set.all().delete()
return MessageResponse("Hasło zostało zmienione")
return ErrorResponse("Stare hasło jest niepoprawne", status.HTTP_403_FORBIDDEN)
def post(self, request, user_id):
if user_id is not None:
try:
user = Account.objects.get(pk=user_id)
except Account.DoesNotExist:
return ErrorResponse('Nie znaleziono użytkownika', status.HTTP_404_NOT_FOUND)
user.status = AccountStatus.VERIFIED.value
user.save()
send_verification_email(user_id)
return MessageResponse('Użytkownik został pomyślnie zweryfikowany')
return ErrorResponse('Nie podano id użytkownika', status.HTTP_400_BAD_REQUEST)
def post(self, request):
user = DefaultAccount.objects.get(user=request.user)
try:
perspective = UserPerspective.objects.get(user=user)
except UserPerspective.DoesNotExist:
return ErrorResponse('Nie zacząłeś_aś oglądać kroków usamodzielnienia', status.HTTP_400_BAD_REQUEST)
if perspective.step.substeps.count() <= perspective.substep_order + 1:
return ErrorResponse('Przekroczono liczbę podkroków', status.HTTP_400_BAD_REQUEST)
else:
perspective.substep_order += 1
perspective.save()
return MessageResponse('Gratulacje, przechodzisz dalej!')
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)
def post(self, request, cv_id):
if cv_id is not None:
try:
cv = CV.objects.get(cv_id=cv_id)
except CV.DoesNotExist:
return ErrorResponse('Nie znaleziono CV o podanym id', status.HTTP_404_NOT_FOUND)
cv.is_verified = True
cv.save()
notify.send(request.user, recipient=cv.cv_user.user,
verb=f'CV {cv.name} zostało zatwierdzone',
app='myCVs',
object_id=None
)
return MessageResponse('CV zweryfikowano pomyślnie')
return ErrorResponse('Nie podano cv_id', status.HTTP_400_BAD_REQUEST)
def put(self, request, cv_id):
try:
cv = CV.objects.get(cv_id=cv_id)
if not IsCVOwner().has_object_permission(request, self, cv):
return ErrorResponse("Nie masz uprawnień do wykonania tej czynności", status.HTTP_403_FORBIDDEN)
except CV.DoesNotExist:
return ErrorResponse('Nie znaleziono CV o podanym id', status.HTTP_404_NOT_FOUND)
try:
cv.name = request.data['name']
cv.save()
return MessageResponse(f'Nazwa CV zmieniona na: {request.data["name"]}')
except KeyError:
return ErrorResponse('Nie podano nowej nazwy CV', status.HTTP_400_BAD_REQUEST)
def post(self, request, user_id):
if user_id is not None:
try:
user = Account.objects.get(pk=user_id)
except Account.DoesNotExist:
return ErrorResponse('Użytkownik o podanym ID nie został znaleziony', status.HTTP_404_NOT_FOUND)
if user.type == AccountType.STAFF.value:
return ErrorResponse('Nie możesz zablokować tego użytkownika', status.HTTP_403_FORBIDDEN)
user.status = AccountStatus.BLOCKED.value
user.save()
return MessageResponse('Użytkownik został pomyślnie zablokowany')
return ErrorResponse('ID użytkownika nie zostało podane', status.HTTP_400_BAD_REQUEST)
def post(self, request):
request_data = request.data
serializer = self.serializer_class(data=request_data)
try:
cv = CV.objects.get(cv_id=request_data['cv_id'])
except CV.DoesNotExist:
return ErrorResponse('Nie znaleziono CV o podanym id', status.HTTP_404_NOT_FOUND)
if serializer.is_valid():
feedback = serializer.create(serializer.validated_data)
notify.send(request.user, recipient=cv.cv_user.user,
verb=f'Nowy komentarz do CV: {cv.name}',
app='myCVs',
object_id=None
)
return MessageResponse('Feedback stworzono pomyślnie')
else:
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def delete(self, request, cv_id):
try:
cv = CV.objects.get(cv_id=cv_id)
if not IsCVOwner().has_object_permission(request, self, cv):
return ErrorResponse("Nie masz uprawnień do wykonania tej czynności", status.HTTP_403_FORBIDDEN)
except CV.DoesNotExist:
return ErrorResponse('Nie znaleziono CV', status.HTTP_404_NOT_FOUND)
bi = BasicInfo.objects.get(cv=cv)
if not bi.picture:
return ErrorResponse('Nie znaleziono zdjęcia', status.HTTP_404_NOT_FOUND)
bi.picture.delete(save=True)
cv.has_picture = False
cv.save()
cv_serializer = CVSerializer(instance=cv)
delete_previous_picture(bi)
delete_previous_cv_file(cv)
cv_serializer.update(cv, cv_serializer.data)
return MessageResponse('Zdjęcie usunięto pomyślnie')
def delete(self, request):
request.user.notifications.all().delete()
return MessageResponse('Usunięto wszystkie twoje powiadomienia!')
def delete(self, request):
account = request.user
account.delete()
return MessageResponse("Konto zostało pomyślnie usunięte")
def post(self, request):
pk = request.user.id
#start_scheduler(pk)
return MessageResponse(
'Powiadomienia będą wysyłane na adres mailowy codziennie o 06:00')
def post(self, request):
pk = request.user.id
#stop_scheduler(pk)
return MessageResponse(
'Powiadomienia nie będą już wysyłane na adres mailowy')
def get(self, request):
return MessageResponse('Nawiązano kontakt z WebSocketem')
def post(self, request):
request.user.notifications.mark_all_as_read()
return MessageResponse(
'Oznaczono wszystkie powiadomienia jako przeczytane')