def chat_authenticate(self, event): token = event.get('access_token', None) user = authenticate(token) self.user = user if (user.is_anonymous): self.send( json.dumps({ "error": get_error_serialized(AUTHENTICATION_FAILED).data })) self.close() return if (user.username != self.room_name): self.send( json.dumps( {"error": get_error_serialized(PERMISSION_DENIED).data})) self.close() return last_seen_data = LastSeen.objects.filter(user=user).first() if (last_seen_data is None): last_seen_data = LastSeen.objects.create(user=self.user) # last_seen_data.last_seen = now() last_seen_data.save() record = Clients.objects.filter( username=user, channel_name=self.channel_name).first() if (record is None): Clients.objects.create(username=user, channel_name=self.channel_name) self.send( json.dumps({ "type": "chat.authenticate", "message": "Authenticatied." }))
def get_reply_comments(request): reply_to = request.query_params.get('reply_to', None) depth = request.query_params.get('depth', None) startIdx = request.query_params.get('start_index', None) length = request.query_params.get('max_len', None) reply_len = request.query_params.get('max_reply_len', None) viewer = request.query_params.get('viewer') if not (depth and reply_to and startIdx and length): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) try: startIdx = int(startIdx) length = int(length) except: return JsonResponse(get_error_serialized( 103, "Integer conversion error!").data, status=HTTPStatus.BAD_REQUEST) if (viewer is None and not request.user.is_anonymous): viewer = request.user.username comment = Comment.objects.filter(id=reply_to).first() if (comment is None): return JsonResponse(get_error_serialized(100, "Comment not found!").data, status=HTTPStatus.NOT_FOUND) return JsonResponse(RepliedCommentSerializer(comment, context={ 'depth': depth, 'start_index': startIdx, 'max_len': reply_len, 'viewer': viewer, 'start_index': startIdx }).data, status=HTTPStatus.OK)
def posts_by_hashtag(request): user = request.user hashtag_text = request.query_params.get('hashtag', None) if hashtag_text == "": hashtag_text = None if hashtag_text is None: return JsonResponse( { "error": get_error_serialized(103, 'hashtag field is required').data }, status=status.HTTP_400_BAD_REQUEST) hashtag = Hashtag.objects.filter(text=hashtag_text).first() if hashtag is None: return JsonResponse( {"error": get_error_serialized(100, 'Hashtag not found').data}, status=status.HTTP_404_NOT_FOUND) posts_found_id = PostHashtag.objects.filter(hashtag=hashtag).values_list( 'post', flat=True) posts_found = Post.objects.filter(Q(pk__in=posts_found_id)) return JsonResponse({ "posts": PostSerializer(posts_found, many=True, context={ "content_depth": False }).data })
def delete_community(request): user = request.user community_name = request.data.get('community_name', None) community = Community.objects.filter( name__iexact=community_name.lower()).first() if community is None: return JsonResponse( {"error": get_error_serialized(100, 'Community not found').data}, status=status.HTTP_404_NOT_FOUND) if community.admin != user: return JsonResponse( { "error": get_error_serialized( 106, 'Only community admin is allowed for this request').data }, status=status.HTTP_404_NOT_FOUND) community.delete() return JsonResponse({"message": "Community deleted successfuly"})
def send_unfollow(request): user = request.user to_unfollow_username = request.query_params.get('to_unfollow', None) if to_unfollow_username is None: return JsonResponse({ "error": get_error_serialized( 103, 'Username of to unfollow user must be sended').data }) to_unfollow = User.objects.filter(username=to_unfollow_username).first() if to_unfollow is None: return JsonResponse({ "error": get_error_serialized( 100, 'User with sended username does not exists').data }) finded_following = UserFollowing.objects.filter( user=user, following_user=to_unfollow).first() if finded_following is None: return JsonResponse({"error": get_error_serialized(111).data}) finded_following.delete() return JsonResponse( {"message": f"User {to_unfollow_username} unfollowed successfuly"})
def send_follow(request): user = request.user to_follow_username = request.data.get('to_follow', None) if to_follow_username is None: return JsonResponse({ "error": get_error_serialized( 103, 'Username of to follow user must be sended').data }) to_follow = User.objects.filter(username=to_follow_username).first() if to_follow is None: return JsonResponse({ "error": get_error_serialized( 100, 'User with sended username does not exists').data }) if UserFollowing.objects.filter(user=user, following_user=to_follow).exists(): return JsonResponse({"error": get_error_serialized(112).data}) UserFollowing.objects.create(user=user, following_user=to_follow) return JsonResponse({ "message": f"user {to_follow.username} followed by {user.username} successfuly" })
def user_followings(request): viewer = request.user username = request.query_params.get('username', None) if username is None: return JsonResponse( {"error": get_error_serialized(103, 'Username is required').data}) user = User.objects.filter(username=username).first() if user is None: return JsonResponse({ "error": get_error_serialized( 100, 'User with sended username does not exists').data }) user_following_ids = list( UserFollowing.objects.filter(user=user).values_list('following_user')) # replace viewer followings to first user_following_ids.sort(key=lambda user_id: UserFollowing.objects.filter( user=viewer.id, following_user=user_id).exists(), reverse=True) # replace viewer to first place # viewer_index = user_following_ids.index(viewer.id) # user_following_ids[0], user_following_ids[viewer_index] = user_following_ids[viewer_index], user_following_ids[0] user_followings = [ User.objects.get(id=user_id[0]) for user_id in user_following_ids ] user_followings_serialized = PublicProfileSerializer( user_followings, context={"viewer_id": viewer.id}, many=True) return JsonResponse({"user_followings": user_followings_serialized.data})
def chat_user_profile(self, event): username = event.get("username", None) if (username is None): self.send( json.dumps({ "error": get_error_serialized(MISSING_REQUIRED_FIELDS).data })) return User = get_user_model() user = User.objects.filter(username=username).first() if user is None: self.send( json.dumps({ "error": get_error_serialized(OBJECT_NOT_FOUND, detail="user not found.").data })) return self.send( json.dumps({ "type": "chat.user.profile", "user": PublicProfileSerializer(user).data })) return
def chat_message_get(self, event): if (self.user is None): self.send( json.dumps({ "error": get_error_serialized(AUTHENTICATION_REQUIRED).data })) return other_user = event.get("from", None) offset = event.get("offset", None) count = event.get("count", None) if (other_user is None): self.send( json.dumps({ "error": get_error_serialized(MISSING_REQUIRED_FIELDS).data })) return offset = utils.int_try_parse(offset, 0) count = utils.int_try_parse(count, utils.INFINITY) Users = get_user_model() other_user = Users.objects.filter(username=other_user).first() if (other_user is None): self.send( json.dumps({ "error": get_error_serialized( MISSING_REQUIRED_FIELDS, detail="User to get messages not found!").data })) return chats = list( DirectChatMessage.objects.filter(_from=self.user, _to=other_user)) chats += list( DirectChatMessage.objects.filter(_from=other_user, _to=self.user)) chats = sorted(chats, key=lambda x: x.date)[::-1] result = [] if (offset < len(chats)): chats = chats[offset:offset + count] else: chats = [] for chat in chats: result.append( DirectChatViewSerializer(chat, context={ "target_username": self.user.username }).data) self.send( json.dumps({ "type": "chat.message.get", "_user": PublicProfileSerializer(other_user).data, "data": json.dumps(result) }))
def get_post_comments(request): post_id = request.query_params.get('post_id', None) depth = request.query_params.get('depth', '0') startIdx = request.query_params.get('start_index', None) length = request.query_params.get('max_len', None) reply_len = request.query_params.get('max_reply_len', None) viewer = request.query_params.get('viewer') if not (depth and post_id and startIdx and length): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) try: startIdx = int(startIdx) length = int(length) depth = int(depth) except: return JsonResponse(get_error_serialized( 103, "Integer conversion error!").data, status=HTTPStatus.BAD_REQUEST) if (viewer is None and not request.user.is_anonymous): viewer = request.user.username post = Post.objects.filter(id=post_id).first() if (post is None): return JsonResponse(get_error_serialized(100, "Post not found!").data, status=HTTPStatus.NOT_FOUND) post_comments = PostReply.objects.filter(post=post_id) result = [] post_comments = list(post_comments) total_comments = len(post_comments) if (startIdx >= len(post_comments)): post_comments = [] else: post_comments = post_comments[startIdx:startIdx + length] for comment in list(post_comments): comment = comment.reply if (comment is None): continue result.append( RepliedCommentSerializer(comment, context={ 'depth': str(depth - 1), 'max_len': reply_len, 'viewer': viewer, 'start_index': startIdx }).data) return JsonResponse( { 'post_id': post_id, 'total_comments': total_comments, 'retrived_comments_count': len(result), 'comments': result }, status=HTTPStatus.OK)
def send_report(request): user = request.user post_id = request.data.get('post_id', None) subjects = request.data.get('subjects', None) description = request.data.get('description', None) if subjects is None or len(subjects) == 0 or post_id is None: return JsonResponse( { "error": get_error_serialized( 103, 'post_id, subjects fields is required').data }, status=status.HTTP_400_BAD_REQUEST) subjects_obj = [] for subject in subjects: report_subject = ReportSubject.objects.filter(text=subject).first() if report_subject is None: return JsonResponse( { "error": get_error_serialized( 100, f'This subject is not allowed: \'{subject}\'').data }, status=status.HTTP_400_BAD_REQUEST) subjects_obj.append(report_subject) report_post = Post.objects.filter(id=post_id).first() if report_post is None: return JsonResponse( {"error": get_error_serialized(100, 'Post not found').data}, status=status.HTTP_404_NOT_FOUND) if Reports.objects.filter(user=user, post=report_post).exists(): return JsonResponse({"error": get_error_serialized(115).data}, status=status.HTTP_406_NOT_ACCEPTABLE) created_report = Reports.objects.create(user=user, post=report_post, description=description) for subject in subjects_obj: PostReport.objects.create(subject=subject, report=created_report) report_post.reports_number += 1 return JsonResponse( {"message": f"report to post with id:{post_id} sended"})
def get_public_profile(request): viewer = request.user username = request.query_params.get('username', None) if (username is None): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) user = User.objects.filter(username=username).first() if (user is None): return JsonResponse(get_error_serialized(100, "User not found!").data, status=HTTPStatus.NOT_FOUND) public_profile = PublicProfileSerializer(user, context={"viewer_id": viewer.id}) data = public_profile.data data['follower'] = "5" data['follower'] = "10" data['nickname'] = user.first_name + ' ' + user.last_name user_posts = Post.objects.filter(author=user.id) if (user_posts is not None): data['posts_count'] = str(len(list(user_posts))) else: data['posts_count'] = "0" post_likes = list(PostLike.objects.filter(user=user.id)) comment_likes = list(CommentLike.objects.filter(user=user.id)) data['likes_count'] = len(post_likes) + len(comment_likes) comment_serializer = UserCommentSerializer(user) if (comment_serializer is not None): data['comments_count'] = str( len(comment_serializer.get_post_replies(user)) + len(comment_serializer.get_comment_replies(user))) else: data['comments_count'] = "0" return JsonResponse(data=data, status=HTTPStatus.OK)
def chat_users(self, event): if (self.user is None): self.send( json.dumps({ "error": get_error_serialized(AUTHENTICATION_REQUIRED).data })) return chats_from_user = list( DirectChatMessage.objects.filter(_from=self.user)) chats_to_user = list(DirectChatMessage.objects.filter(_to=self.user)) records = chats_from_user + chats_to_user records = sorted(records, key=lambda x: x.date)[::-1] users = [] for record in records: if (record._from.id == self.user.id and record._to not in users): users.append(record._to) elif (record._to.id == self.user.id and record._from not in users): users.append(record._from) result = [] for user in users: result.append( ChatUsersSerializer(user, context={ "target_username": self.user.username }).data) self.send(json.dumps({"type": "chat.users", "data": result}))
def get_hashtag_posts(request): hashtag_text = request.query_params.get('text', None) sort = request.query_params.get('sort', 'latest') viewer = None if not (request.user.is_anonymous): viewer = request.user.username if (hashtag_text is None): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) hashtag = Hashtag.objects.filter(text=hashtag_text).first() if (hashtag is None): return JsonResponse(get_error_serialized(100, "Hashtag not found!").data, status=HTTPStatus.NOT_FOUND) records = PostHashtag.objects.filter(hashtag=hashtag.id) posts = [record.post for record in records] if (sort == 'latest'): posts = sorted(posts, key=lambda x: x.date_created)[::-1] elif (sort == 'popular'): posts = sorted( posts, key=lambda x: len(PostLike.objects.filter(post=x.id)))[::-1] return JsonResponse( { 'hashtag': HashtagSerializer(hashtag).data, 'posts': PostSerializer(posts, many=True, context={ 'viewer': viewer }).data }, status=HTTPStatus.OK)
def submit_reply_comment(request): user = request.user reply_to = request.data.get('reply_to_id') content = request.data.get('content') if not (user and reply_to and content): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) comment = Comment.objects.filter(id=reply_to).first() if (comment is None): return JsonResponse(get_error_serialized(100, "Comment not found!").data, status=HTTPStatus.NOT_FOUND) data = {'author': user.id, 'content': content} new_comment = CommentSerializer(data=data) if (new_comment.is_valid()): new_comment.save() else: return JsonResponse(new_comment.errors, status=HTTPStatus.BAD_REQUEST) data = {'reply_to': reply_to, 'reply': new_comment.instance.id} reply_comment = CommentReplySerializer(data=data) if (reply_comment.is_valid()): reply_comment.save() else: return JsonResponse(reply_comment.errors, status=HTTPStatus.BAD_REQUEST) return JsonResponse( { 'message': 'Comment submitted.', 'comment': DisplayCommentSerializer(new_comment.instance).data }, status=HTTPStatus.CREATED)
def submit_post_comment(request): user = request.user post_id = request.data.get('post') content = request.data.get('content') if not (content and post_id and user): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) post = Post.objects.filter(id=post_id).first() if (post is None): return JsonResponse(get_error_serialized(100, "Post not found!").data, status=HTTPStatus.NOT_FOUND) data = {'author': user.id, 'content': content} comment = CommentSerializer(data=data) if (comment.is_valid()): comment.save() else: return JsonResponse(comment.errors, status=HTTPStatus.BAD_REQUEST) data = {'post': post_id, 'reply': comment.instance.id} reply_post = PostReplySerializer(data=data) if (reply_post.is_valid()): reply_post.save() else: return JsonResponse(reply_post.errors, status=HTTPStatus.BAD_REQUEST) return JsonResponse( { 'message': 'Comment submitted.', 'comment': DisplayCommentSerializer(comment.instance).data }, status=HTTPStatus.CREATED)
def search_in_users(request): serach_key = request.query_params.get('key', None) if (serach_key is None): return JsonResponse( {'error': get_error_serialized(103, 'key parameter is required')}, status=HTTPStatus.BAD_REQUEST) data_usernames = [] data_firstnames = [] data_lastnames = [] for user in User.objects.all(): data_usernames.append((user.username, user.id)) data_firstnames.append((user.first_name, user.id)) data_lastnames.append((user.last_name, user.id)) all_users_finded = [] all_users_finded.extend(list(set(search(serach_key, data_usernames)))) all_users_finded.extend(list(set(search(serach_key, data_firstnames)))) all_users_finded.extend(list(set(search(serach_key, data_lastnames)))) all_users_finded_ = User.objects.filter(Q(id__in=all_users_finded)) return JsonResponse({ "users_finded": PublicProfileSerializer(all_users_finded_, many=True).data })
def update_community(request): user = request.user community_name = request.data.get('community_name', None) community = Community.objects.filter( name__iexact=community_name.lower()).first() if community is None: return JsonResponse( {"error": get_error_serialized(100, 'Community not found').data}, status=status.HTTP_404_NOT_FOUND) if community.admin != user: return JsonResponse( { "error": get_error_serialized( 106, 'Only community admin is allowed for this request').data }, status=status.HTTP_404_NOT_FOUND) new_name = request.data.get('name', None) new_about = request.data.get('about', None) new_pic = request.data.get('picture', None) new_banner = request.data.get('banner_picture', None) if not (new_name is None): if Community.objects.filter(name__iexact=new_name.lower()).exists(): return JsonResponse({"error": get_error_serialized(109).data}, status=status.HTTP_400_BAD_REQUEST) community.name = new_name.lower() community.save(update_fields=['name']) if not (new_about is None): community.about = new_about community.save(update_fields=['about']) if not (new_pic is None): community.picture = new_pic community.save(update_fields=['picture']) if not (new_banner is None): community.banner_picture = new_banner community.save(update_fields=['banner_picture']) return JsonResponse({"message": "all fields updated successfuly"})
def delete_post_like(request): user = request.user post_id = request.data.get('id', None) if not (post_id and user): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) post = Post.objects.filter(id=post_id).first() if (post is None): return JsonResponse(get_error_serialized(100, "Post not found!").data, status=HTTPStatus.NOT_FOUND) like = PostLike.objects.filter(user=user.id, post=post.id).first() if (like is None): return JsonResponse(get_error_serialized(100, "Like not found!").data, status=HTTPStatus.NOT_FOUND) like.delete() return JsonResponse({"message": "Like deleted successfully."}, status=HTTPStatus.OK)
def chat_message_see(self, event): other_side_message_type = "chat.message.saw" chat_id = event.get("id", None) if (self.user is None): self.send( json.dumps({ "error": get_error_serialized(AUTHENTICATION_REQUIRED).data })) return if (chat_id is None): self.send( json.dumps({ "error": get_error_serialized(MISSING_REQUIRED_FIELDS).data })) return chat = DirectChatMessage.objects.filter(id=chat_id).first() if (chat is None): self.send( json.dumps({ "error": get_error_serialized(OBJECT_NOT_FOUND, detail="chat not found.").data })) return if (chat._to != self.user): self.send( json.dumps( {"error": get_error_serialized(PERMISSION_DENIED).data})) return chat.seen = True chat.save() other_side = chat._from other_side_sessions = Clients.objects.filter(username=other_side) data = { "type": other_side_message_type, "id": chat_id, 'user': PublicProfileSerializer(self.user).data, 'uuid': str(chat.uuid) } for session in other_side_sessions: channel_layer = get_channel_layer() async_to_sync(channel_layer.send)(session.channel_name, data)
def reports_number(request): post_id = request.query_params.get('post_id', None) if post_id is None: return JsonResponse( { "error": get_error_serialized(103, 'post_id field is required').data }, status=status.HTTP_400_BAD_REQUEST) post = Post.objects.filter(id=post_id).first() if post is None: return JsonResponse( {"error": get_error_serialized(100, 'Post not found').data}, status=status.HTTP_404_NOT_FOUND) reports_number = Reports.objects.filter(post=post).count() return JsonResponse({"reports_number": reports_number})
def chat_control(self, event): _from = event.get("from", None) _to = event.get("to", None) data = event.get("data", None) if (self.user is None): self.send( json.dumps({ "error": get_error_serialized(AUTHENTICATION_REQUIRED).data })) return if (_to is None and _from is None) or ( (_to is not None and _from is not None) or data is None): self.send( json.dumps({ "error": get_error_serialized(MISSING_REQUIRED_FIELDS).data })) return User = get_user_model() if (_to is not None): user_to = User.objects.filter(username=_to).first() if (user_to is None): self.send( json.dumps({ "error": get_error_serialized(OBJECT_NOT_FOUND, detail="user not found.").data })) return active_sessions = Clients.objects.filter(username=user_to) for session in active_sessions: send_data = { "type": "chat.control", "from": self.user.username, "data": data } channel_layer = get_channel_layer() async_to_sync(channel_layer.send)(session.channel_name, send_data) #recieved control message from other users so send it to client elif (_from is not None): self.send(json.dumps(event))
def disable_user(request): user = request.user community_name = request.data.get('community_name', None) if community_name is None: return JsonResponse( { "error": get_error_serialized( 103, '\'community_name\' field is required').data }, status=status.HTTP_400_BAD_REQUEST) community = Community.objects.filter( name__iexact=community_name.lower()).first() if community is None: return JsonResponse( {"error": get_error_serialized(100, 'Community not found').data}, status=status.HTTP_404_NOT_FOUND) if community.admin != user: return JsonResponse( { "error": get_error_serialized( 106, 'Only community admin is allowed for this request').data }, status=status.HTTP_404_NOT_FOUND) username = request.data.get('username', None) dis_user = User.objects.filter(username=username).first() if dis_user is None: return JsonResponse( {"error": get_error_serialized(100, 'User not found').data}, status=status.HTTP_400_BAD_REQUEST) community.disabeled_users.add(dis_user) return JsonResponse( {"message": "User added to disabeled users successfuly"})
def get_post_likes(request): post_id = request.query_params.get('id', None) if (post_id is None): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) post = Post.objects.filter(id=post_id).first() if (post is None): return JsonResponse(get_error_serialized(100, "Post not found!").data, status=HTTPStatus.NOT_FOUND) return JsonResponse(ViewPostLikesSerializer(post).data, status=HTTPStatus.OK)
def post_reports(request): post_id = request.query_params.get('post_id', None) if post_id is None: return JsonResponse( { "error": get_error_serialized(103, 'post_id field is required').data }, status=status.HTTP_400_BAD_REQUEST) post = Post.objects.filter(id=post_id).first() if post is None: return JsonResponse( {"error": get_error_serialized(100, 'Post not found').data}, status=status.HTTP_404_NOT_FOUND) all_reports = Reports.objects.filter(post=post) return JsonResponse( {"reports": ReportSerializer(all_reports, many=True).data})
def remove_user(request): user = request.user community_name = request.data.get('community_name', None) community = Community.objects.filter( name__iexact=community_name.lower()).first() if community is None: return JsonResponse( {"error": get_error_serialized(100, 'Community not found').data}, status=status.HTTP_404_NOT_FOUND) if community.admin != user: return JsonResponse( { "error": get_error_serialized( 106, 'Only community admin is allowed for this request').data }, status=status.HTTP_404_NOT_FOUND) username = request.data.get('username', None) del_user = User.objects.filter(username=username).first() if del_user is None: return JsonResponse( {"error": get_error_serialized(100, 'User not found').data}, status=status.HTTP_400_BAD_REQUEST) if not community.users.filter(username=username).exists(): return JsonResponse({"error": get_error_serialized(117).data}, status=status.HTTP_400_BAD_REQUEST) if del_user == user: return JsonResponse({"error": get_error_serialized(118).data}, status=status.HTTP_400_BAD_REQUEST) community.users.remove(del_user) return JsonResponse({"message": "User removed from community successfuly"})
def get_comment_likes(request): comment_id = request.query_params.get('id', None) if (comment_id is None): return JsonResponse(ErrorSerializer(get_error(103)).data, status=HTTPStatus.BAD_REQUEST) comment = Comment.objects.filter(id=comment_id).first() if (comment is None): return JsonResponse(get_error_serialized(100, "Coment not found!").data, status=HTTPStatus.NOT_FOUND) return JsonResponse(ViewCommentLikesSerializer(comment).data, status=HTTPStatus.OK)
def is_admin(request): user = request.user communtiy_name = request.query_params.get('community', None) if communtiy_name is None: return JsonResponse( { "error": get_error_serialized(103, '\'community\' field is required').data }, status=status.HTTP_400_BAD_REQUEST) community = Community.objects.filter( name__iexact=communtiy_name.lower()).first() if community is None: return JsonResponse( {"error": get_error_serialized(100, 'Community not found').data}, status=status.HTTP_404_NOT_FOUND) is_admin = community.admin == user return JsonResponse({"is_admin": is_admin})
def get_usneen_messages_count(self, instance): target_username = self.context.get("target_username", None) target = User.objects.filter(username=target_username).first() if (target is None): return { "error": get_error_serialized(OBJECT_NOT_FOUND, detail="User not found.") } records = list( DirectChatMessage.objects.filter(_from=instance, _to=target)) return len([r for r in records if not r.seen])
def update_password(request): user = request.user old_pass = request.data.get('old_password', None) new_pass = request.data.get('new_password', None) if not (old_pass and new_pass): return JsonResponse( { "error": get_error_serialized( 103, "new_password or old_password field is required").data }, status=status.HTTPStatus.BAD_REQUEST) if not User.check_password(user, old_pass): return JsonResponse({"error": get_error_serialized(101).data}, status=HTTPStatus.BAD_REQUEST) user.set_password(new_pass) user.save(update_fields=['password']) return JsonResponse({"message": "password successfuly updated"})