def post(self, request, **kwargs):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
search_type = serializer.validated_data.get("search_type")
search_string = self.request.query_params.get('search')
if search_type == "user":
users = User.objects.all()
queryset = users.filter(
Q(username__contains=search_string)
| Q(first_name__contains=search_string)
| Q(last_name__contains=search_string))
return Response(UserSerializer(queryset, many=True).data)
elif search_type == "review":
reviews = Review.objects.all()
queryset = reviews.filter(
Q(content__contains=search_string)
| Q(comment__contains=search_string))
return Response(UserSerializer(queryset, many=True).data)
elif search_type == "restaurant":
restaurants = Restaurant.objects.all()
queryset = restaurants.filter(
Q(name__contains=search_string)
| Q(street__contains=search_string)
| Q(country__contains=search_string)
| Q(category__contains=search_string))
return Response(UserSerializer(queryset, many=True).data)
class FriendRequestSerializer(serializers.ModelSerializer):
sender = UserSerializer(read_only=True)
receiver = UserSerializer(read_only=True)
class Meta:
model = Friendship
fields = ['id', 'sender', 'receiver', 'status']
read_only_fields = fields
def get(self, request, user_id):
try:
user = User.objects.get(id=user_id)
except User.DoesNotExist:
raise Http404
serializer = UserSerializer(user)
return Response(serializer.data)
class FeedDisplaySerializer(PostSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Post
fields = ['id', 'content', 'created', 'user']
read_only_fields = ['created', 'id', 'user']
def post(self, request, user_id):
user = self.get_object(user_id)
user_profile, created = Profile.objects.get_or_create(
user=request.user)
user_profile.followees.remove(user)
serializer = UserSerializer(user)
return Response(serializer.data)
def get(self, request, user_id):
"""
GET: Get specific user profile
"""
user = User.objects.get(id=user_id)
serializer = UserSerializer(user)
return Response(serializer.data)
def get(self, request):
"""
GET: list of all the people the user is following
"""
user_profile = UserProfile.objects.get(user=request.user)
followings = user_profile.following.all()
serializer = UserSerializer(followings, many=True)
return Response(serializer.data)
def post(self, request, user_id):
user = self.get_object(user_id)
user_profile, created = Profile.objects.get_or_create(
user=request.user)
user_profile.followees.add(user)
serializer = UserSerializer(user)
self.send_email(user.email, request.user.username)
return Response(serializer.data)
def get(self, request):
"""
/api/users/followers/
"""
# followers = [p.user for p in request.user.followers.all()]
followers = User.objects.filter(profile__following=request.user)
serializer = UserSerializer(followers, many=True)
return Response(serializer.data)
def get(self, request):
return Response(
UserSerializer(User.objects.filter(
Q(
Q(friend_request__receiver=request.user)
| Q(friend_request__status='accepted')
| Q(friend_requested__sender=request.user)
| Q(friend_requested__status='accepted'))),
many=True).data)
def get(self, request):
# print all users either with or without search params
search = request.query_params.get('search')
if search:
users = User.objects.filter(username__contains=search)
else:
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
def get(self, request):
"""
GET: List all friends
"""
user = request.user
friends = User.objects.filter(
Q(received_requests__request_status='accepted')
| Q(sent_requests__request_status='accepted'),
Q(sent_requests__request_from=user)
| Q(sent_requests__request_to=user)
| Q(received_requests__request_to=user)
| Q(received_requests__request_from=user)).exclude(
id=user.id).distinct()
return Response(UserSerializer(friends, many=True).data)
def get(self, request):
"""
GET: Get all the users or search using query string via url params
"""
query_string = request.query_params.get('q')
users = User.objects.all()
if query_string:
users = users.filter(
Q(username__contains=query_string)
| Q(first_name__contains=query_string)
| Q(last_name__contains=query_string)
| Q(email__contains=query_string))
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
class PostSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Post
fields = ['id', 'content', 'created', 'user']
read_only_fields = ['created', 'id', 'user']
def to_representation(self, post):
data = super().to_representation(post)
return {
**data,
'likes_count': post.likes.count(),
}
def update(self, post, validated_data):
content = validated_data.get('content')
post.content = content
post.save()
return post
def get(self, request):
users = User.objects.filter(user_profile__followees=request.user)
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
def get(self, request):
followers = request.user.user_profile.followees.all()
serializer = UserSerializer(followers, many=True)
return Response(serializer.data)
def get(self, request):
return Response(UserSerializer(User.objects.all()).data)
def get(self, user_id):
return Response(UserSerializer(User.objects.filter(user_id)).data)
def get(self, category_id):
return Response(UserSerializer(User.objects.filter(category_id)).data)
