def put(self, request):
"""
This API is used to update user profile
@param: user profile data
@return: updates user profile
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
try:
profile = Profile.objects.get(user=request.user.pk)
user = User.objects.get(pk=request.user.pk)
profile.bio = serializer.data.get('bio')
profile.dob = serializer.data.get('dob')
profile.save()
user.first_name = serializer.data.get('firstName')
user.last_name = serializer.data.get('lastName')
user.save()
msg = "Your Profile is updated"
logger.info(f"{user.username}'s profile is updated")
return Response({'response_msg':msg},status=status.HTTP_200_OK)
except Profile.DoesNotExist as e:
msg = "Some error occurred"
logger.error(e)
return Response({'response_msg': msg}, status=status.HTTP_403_FORBIDDEN)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, uid, token):
"""
This API is used to reset user password
@param: uid and token fetched for get request
@return: reset user password
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
password = serializer.data.get('password')
response = JWTAuth.verifyToken(jwtToken=token)
if not response:
msg = 'Session for this token is expired!'
logger.info('Token session expired!')
return Response({'response_msg':msg}, status=status.HTTP_403_FORBIDDEN)
username=response.get('username')
try:
user = User.objects.get(username=username)
user.set_password(raw_password=password)
user.save()
TokenBlackLists(token=token).save()
msg = 'Your password is reset successfully !'
logger.info(f"{username}'s password reset successfully")
return Response({'response_msg':msg}, status=status.HTTP_200_OK)
except Exception as e:
msg = 'Something went wrong !'
logger.error(e)
return Response({'response_msg':msg}, status=status.HTTP_403_FORBIDDEN)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
This API is used to create a note for user
@param request: It takes note title, content, label(optional) and color(optional)
@return: creates not on successful validation
"""
serializer = self.serializer_class(data=request.data,
context={'user': request.user})
if serializer.is_valid():
serializer.save()
logger.info(f"{request.user.username}'s note is saved")
return Response({'response_msg': 'Your note is saved'},
status=status.HTTP_201_CREATED)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
This API is used to create a label
@param request: label name
@return: Creates label
"""
serializer = self.serializer_class(data=request.data,
context={'user': request.user})
if serializer.is_valid():
Label(user=request.user,
label_name=serializer.data.get('label_name')).save()
logger.info("label created")
return Response({'response_msg': 'Label added'},
status=status.HTTP_201_CREATED)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def put(self, request):
"""
This API is used to change user password
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
user = User.objects.get(pk=request.user.pk)
if check_password(serializer.data.get('old_password'), user.password):
user.set_password(raw_password=serializer.data.get('password'))
user.save()
msg = "Your password is changed"
logger.info(f"{user.username}'s password changed")
return Response({'response_msg':msg}, status=status.HTTP_200_OK)
msg = "Old password does not match!"
logger.warning(f"{user.username}'s old password does not match")
return Response({'response_msg':msg}, status=status.HTTP_401_UNAUTHORIZED)
logger.error(serializer.errors)
return Response({'msg': serializer.errors["non_field_errors"][0]}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request):
"""
This api is used to update user profile picture
@param: profile picture
@return: updates profile picture
"""
if request.FILES:
img = request.FILES['image']
serializer = self.serializer_class(data={'image':img})
serializer.is_valid(raise_exception=True)
old_image_name = request.user.profile.image.name
if old_image_name != 'profile_pics/default.jpg':
actual_path = os.path.join(os.getcwd(), 'media', old_image_name)
os.remove(actual_path)
request.user.profile.image = img
request.user.profile.save()
logger.info(f"{request.user.username}'s profile picture is updated")
return Response({'response_msg':'Your profile picture is uploaded'}, status=status.HTTP_200_OK)
logger.error("Blank image filed is found on put request")
return Response({'response_msg':'select a file'}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, label_name):
"""
This API is used to create label specific notes
@param label_name: existing specific label name
@return: creates note for this specific label
"""
serializer = self.serializer_class(
data=request.data, context={'email': request.user.email})
if serializer.is_valid():
try:
label = Label.objects.get(
Q(label_name=label_name) & Q(user_id=request.user.pk))
note = Notes(user=request.user,
title=serializer.data.get('title'),
content=serializer.data.get('content'),
color=serializer.data.get('color'))
collaborators = serializer.data.get('collaborators')
if collaborators:
collaborators_json = {
'owner': request.user.email,
'collaborators': collaborators
}
note.collaborators = collaborators_json
note.save()
note.label.add(label)
cache = Cache.getCacheInstance()
cache.hmset(f'user-{request.user.id}-note-{note.id}', {
'noteObj':
json.dumps(RetriveAllNotesSerializer(note).data)
})
logger.info(f"Note is saved")
return Response({'response_msg': 'Your note is saved'},
status=status.HTTP_201_CREATED)
except Label.DoesNotExist:
logger.info(f'{label_name} label is not exist')
return Response(
{'response_msg': f'{label_name} label is not exist'},
status=status.HTTP_404_NOT_FOUND)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
This API is used to authenticate user to access resources
@param request: user credential like username and password
@return: Redirects to all notes url on successful login
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
username = serializer.data.get('username')
password = serializer.data.get('password')
user = authenticate(request, username=username, password=password)
if user:
logger.info(f"{username} is authenticated")
login(request, user)
logger.info(f"{username} is logged in")
redirect_url = request.GET.get('next')
if redirect_url:
logger.info(f'Redirects to {redirect_url}')
return redirect(redirect_url)
logger.info(f'Redirects to /notes/')
return redirect('/notes/')
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
if user and check_password(password, user.password):
jwtToken = JWTAuth.getToken(user.username, user.password)
current_site = get_current_site(request).domain
relative_url = 'user/verify-email/'
email_data = Email.configureEmail(jwtToken, user, current_site, relative_url)
Email.sendEmail(email_data)
logger.info(f"{username}'s account is not active, activation mail is sent to {user.email}")
msg = 'Your account is not active. Please activate your account from the link shared in your mail'
return Response({'response_msg':msg}, status=status.HTTP_100_CONTINUE)
msg = 'Bad Credential found'
logger.error(f"Credential failure for {username}")
return Response({'response_msg':msg}, status=status.HTTP_401_UNAUTHORIZED)
logger.error(serializer.errors)
return Response({'msg':serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
This api is for user registration to this application
@param request: user registration data like username, email, password, firstname, lastname
@return: account verification link to registered email once registration is successful
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
serializer.save()
user = User.objects.get(username=serializer.data.get('username'))
user.is_active = False
user.save()
logger.info(f"{user.username} is registered")
jwtToken = JWTAuth.getToken(user.username, user.password)
current_site = get_current_site(request).domain
relative_url = 'user/verify-email/'
email_data = Email.configureEmail(jwtToken, user, current_site, relative_url)
Email.sendEmail(email_data)
logger.info(f'Account activation link is sent to {user.email}')
msg= "Your account is created and a confirmation mail is sent to your mail for account activation"
return Response({'response_msg':msg, 'response_data':jwtToken},status = status.HTTP_201_CREATED)
logger.error(serializer.errors)
return Response({'response_msg':serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
This api is used to send reset password request to server
@param request: user registered email id
@return: sends a password reset link to user validated email id
"""
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
try:
user = User.objects.get(email=serializer.data.get('email'))
except User.DoesNotExist:
msg = 'Your Mail id is not registered'
logger.info(f"{serializer.data.get('email')} is not registered")
return Response({'response_msg':msg}, status=status.HTTP_404_NOT_FOUND)
jwtToken = JWTAuth.getToken(user.username, user.password)
current_site = get_current_site(request).domain
relative_url = 'user/reset-password/'+str(user.pk)+"/"+str(jwtToken)
email_data = Email.configureResetPasswordMail(jwtToken, user, current_site, relative_url)
Email.sendEmail(email_data)
msg = 'Password reset link is sent to your mail.'
logger.info(f'password reset link is sent to {user.email}')
return Response({'response_msg':msg, 'response_data':jwtToken}, status=status.HTTP_100_CONTINUE)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, note_id):
"""
This API is used to update the existing note
@param request: title, content, label, color
@param note_id: primary_key of the specific note
@return: updates the note
"""
try:
note = Notes.objects.get(
Q(pk=note_id) & Q(user=request.user) & Q(is_trash=False))
except Notes.DoesNotExist:
logger.warning("Note does not exist on update API hit")
return Response({'msg': 'Your not authorised to access this data'},
status=status.HTTP_401_UNAUTHORIZED)
serializer = self.serializer_class(data=request.data,
partial=True,
context={'user': request.user})
if serializer.is_valid():
note.last_updated = datetime.now()
note.title = serializer.data.get('title')
note.content = serializer.data.get('content')
note.color = serializer.data.get('color')
collabortors = serializer.data.get('collaborators')
if serializer.data.get('label'):
for label in serializer.data.get('label'):
try:
Label.objects.get(
Q(label_name=label['label_name'])
& Q(user=request.user))
except Label.DoesNotExist:
logger.warning(f"{label['label_name']} does not exist")
return Response(
{'response_msg': 'This label is not exist'},
status=status.HTTP_404_NOT_FOUND)
note.label.clear()
if serializer.data.get('label'):
for label in serializer.data.get('label'):
label_obj = Label.objects.get(
Q(label_name=label['label_name'])
& Q(user=request.user))
note.label.add(label_obj)
if note.collaborators:
note.collaborators.pop('owner')
note.collaborators.pop('collaborators')
if collabortors:
collaborators_json = {
'owner': request.user.email,
'collaborators': collabortors
}
note.collaborators = collaborators_json
note.save()
logger.info("Note is updated")
cache = Cache.getCacheInstance()
cache.delete(f'user-{request.user.id}-note-{note.id}')
cache.hmset(
f'user-{request.user.id}-note-{note.id}',
{'noteObj': json.dumps(RetriveAllNotesSerializer(note).data)})
cache.expire(f'user-{request.user.id}-note-{note.id}',
time=timedelta(days=3))
logger.info("Note is updated in cache")
return Response({'response_msg': 'Your note is Updated'},
status=status.HTTP_200_OK)
logger.error(serializer.errors)
return Response({'response_msg': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
