davidcr01
commented
1 year ago Update Report - DRF
Model and serializer
A new model, serializer and view have been added to manage the friend requests. The model is very similar to the FriendList:
class FriendRequest(models.Model):
sender = models.ForeignKey(Player, on_delete=models.CASCADE, related_name='requests_sent')
receiver = models.ForeignKey(Player, on_delete=models.CASCADE, related_name='requests_received')
timestamp = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [
models.UniqueConstraint(fields=['sender', 'receiver'], name='unique_friendrequest') ]
def clean(self):
if self.sender == self.receiver:
raise ValidationError('You can not be send a request to yourself.')
if FriendRequest.objects.filter(sender=self.receiver, receiver=self.sender).exists():
raise ValidationError('This friend request already exists.')
def __str__(self):
return f"{self.sender.user.username} - {self.receiver.user.username}"About the serializer, is a little bit different from the FriendList serializer. In this case, we do not return the receiver field. This is done to get the friend request correctly and ignoring the receiver, who is the player itself. Also, the ID of the request is added in the serializer:
class FriendRequestSerializer(serializers.ModelSerializer):
sender = serializers.SerializerMethodField()
class Meta:
model = FriendRequest
fields = ['id', 'sender']
def get_sender(self, obj):
return {'username': obj.sender.user.username, 'id': obj.sender.user.id}View
As the friend requests manage the friend list and the notification, and relates two players, the view is a little complex:
-
The GET method lists all the requests where the receiver is the identified player.
class FriendRequestViewSet(viewsets.ReadOnlyModelViewSet): queryset = FriendRequest.objects.all() serializer_class = FriendRequestSerializer permission_classes = [permissions.IsAuthenticated] def list(self, request, *args, **kwargs): player = getattr(request.user, 'player', None) if not player: return Response({'error': 'Player not found'}, status=404) queryset = FriendRequest.objects.filter(receiver=player).order_by('timestamp') serializer = self.get_serializer(queryset, many=True) return Response(serializer.data) -
About the POST method to create new requests (the identified player is the sender), some checks have to be done:
- Check if the player is actually a player.
- Check if the receiver_id parameter is in the body.
- Check if the receiver exists.
- Prohibiting requesting to yourself.
- Check if the request exists.
- Check if the friendship exists.
- If everything is ok, create the request and notify it.
def create(self, request, *args, **kwargs):
sender = getattr(request.user, 'player', None)
if not sender:
return Response({'error': 'Player not found'}, status=404)
receiver_id = request.data.get('receiver_id')
if not receiver_id:
return Response({'error': 'receiver_id is required'}, status=status.HTTP_400_BAD_REQUEST)
try:
receiver = Player.objects.get(id=receiver_id)
except Player.DoesNotExist:
return Response({'error': 'Receiver not found'}, status=status.HTTP_404_NOT_FOUND)
if sender == receiver:
return Response({'error': 'Cannot send friend request to yourself'}, status=status.HTTP_400_BAD_REQUEST)
# Check if there is an existing request
existing_request = FriendRequest.objects.filter(sender=sender, receiver=receiver)
if existing_request.exists():
return Response({'error': 'Friend request already sent'}, status=status.HTTP_400_BAD_REQUEST)
# Check if there is an existing friendship
existing_friendship1 = FriendList.objects.filter(sender=sender, receiver=receiver)
existing_friendship2 = FriendList.objects.filter(sender=receiver, receiver=sender)
if existing_friendship1.exists() or existing_friendship2.exists():
return Response({'error': 'Friendship already exists'}, status=status.HTTP_400_BAD_REQUEST)
# Create the request and notify it
friend_request = FriendRequest.objects.create(sender=sender, receiver=receiver)
Notification.objects.create(
player=receiver,
text='You have a new friend request!',
link='http://localhost:8100/friendlist'
)
serializer = FriendRequestSerializer(friend_request)
return Response(serializer.data, status=status.HTTP_201_CREATED)To accept or decline requests, a decorator is used in the POST request. This allows the POST request to add a sub-url, (/{idRequest}/[accept/reject])
In this case:
- If the receiver accepts, the friendship is created and is notified to both users. The request is destroyed
- If the receiver denies, the request is destroyed.
@action(detail=True, methods=['post'])
def accept(self, request, *args, **kwargs):
instance = self.get_object()
receiver = getattr(request.user, 'player', None)
if not receiver:
return Response({'error': 'Player not found'}, status=404)
if instance.receiver != receiver:
return Response({'error': 'Permission denied'}, status=403)
# Create the friendship
FriendList.objects.create(sender=instance.sender, receiver=receiver)
# Create notification for both players
Notification.objects.create(
player=instance.sender,
text=f"You are now friends with {receiver.user.username}.",
link='http://localhost:8100/friendlist'
)
Notification.objects.create(
player=receiver,
text=f"You are now friends with {instance.sender.user.username}.",
link='http://localhost:8100/friendlist'
)
instance.delete()
return Response({'message': 'Friend request accepted'}, status=200)
@action(detail=True, methods=['post'])
def reject(self, request, *args, **kwargs):
instance = self.get_object()
receiver = request.user.player
if instance.receiver != receiver:
return Response({'error': 'Permission denied'}, status=403)
instance.delete()
return Response({'message': 'Friend request rejected'}, status=200)The URL is added to the router:
router.register('api/friendrequest', FriendRequestViewSet, basename='friendrequest')Testing
The following screenshots show the whole process.
- Sender: player, 36dcbcf7e091925a5aa1dfa5ffab38a478b5aadc
- Receiver: player2, 837d2b53937f093594fc15201423a28bd64a9340. ID Player: 9
Creating the request as player:
As player2, we list the pending requests:
The ID of the request is 8.
The player2 rejects the request, and no requests are left:
The request is created again, and accepted. The friendship and notifications are created:
Description
As a player, is necessary to implement a new logic to search for another player by its username and send a friend request.