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) 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 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 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 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 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 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_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 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 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() 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 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 middleware(request): info = { 'req_time': now_ms(), 'user_id': request.user.id if request.user.is_authenticated else None } request.info = info log_message = req_log_message(request, info['req_time']) logger.info(log_message) response = get_response(request) 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 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) 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() 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) 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 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 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): 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): """" 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"})