def search(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
if (request.data.get('name') == None or request.data.get('name') == ""
or request.data.get('name') == " "):
log_result = 'empty field error in search'
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return Response({"error": "empty_field"})
pattern_set = request.data.get('name').split()
query = Q()
for pattern in pattern_set:
query = query | Q(fullname__contains=pattern)
queryset = Profile.objects.all()
query_list = []
for item in queryset:
distance = max(len(str(item.fullname)), 100)
for pattern in pattern_set:
distance = min(levenshteinDistance(item.fullname, pattern),
distance)
query_list.append({"profile": item, 'distance': distance})
query_list = sorted(query_list, key=lambda x: x['distance'])[:30]
result = []
for item in query_list:
profile = ProfileSerializer(item["profile"],
context={'request': request})
result.append(profile.data)
log_result = 'user(id={0}) searched in users names'.format(
request.user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({"results": result})
def get(self, request, email_verification_token):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
verify_template = loader.get_template('email_verified.html')
try:
email_verification_request = EmailVerificationRequests.objects.get(
hashed_token=EmailVerificationRequests.hash_token(email_verification_token)
) # may throw DoesNotExist
if email_verification_request.expired():
log_result = 'Fail: Token expired'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return HttpResponse(verify_template.render({'message': 'your token is expired. please try again!'}))
profile = email_verification_request.profile
if profile.email_verified:
log_result = 'Success: Already verified'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return HttpResponse(verify_template.render({'message': 'your email is already verified!'}))
profile.email_verified = True
profile.save()
email_verification_request.delete()
log_result = 'Success: Email verified'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return HttpResponse(verify_template.render({'message': 'email successfully verified:)'}))
except EmailVerificationRequests.DoesNotExist:
log_result = 'Fail: non-existent token'
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return HttpResponse(verify_template.render({'message': 'invalid request!'}))
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
old_password = request.data.get('old_password')
new_password = request.data.get('new_password')
if old_password is None or old_password == "" or new_password is None or new_password == "":
log_result = 'Fail: Empty password'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({"error": _("empty_password")},
status=HTTP_400_BAD_REQUEST)
user = request.user
if not user.check_password(old_password):
log_result = 'Fail: Wrong old password'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("wrong_old_password!")},
status=HTTP_400_BAD_REQUEST)
try:
validate_password(new_password)
except:
log_result = 'Fail: New password failed validation'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("weak_password")}, status=HTTP_400_BAD_REQUEST)
user.set_password(new_password)
user.save()
log_result = 'Success: Password changed'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": _("succeeded")})
def list_posts(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
username = request.GET.get('username')
if not username:
username = request.user.profile.main_username
profile = Profile.objects.filter(main_username=username).first()
if not (UserFollow.objects.filter(source=request.user.profile,
destination=profile).exists()
or profile.is_public or profile == request.user.profile):
log_result = 'user(id={0}) requested to get lists of posts of user(id={1}) while not following him'\
.format(request.user.id, profile.user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': 'not_followed'},
status=HTTP_400_BAD_REQUEST)
queryset = Post.objects.filter(profile__main_username=username)
posts = self.paginate_queryset(queryset)
serializer_context = {
'request': request,
}
log_result = 'list posts of user(id={0})'.format(profile.user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
if posts is not None:
serializer = PostSerializerGET(posts,
many=True,
context=serializer_context)
return self.get_paginated_response(serializer.data)
serializer = PostSerializerGET(queryset,
many=True,
context=serializer_context)
return Response(serializer.data)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
profile = request.user.profile
if profile.is_public:
profile.is_public = False
profile.save()
log_result = 'Success: Profile set to private'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": "private"})
else:
profile.is_public = True
profile.save()
query = UserFollowRequest.objects.filter(destination=profile)
for q in query:
accept_handler(source=q.source , destination=profile)
log_result = 'Success: Profile set to public'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": "public"})
def search(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
if (request.data.get('tag') == None or request.data.get('tag') == ""
or request.data.get('tag') == " "):
log_result = 'empty field error in search'
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return Response({"error": "empty_field"})
pattern_set = request.data.get('tag').split()
# query = Q()
# for pattern in pattern_set:
# query = query | Q(text__contains=pattern)
# queryset = Tag.objects.filter(query).distinct().order_by('number')
queryset = Tag.objects.all()
query_list = []
for item in queryset:
distance = max(len(str(item.text)), 100)
for pattern in pattern_set:
distance = min(levenshteinDistance(item.text, pattern),
distance)
query_list.append({"text": item.text, 'distance': distance})
query_list = sorted(query_list, key=lambda x: x['distance'])[:30]
result = []
for item in query_list:
result.append(item['text'])
log_result = 'user(id={0}) searched in tags'.format(request.user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({"results": result})
def create(self, request, *args, **kwargs):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
image = request.FILES.get("image")
if image is None:
log_result = 'user id={0} tried to create a post without any iamge.'.format(
request.user.id)
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return Response({'error': _('image is required')},
status=HTTP_400_BAD_REQUEST)
caption = request.POST.get("caption")
location = request.POST.get("location")
if not (validate_charfield_input(location, location_max_length)):
return Response({'error': _('location is too long.')},
status=HTTP_400_BAD_REQUEST)
profile = request.user.profile
post = Post.objects.create(image=image,
caption=caption,
location=location,
profile=profile)
tag_string = request.POST.get("tag_string")
tag_list = str(tag_string).split()
for tag in tag_list:
t, is_created = Tag.objects.get_or_create(text=tag)
if not (validate_charfield_input(t.text, tag_max_length)):
return Response({'error': _('tag name is too long.')},
status=HTTP_400_BAD_REQUEST)
post.tags.add(t)
log_result = 'user id={0} created a new post(id={1}).'.format(
request.user.id, post.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')},
status=status.HTTP_201_CREATED)
def post(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
if str(request.META.get("REMOTE_ADDR")) == "127.0.0.1":
type = request.data.get("type")
if type == forgot_password_type:
return self.forgot_pass_mail(request, req_time)
if type == email_verification_type:
return self.verify_email(request, req_time)
if type == invite_mail_type:
return self.send_invite_mail(request, req_time)
receiver = request.data.get("receiver")
sender = request.data.get("sender")
object = request.data.get("object")
you = request.data.get("you")
id = request.data.get("id")
if type != comment_type and \
Notification.objects.filter(type=type,
receiver=Profile.objects.get(id=receiver),
sender=Profile.objects.get(id=sender),
object=Profile.objects.get(id=object),
you=True).exists():
return Response(status=status.HTTP_200_OK)
if type == unfollow_type:
Notification.objects.filter(
type=follow_request_type,
receiver=Profile.objects.get(id=receiver),
sender=Profile.objects.get(id=sender),
object=Profile.objects.get(id=object),
).delete()
return Response(status=status.HTTP_200_OK)
if type == follow_type:
self.delete_follow_request_notif(object, receiver, sender)
notif = Notification(type=type,
receiver=Profile.objects.get(id=receiver),
sender=Profile.objects.get(id=sender),
object=Profile.objects.get(id=object),
you=you)
notif.save()
if id > 0:
notif.data = id
notif.save()
if type == follow_type:
self.create_notif_for_all_followers(object, sender, type)
log_result = 'user(id={0}) notif successfully handled from redis queue'.format(
sender)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response(status=status.HTTP_200_OK)
else:
log_result = 'try to send request to internal api of redis'
log_message = res_log_message(request, log_result, req_time)
logger.error(log_message)
return Response(status=status.HTTP_403_FORBIDDEN)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
new_username = request.data.get("username")
new_bio = request.data.get("bio")
new_email = request.data.get("email")
new_fullname = request.data.get("fullname")
new_profile_picture = request.data.get("profile_picture")
user = request.user
if Profile.objects.filter(main_username=new_username).count() > 0 \
and not Profile.objects.get(user=user).main_username == new_username:
log_result = 'Fail: username already taken'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': _('this username is already taken')},
status=HTTP_400_BAD_REQUEST)
elif User.objects.filter(email=new_email).count() > 0 and not user.email == new_email:
log_result = 'Fail: Email already taken'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': _('this email is already taken')},
status=HTTP_400_BAD_REQUEST)
if not new_email is None:
if not email_pattern.match(new_email):
log_result = 'Fail: Email failed validation'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': _('bad_email')},
status=HTTP_400_BAD_REQUEST)
user.email = new_email
user.username = new_email
profile = Profile.objects.get(user=user)
if not new_fullname is None:
profile.fullname = new_fullname
if not new_bio is None:
if not validate_charfield_input(new_bio, bio_max_length):
log_result = 'Fail: bio exceeded max length'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("long bio")}, status=HTTP_400_BAD_REQUEST)
profile.bio = new_bio
if not new_username is None:
profile.main_username = new_username
if not new_profile_picture is None:
profile.profile_picture = new_profile_picture
user.save()
profile.save()
log_result = 'Success: Profile info set'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
def like(self, request, pk):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
if self.request.method == 'GET':
queryset = Like.objects.filter(post__pk=pk)
likes = self.paginate_queryset(queryset)
serializer = LikeSerializer(likes,
many=True,
context={'request': request})
log_result = 'user(id={0}) requested for likes on post(id={1})'.format(
request.user, pk)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return self.get_paginated_response(serializer.data)
elif self.request.method == 'POST':
post = Post.objects.get(id=pk)
if post is None:
log_result = 'post not found: user(id={0}) requested to like post(id={1}).'.format(
request.user.id, post.id)
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return JsonResponse({"error": "post_not_find"},
status=HTTP_400_BAD_REQUEST)
if Like.objects.filter(post=post,
profile=self.request.user.profile).exists():
Like.objects.get(post=post,
profile=self.request.user.profile).delete()
log_result = 'user(id={0}) unliked post(id={1}).'.format(
request.user.id, post.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('unliked')})
profile = self.request.user.profile
like = Like.objects.create(post=post, profile=profile)
post.likes.add(like)
receiver = Profile.objects.get(id=post.profile.id)
data = {
"type": like_type,
"receiver": receiver.id,
"sender": profile.id,
"you": True,
"object": receiver.id,
"id": post.id
}
queue.enqueue(json.dumps(data))
log_result = 'user(id={0}) liked post(id={1}).Queued on redis.'.format(
request.user.id, post.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
def post(self, request, reset_password_token):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
try:
password_reset_request = PasswordResetRequests.objects.get(
hashed_token=PasswordResetRequests.hash_token(reset_password_token)
) # may throw DoesNotExist
except PasswordResetRequests.DoesNotExist:
log_result = 'Fail: Invalid token'
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return JsonResponse({"error": _("Invalid_request")},
status=HTTP_400_BAD_REQUEST)
if password_reset_request.expired():
log_result = 'Fail: Expired token'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
password_reset_request.delete()
return JsonResponse({"error": _("Invalid_request")}, # TODO: error: expired ?
status=HTTP_400_BAD_REQUEST)
if request.data.get('validation') == 'true':
log_result = 'Success: Token passed validation'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": _("succeeded")},
status=HTTP_200_OK)
new_password = request.data.get('new_password')
user = password_reset_request.user
try:
validate_password(new_password)
except:
log_result = 'Fail: New password failed validation'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("weak_password")}, status=HTTP_400_BAD_REQUEST)
user.set_password(new_password)
user.save()
password_reset_request.delete()
log_result = 'Success: Password reset for user_{0}'.format(user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
# TODOdone: should password_reset_request be disabled ? is deleted
return JsonResponse({"status": _("succeeded")})
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
invitee_email = request.data.get('email')
fullname = request.user.profile.fullname
username = request.user.profile.main_username
inviter_name = fullname if fullname is not None and len(fullname) > 0 else username
# TODO: make a db table for invitations
# TODO: then don't permit inviting members and only allow single time invitations
subject = "Invitation to join Akkaskhuneh"
body = """
<p>Hello,</p>
<p>{0} invited you to join Akkaskhuneh</p>
<p>Don't hesitate. Akkaskhuneh is far better than instagram, etc.</p>
<p>Hurry!</p>
""".format(inviter_name)
# send_mail(invitee_email, subject, body)
data = {"type": invite_mail_type,
"email": invitee_email,
"subject":subject,
"body":body}
queue.enqueue(json.dumps(data))
response = JsonResponse({'Success': _('Invitation email sent')},
status=HTTP_200_OK)
log_result = 'Success: Invitation sent to {0}'.format(invitee_email)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return response
def list_favorites(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
username = request.GET.get('username')
print(username)
if not username:
username = request.user.profile.main_username
serializer_context = {
'request': request,
}
queryset = Favorite.objects.filter(profile__main_username=username)
page = self.paginate_queryset(queryset)
log_result = 'user id={0} requested to receive lists of favorites of user(id={1})'.format(
request.user.id,
User.objects.get(profile__main_username=username).id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
if page is not None:
serializer = FavoriteSerializer(page,
many=True,
context=serializer_context)
return self.get_paginated_response(serializer.data)
serializer = FavoriteSerializer(queryset,
many=True,
context=serializer_context)
return Response(serializer.data)
def list_posts(self, request, pk):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
username = request.GET.get('username')
if not username:
username = request.user.id
favorite = Favorite.objects.get(id=pk)
queryset = favorite.posts.filter(
Q(profile__is_public=True)
| Q(profile__followers__source=self.request.user.profile)
| Q(profile__user=request.user))
# .filter(user_id=user_id)
page = self.paginate_queryset(queryset)
serializer_context = {
'request': request,
}
log_result = 'user id={0} requested for list of posts of favorite(id={1}).'.format(
request.user.id, pk)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
if page is not None:
serializer = PostSerializerGET(page,
many=True,
context=serializer_context)
return self.get_paginated_response(serializer.data)
serializer = PostSerializerGET(queryset,
many=True,
context=serializer_context)
return Response(serializer.data)
def list_posts(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
# if not username:
# username = request.user.id
tag = Tag.objects.get(text=request.GET.get('tag'))
queryset = tag.posts.filter(
Q(profile__is_public=True)
| Q(profile__followers__source=self.request.user.profile)
| Q(profile__user=request.user))
page = self.paginate_queryset(queryset)
serializer_context = {
'request': request,
}
log_result = 'user id={0} requested for list of posts of tag "{1}".'.format(
request.user.id, tag.text)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
if page is not None:
serializer = PostSerializerGET(page,
many=True,
context=serializer_context)
return self.get_paginated_response(serializer.data)
serializer = PostSerializerGET(queryset,
many=True,
context=serializer_context)
return Response(serializer.data)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
email = request.data.get('email')
try:
user = User.objects.get(email=email)
# logger.info('Forgot password request for user {0}, from {1}.'.format(user.id, client_IP))
except User.DoesNotExist:
log_result = 'Fail: Forgot password request for non-existent email {0}'.format(email)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("Wrong_email")},
status=HTTP_400_BAD_REQUEST)
try:
PasswordResetRequests.objects.get(user=user).delete()
except PasswordResetRequests.DoesNotExist:
pass
password_reset_request = PasswordResetRequests(user=user)
token = uuid.uuid4().hex
password_reset_request.set_token(token)
password_reset_request.save()
host_root = request.build_absolute_uri('/') # example: http://127.0.0.1:8000/
password_reset_url = '{0}user/reset_password/{1}/'.format(host_root, token)
# send_mail_response_code = \
# ForgotPassword.send_password_reset_email(user.profile.main_username,
# user.email,
# password_reset_url)
data = {"type": forgot_password_type,
"username": user.profile.main_username,
"email": user.email,
"url": password_reset_url}
queue.enqueue(json.dumps(data))
log_result = 'Success: Reset password email for user_{0} sent to {1}'.format(
user.id, email)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
# if send_mail_response_code == 200:
return JsonResponse({"status": _("Succeeded. Please check your email.")},
status=HTTP_200_OK)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
user = request.user
profile = user.profile
if profile.email_verified:
log_result = 'Fail: Already verified'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("Already verified")},
status=HTTP_400_BAD_REQUEST)
try:
EmailVerificationRequests.objects.get(profile=profile).delete()
except EmailVerificationRequests.DoesNotExist:
pass
email_verification_request = EmailVerificationRequests(profile=profile)
token = uuid.uuid4().hex
email_verification_request.set_token(token)
email_verification_request.save()
host_root = request.build_absolute_uri('/') # example: http://127.0.0.1:8000/
email_verification_url = '{0}user/verify_email/{1}/'.format(host_root, token)
# send_mail_response_code = \
# VerificationRequest.send_verification_email(profile.main_username,
# user.email,
# email_verification_url)
data = {"type": email_verification_type,
"username": profile.main_username,
"email": user.email,
"url": email_verification_url}
queue.enqueue(json.dumps(data))
# queue.enqueue(ForgotPassword.send_password_reset_email, user.profile.main_username,
# user.email,
# password_reset_url)
# if send_mail_response_code == 200:
log_result = 'Success: Verification email sent'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": _("Succeeded. Please check your email.")},
status=HTTP_200_OK)
def send_invite_mail(self, request, req_time):
email = request.data.get("email")
subject = request.data.get("subject")
body = request.data.get("body")
send_mail(email, subject, body)
log_result = 'invite mail sent to: "{0}".'.format(email)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse(
{"status": _("Succeeded. Please check your email.")},
status=HTTP_200_OK)
def comment(self, request, pk):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
if self.request.method == 'GET':
queryset = Comment.objects.filter(post__pk=pk)
comments = self.paginate_queryset(queryset)
serializer = CommentSerializer(comments,
many=True,
context={'request': request})
log_result = 'user(id={0}) requested for comments on post(id={1})'.format(
request.user.id, pk)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return self.get_paginated_response(serializer.data)
elif self.request.method == 'POST':
text = request.data.get("text")
if text is None or text == "":
return JsonResponse({"error": "empty_field"},
status=HTTP_400_BAD_REQUEST)
post = Post.objects.get(id=pk)
profile = self.request.user.profile
comment = Comment.objects.create(text=text,
post=post,
profile=profile)
post.comments.add(comment)
receiver = Profile.objects.get(id=post.profile.id)
# notif = Notification(type=comment_type, receiver=receiver, sender=profile, object=receiver, you=True)
data = {
"type": comment_type,
"receiver": receiver.id,
"sender": profile.id,
"you": True,
"object": receiver.id,
"id": post.id
}
queue.enqueue(json.dumps(data))
log_result = 'user(id={0}) added a new comment on post(id={1}).Queued on redis.'.format(
request.user.id, post.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
def finalize_response(self, request, response, *args, **kwargs):
# regular finalize response
response = super().finalize_response(request, response, *args,
**kwargs)
# do not log, if method not found
if request.method.lower() not in self.allowed_logging_methods:
return response
status_code = response.status_code
# time_delta = now() - self.request.info['date']
# response_time_ms = time_delta.total_seconds() * 1000
# log_kwargs = {
# 'view': self.get_view_name(),
# 'action': self.action,
# 'method': request.method.lower(),
# 'status_code': status_code,
# 'response_time_ms': round(response_time_ms, 2),
# 'request_path': request.path,
# }
req_time = self.request.info['req_time']
if status.is_server_error(status_code):
log_result = 'Fail: status_{0}'.format(status_code)
log_message = res_log_message(request, log_result, req_time)
logger.error(log_message)
elif status.is_client_error(status_code):
log_result = 'Fail: status_{0}'.format(status_code)
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
elif status_code == 200 or status_code == 201:
log_result = 'Success: status_{0}'.format(status_code)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
else:
log_result = 'Fail: status_{0}'.format(status_code)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return response
def get(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
user = request.user
profile = Profile.objects.get(user=user)
serializer = ProfileSerializer(profile, context={'request': request}).data
log_result = 'Success: Profile info sent'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse(serializer)
def post(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
favorite_id = request.data.get("favorite_id")
if (Favorite.objects.filter(id=favorite_id).exists()):
Favorite.objects.get(id=favorite_id).delete()
log_result = 'favorite (id={0}) removed from favorite list'.format(favorite_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
else:
return Response({'error': _('no such favorite')},
status=HTTP_400_BAD_REQUEST)
def verify_email(self, request, req_time):
username = request.data.get("username")
email = request.data.get("email")
url = request.data.get("url")
send_mail_response_code = \
VerificationRequest.send_verification_email(username,
email,
url)
if send_mail_response_code == 200:
log_result = 'verification mail successfully sent to user(id={0})'.format(
User.objects.get(profile__main_username=username))
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse(
{"status": _("Succeeded. Please check your email.")},
status=HTTP_200_OK)
else:
log_result = 'fail to send verification mail to user(id={0})'.format(
User.objects.get(profile__main_username=username))
log_message = res_log_message(request, log_result, req_time)
logger.warning(log_message)
return JsonResponse(
{"error": _("Failure in sending email. Try later")},
status=send_mail_response_code)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
destination = request.user.profile
source_username = request.data.get('username')
source = Profile.objects.filter(main_username=source_username).first()
if source is None:
log_result = 'Fail: User not found'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": "user_not_found"}, status=HTTP_400_BAD_REQUEST)
destination_id = destination.user.id
if response.status_code == 200:
log_result = 'Success: Follow request from user_{0} accepted'.format(destination_id)
else:
log_result = 'Fail: No request from user_{0}'.format(destination_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
response = accept_handler(destination, source)
return response
def post(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
post_id = request.data.get("post_id")
tag_text = request.data.get("tag")
post = Post.objects.get(id=post_id)
# post=Post.objects.get(post_id=post_id)
# if post.profile.user != request.user
# return({({'error': _('you cant add tag to others post)},
# status=HTTP_400_BAD_REQUEST)})
tags = Tag.objects.get_or_create(text=tag_text)
tags[0].posts.add(post)
post.tags.add(tags[0])
log_result = 'tag (text={0}) added to Post (id={1}).'.format(tag_text, post_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
def post(self, request):
req_time = now_ms()
logger.info(req_log_message(request, req_time))
post_id = request.data.get("post_id")
favorite_name = request.data.get("favorite")
if not (validate_charfield_input(favorite_name, favorite_title_max_length)):
return Response({'error': _('favorite name is too long.')},
status=HTTP_400_BAD_REQUEST)
user = request.user
favorites = Favorite.objects.get_or_create(title=favorite_name, profile=user.profile)
if (Post.objects.filter(id=post_id).exists()):
favorites[0].posts.add(Post.objects.get(id=post_id))
log_result = 'Post(id={0}) added to favorite (id={1}.'.format(post_id, favorites[0].id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
else:
return Response({'error': _('no such post')},
status=HTTP_400_BAD_REQUEST)
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
contacts = []
contact_list = request.data.get('contact_list')
for contact in contact_list:
serializer = {
"contact_email": contact["email"], "contact_name": contact["name"]
}
contact_user = Profile.objects.filter(user__email=contact["email"]).first()
if contact_user is not None:
serializer['user'] = ProfileSerializer(contact_user, context={'request': request}).data
if contact_user is None:
serializer['user'] = "******"
contacts.append(serializer)
log_result = 'Success' # TODO: elaborate?
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"contacts": contacts})
def post(self, request):
""""
this should take email instead of username
"""
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
email = request.POST.get("email")
password = request.POST.get("password")
fullname = request.POST.get("fullname")
bio = request.POST.get("bio")
image = request.FILES.get("profile_picture")
username = request.POST.get("username")
response = RegisterValidation()
response = response.post(request)
if response.status_code == 400:
log_result = 'Fail: Validation failed'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return (response)
if username is None or username == "":
log_result = 'Fail: No username'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("please enter username")}, status=HTTP_400_BAD_REQUEST)
if not username_pattern.match(username):
log_result = 'Fail: Invalid username'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("bad username")}, status=HTTP_400_BAD_REQUEST)
if len(username) < 5:
log_result = 'Fail: No username'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("bad username")}, status=HTTP_400_BAD_REQUEST)
if not validate_charfield_input(bio, bio_max_length):
log_result = 'Fail: No username'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": _("long bio")}, status=HTTP_400_BAD_REQUEST)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
user = None
if Profile.objects.filter(main_username=username).count() > 0:
log_result = 'Fail: Username already taken'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': _('this username is already taken')},
status=HTTP_400_BAD_REQUEST)
# try:
# validate_password(password)
# except:
# return JsonResponse({"error": _("weak_password")}, status=HTTP_400_BAD_REQUEST)
if user is None:
user = User(username=email, email=email)
user.set_password(password)
user.save()
else:
log_result = 'Fail: Email already taken'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'error': _('this email is already taken')},
status=HTTP_400_BAD_REQUEST)
profile = Profile.objects.get(user_id=user.id)
profile.fullname = fullname
profile.bio = bio
profile.main_username = username
profile.profile_picture = image
profile.save()
log_result = 'Success: User_{0} registered'.format(user.id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return Response({'status': _('succeeded')})
def post(self, request):
req_time = now_ms()
log_message = req_log_message(request, req_time)
logger.info(log_message)
source = request.user.profile
destination_username = request.data.get('username')
destination = Profile.objects.filter(main_username=destination_username).first()
if destination is None:
log_result = 'Fail: User not found'
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"error": "user_not_find"}, status=HTTP_400_BAD_REQUEST)
destination_id = destination.user.id
if UserFollow.objects.filter(source=source, destination=destination).exists():
UserFollow.objects.get(source=source, destination=destination).delete()
data = {"type": unfollow_type,
"receiver": destination.id,
"sender": source.id,
"you": True,
"object": destination.id,
"id": 0
}
queue.enqueue(json.dumps(data))
log_result = 'Success: User_{0} unfollowed'.format(destination_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": "unfollowed"})
if destination.is_public:
UserFollow.objects.create(source=source, destination=destination)
data = {"type": follow_type,
"receiver": destination.id,
"sender": source.id,
"you": True,
"object": destination.id,
"id": 0
}
queue.enqueue(json.dumps(data))
log_result = 'Success: User_{0} followed'.format(destination_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": "followed"})
else:
if UserFollowRequest.objects.filter(source=source, destination=destination).exists():
UserFollowRequest.objects.filter(source=source, destination=destination).delete()
data = {"type": unfollow_type,
"receiver": destination.id,
"sender": source.id,
"you": True,
"object": destination.id,
"id": 0
}
queue.enqueue(json.dumps(data))
log_result = 'Success: Follow request to user_{0} withdrawn'.format(destination_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"status": "request withdrawn"})
UserFollowRequest.objects.create(source=source, destination=destination)
data = {"type": follow_request_type,
"receiver": destination.id,
"sender": source.id,
"you": True,
"object": destination.id,
"id": 0
}
queue.enqueue(json.dumps(data))
log_result = 'Success: Follow request sent to user_{0}'.format(destination_id)
log_message = res_log_message(request, log_result, req_time)
logger.info(log_message)
return JsonResponse({"statuas": "follow_request_sent"})
