More Efficient List Views with Pagination:

We will apply pagination in views

  • use paginator for tweet_feed_view in /tweets/api/views.py ```python from rest_framework.pagination import PageNumberPagination # new

@api_view([‘GET’]) @permission_classes([IsAuthenticated]) def tweet_feed_view(request, args, *kwargs): paginator = PageNumberPagination() # new paginator.page_size = 20 # new

  1. user = request.user
  2. qs = Tweet.objects.feed(user)
  4. paginated_qs = paginator.paginate_queryset(qs, request)  # new
  5. # serializer = TweetSerializer(qs, many=True)
  6. serializer = TweetSerializer(paginated_qs, many=True)  
  8. # return Response(serializer.data, status=200)
  9. return paginator.get_paginated_response(serializer.data)
  1. after this setup, each page of [http://localhost/api/tweets/feed/](http://localhost/api/tweets/feed/) will only show a query set of 20 tweets, but also provides a link to its next and previous page. 
  3. to test, runserver, access [http://localhost/api/tweets/feed/?page=2](http://localhost/api/tweets/feed/?page=2)<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/1243266/1596817561794-5ec0c546-24b7-4671-b64a-0ee5a6d165a0.png#align=left&display=inline&height=473&margin=%5Bobject%20Object%5D&name=image.png&originHeight=945&originWidth=1675&size=96049&status=done&style=none&width=837.5)<br />Here we only can see 20 tweets, and 2 urls called "next" and "previous".<br />We are on page 2, so we have a "next" to page 3, and "previous" to page 1 (or homepage because there is no "?page="), and those are also pages with 20 tweets. 
  5. - we better split feed view and pagination into tweet_feed_view and get_paginated_queryset_response in /tweets/api/views.py
  6. ```python
  7. '''
  8. @api_view(['GET'])
  9. @permission_classes([IsAuthenticated])
  10. def tweet_feed_view(request, *args, **kwargs):
  11.     paginator = PageNumberPagination()  
  12.     paginator.page_size = 20  
  14.     user = request.user
  15.     qs = Tweet.objects.feed(user)
  17.     paginated_qs = paginator.paginate_queryset(qs, request) 
  18.     serializer = TweetSerializer(paginated_qs, many=True)
  20.     return paginator.get_paginated_response(serializer.data)
  21. '''
  23. def get_paginated_queryset_response(qs, request):
  24.     paginator = PageNumberPagination()
  25.     paginator.page_size = 20
  27.     paginated_qs = paginator.paginate_queryset(qs, request)
  28.     serializer = TweetSerializer(paginated_qs, many=True)
  30.     return paginator.get_paginated_response(serializer.data) 
  33. @api_view(['GET'])
  34. @permission_classes([IsAuthenticated])
  35. def tweet_feed_view(request, *args, **kwargs):
  36.    user = request.user
  37.    qs = Tweet.objects.feed(user)
  38.     return get_paginated_queryset_response(qs, request)

nothing changes in actually shown feed view.

User Profile Serializer:

timestamp and user id:

  • we add a user variable for all tweets in /tweets/serializers.py

    1. # ...
    2. class TweetSerializer(serializers.ModelSerializer):
    3.   user = serializers.SerializerMethodField(read_only=True)  # new
    4.   likes = serializers.SerializerMethodField(read_only=True)
    5.   parent = TweetCreateSerializer(read_only=True)
    7.   class Meta:
    8.       model = Tweet
    9.       # fields = ['id', 'content', 'likes', 'is_retweet']
    10.       fields = ['user', 'id', 'content', 'likes', 'is_retweet', 'parent']  # new
    12.   def get_likes(self, obj):
    13.       return obj.likes.count()
    15.   def get_user(self, obj):  # new
    16.       return obj.user.id

    runserver, and access http://localhost/api/tweets/
    image.png
    we can see the user id of the sender of each tweet is shown.

  • further in /tweets/serializers.py

    • also setup user in TweetCreateSerializer

    • both add “timestamp” ```python class TweetCreateSerializer(serializers.ModelSerializer): user = serializers.SerializerMethodField(read_only=True) # new likes = serializers.SerializerMethodField(read_only=True)

      class Meta: model = Tweet

      fields = [‘id’, ‘content’, ‘likes’]

      fields = [

      1.    'user',
      2.    'id',
      3.    'content',
      4.    'likes',
      5.    'timestamp'

      ]

      def get_likes(self, obj): return obj.likes.count()

      def validate_content(self, value): if len(value) > MAX_TWEET_LENGTH:

      1.    raise serializers.ValidationError("This tweet is too long")

      return value

      def get_user(self, obj): # new return obj.user.id

class TweetSerializer(serializers.ModelSerializer): user = serializers.SerializerMethodField(read_only=True) likes = serializers.SerializerMethodField(read_only=True) parent = TweetCreateSerializer(read_only=True)

  1. class Meta:
  2.     model = Tweet
  3.     # fields = ['user', 'id', 'content', 'likes', 'is_retweet', 'parent']
  4.     fields = [
  5.         'user',
  6.         'id',
  7.         'content',
  8.         'likes',
  9.         'is_retweet',
  10.         'parent',
  11.         'timestamp'
  12.     ]
  14. def get_likes(self, obj):
  15.     return obj.likes.count()
  17. def get_user(self, obj):
  18.     return obj.user.id
  2. <a name="XJoDg"></a>
  3. #### create user profile serializer and show that in tweets list: 
  5. - create /profiles/serializers.py
  6. ```python
  7. from rest_framework import serializers
  9. from .models import Profile
  12. class PublicProfileSerializer(serializers.ModelSerializer):
  14.     first_name = serializers.SerializerMethodField(read_only=True)
  15.     last_name = serializers.SerializerMethodField(read_only=True)
  16.     username = serializers.SerializerMethodField(read_only=True)
  17.     follower_count = serializers.SerializerMethodField(read_only=True)
  18.     following_count = serializers.SerializerMethodField(read_only=True)
  20.     class Meta:
  21.         model = Profile
  22.         fields = [
  23.             "first_name",
  24.             "last_name",
  25.             "id",
  26.             "bio",
  27.             "location",
  28.             "follower_count",
  29.             "following_count",
  30.             "username",
  31.         ]
  33.     def get_first_name(self, obj):
  34.         return obj.user.first_name
  36.     def get_last_name(self, obj):
  37.         return obj.user.last_name
  39.     def get_username(self, obj):
  40.         return obj.user.username
  42.     def get_following_count(self, obj):
  43.         return obj.user.following.count()
  45.     def get_follower_count(self, obj):
  46.         return obj.followers.count()
  • apply PublicProfileSerializer in /tweets/serializers.py ```python

    …

    from profiles.serializers import PublicProfileSerializer # new

…

class TweetCreateSerializer(serializers.ModelSerializer):

  1. # user = serializers.SerializerMethodField(read_only=True)
  2. user = PublicProfileSerializer(source='user.profile', read_only=True)
  3. likes = serializers.SerializerMethodField(read_only=True)
  5. class Meta:
  6.     model = Tweet
  7.     # fields = ['id', 'content', 'likes']
  8.     fields = [
  9.         'user',
  10.         'id',
  11.         'content',
  12.         'likes',
  13.         'timestamp'
  14.     ]
  16. def get_likes(self, obj):
  17.     return obj.likes.count()
  19. def validate_content(self, value):
  20.     if len(value) > MAX_TWEET_LENGTH:
  21.         raise serializers.ValidationError("This tweet is too long")
  22.     return value
  24. #def get_user(self, obj): 
  25. #    return obj.user.id

class TweetSerializer(serializers.ModelSerializer):

  1. # user = serializers.SerializerMethodField(read_only=True)
  2. likes = serializers.SerializerMethodField(read_only=True)
  3. user = PublicProfileSerializer(source='user.profile', read_only=True)
  4. parent = TweetCreateSerializer(read_only=True)
  6. class Meta:
  7.     model = Tweet
  8.     # fields = ['user', 'id', 'content', 'likes', 'is_retweet', 'parent']
  9.     fields = [
  10.         'user',
  11.         'id',
  12.         'content',
  13.         'likes',
  14.         'is_retweet',
  15.         'parent',
  16.         'timestamp'
  17.     ]
  19. def get_likes(self, obj):
  20.     return obj.likes.count()
  22. # def get_user(self, obj):
  23. #     return obj.user.id

``` runserver and access http://localhost/api/tweets/
image.png
At present, “user” is modified from id to a long serializer, while we can see first_name, last_name, etc.