def list(self, request):
if 'user_id' not in request.query_params:
return Response('missing user_id', status=400)
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(tweets, many=True)
return Response({'Tweets': serializer.data}, status=200)
def list(self, request, *args, **kwargs):
"""
overloading list function, make user_id as a requirement to filter
"""
user_id = request.query_params['user_id']
tweets = Tweet.objects.filter(user_id=user_id).prefetch_related('user')
cached_tweets = TweetService.get_cached_tweets(user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
"""
if 'user_id' not in request.query_params:
return Response('missing user_id', status=400)
The above line will be interpreted as following SQL:'
select * from twitter_tweets where user_id=xxx order by created_at DESC
this SQL query will be using composite index of user_id and created_at
"""
queryset = Tweet.objects.filter(
user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
# usually response in JSON format should be included in hash
# instead of a list
return self.get_paginated_response(serializer.data)
def api_user_tweet_list_view(request, username, *args, **kwargs):
user = User.objects.filter(username=username).first()
if (user):
user_tweets = user.user_tweets.all()
serializer = TweetSerializer(user_tweets, many=True)
return Response(serializer.data, status.HTTP_200_OK)
return Response({"error_message": "not found"}, status.HTTP_404_NOT_FOUND)
def list(self, request, *args, **kwargs):
"""
重载 list 方法，不列出所有 tweets，必须要求指定 user_id 作为筛选条件
"""
user_id = request.query_params['user_id']
cached_tweets = TweetService.get_cached_tweet(user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
# 这句查询会被翻译为
# select * from twitter_tweets
# where user_id = xxx
# order by created_at desc
# 这句 SQL 查询会用到 user 和 created_at 的联合索引
# 单纯的 user 索引是不够的
queryset = Tweet.objects.filter(
user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
# 一般来说 json 格式的 response 默认都要用 hash 的格式
# 而不能用 list 的格式（约定俗成）
return self.get_paginated_response(serializer.data)
def list(self, request):
if 'user_id' not in request.query_params:
return Response('missing user_id', status=400)
user_id = request.query_params['user_id'] #django 会自动把string转换成int
tweets = Tweet.objects.filter(user_id=user_id).order_by('-created_at')
serializer = TweetSerializer(tweets, many=True) #返回list of dict
return Response({'tweets': serializer.data})
def list(self, request):
user_id = request.query_params['user_id']
tweets = Tweet.objects.filter(user_id=user_id).order_by('-created_at')
tweets = self.paginate_queryset(tweets)
serializer = TweetSerializer(
tweets,
context={'request': request},
many=True,
)
return self.get_paginated_response(serializer.data)
class NewsFeedSerializer(serializers.ModelSerializer):
tweet = TweetSerializer()
class Meta:
model = NewsFeed
fields = (
'id',
'created_at',
'user',
'tweet',
)
def list(self, request, *args, **kwargs):
"""
override list
"""
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(tweets, many=True)
return Response({'tweets': serializer.data})
def list(self, request):
# only list when user id specified
if 'user_id' not in request.query_params:
return Response('missing user_id', status=400)
# querying the composite index of user_id and created_at
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(tweets, many=True)
return Response({'tweets': serializer.data})
def create(self, request, *args, **kwargs):
serializer = TweetCreateSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
return Response(TweetSerializer(tweet).data, status=201)
def list(self, request, *args, **kwargs):
# 之前使用如下的方式检验user_id 的
# 因为发现comments中也要检查tweet_id 所以我们使用decorator的方式将两个功能相似的步骤简化为一个
# if 'user_id' not in request.query_params:
# return Response('missing user_id', status=400)
# 此处的搜索需要建立联合索引 来加快搜索速度
# 需要在tweets -- models -- Tweet中建立联合索引
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(tweets,
many=True) # many=True说明会返回一个list of dict
return Response({'tweets': serializer.data})
def create(self, request):
serializer = TweetCreateSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(
{
'success': False,
'message': 'Please check input',
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def create(self, request):
serializer = TweetCreateSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(
{
"success": False,
"massage": "Please check input.",
"errors": serializer.errors,
},
status=400)
# save will call create method in TweetSerializerForCreate
tweet = serializer.save()
return Response(TweetSerializer(tweet).data, status=201)
def list(self, request, *args, **kwargs):
# composite index: take user and created_at
tweets = Tweet.objects.filter(
user_id = request.query_params['user_id']
).order_by('-created_at') #reverse order
# get instance of the list of tweets
tweets = self.paginate_queryset(tweets)
serializer = TweetSerializer(
tweets,
context={'request': request},
many=True,
)
# By default return dict
return self.get_paginated_response(serializer.data)
def list(self, request, *args, **kwargs):
user_id = request.query_params['user_id']
cached_tweets = TweetService.get_cached_tweets(user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
queryset = Tweet.objects.filter(
user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
return self.get_paginated_response(serializer.data)
def list(self, request, *args, **kwargs):
user_id = request.query_params['user_id']
tweets = Tweet.objects.filter(user_id=user_id).prefetch_related('user')
cached_tweets = TweetService.get_cached_tweets(user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
# select * from twitter_tweets where user_id = xxx
# order by created_at desc
queryset = Tweet.objects.filter(user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
return self.get_paginated_response(serializer.data)
def create(self, request):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
},
status=400)
#save will trigger create method in TweetSerializerForCreate
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def list(self, request, *args, **kwargs):
# 这句查询会被翻译为
# select * from twitter_tweets
# where user_id = xxx
# order by created_at desc
# 这句 SQL 查询会用到 user 和 created_at 的联合索引
# 单纯的 user 索引是不够的
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(
tweets,
context={'request': request},
many=True,
)
# 一般来说 json 格式的 response 默认都要用 hash 的格式
# 而不能用 list 的格式（约定俗成）
return Response({'tweets': serializer.data})
def list(self, request, *args, **kwargs):
"""
overload list method, we don't want to list all the tweets that all the users posts
we use user_id as a filtering condition
"""
user_id = request.query_params['user_id']
cached_tweets = TweetService.get_cached_tweets(user_id=user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
queryset = Tweet.objects.filter(
user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
return self.get_paginated_response(serializer.data)
def create(self, request, *args, **kwargs):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "please check input",
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
class ReTweetSerializer(serializers.ModelSerializer):
tweet_detail = TweetSerializer(source='tweet', read_only=True)
class Meta:
model = ReTweet
fields = [
'id',
'text',
'tweet',
'tweet_detail',
]
def create(self, validated_data):
user = self.context['request'].user
validated_data['created_by'] = user
re_tweet = super().create(validated_data)
action.send(user, verb='created re-tweet', action_object=re_tweet)
return re_tweet
def create(self, request):
"""
重载 create 方法，因为需要默认用当前登录用户作为 tweet.user
"""
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
'success': False,
'message': "Please check input",
'errors': serializer.errors,
}, status=400)
# save() will call create method in TweetCreateSerializer
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
def list(self, request, *args, **kwargs):
"""
重载 list 方法，不列出所有 tweets，必须要求指定 user_id 作为筛选条件
"""
if 'user_id' not in request.query_params:
return Response('missing user_id', status=400)
# 这句查询会被翻译为
# select * from twitter_tweets
# where user_id = xxx
# order by created_at desc
# 这句 SQL 查询会用到 user 和 created_at 的联合索引
# 单纯的 user 索引是不够的
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']).order_by('-created_at')
serializer = TweetSerializer(tweets, many=True)
# 一般来说 json 格式的 response 默认都要用 hash 的格式
# 而不能用 list 的格式（约定俗成）
return Response({'tweets': serializer.data})
def create(self, request):
serialzier = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serialzier.is_valid():
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serialzier.errors,
},
status=HTTP_400_BAD_REQUEST)
tweet = serialzier.save()
#fan out to followers
NewsFeedService.fan_out_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=HTTP_201_CREATED)
def list(self, request):
# select out all tweets of a specific user
cached_tweets = TweetService.load_tweets_through_cache(
user_id=request.query_params['user_id']
)
page = self.paginator.paginate_cached_list(cached_tweets, request)
# cache not enough
if not page:
tweets = Tweet.objects.filter(
user_id=request.query_params['user_id']
)
page = self.paginate_queryset(tweets)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
# wrap the list of tweet contents in endless pagination
return self.get_paginated_response(serializer.data)
def list(self, request, *args, **kwargs):
user_id = request.query_params['user_id']
cached_tweets = TweetService.get_cached_tweets(user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
# 这句查询会被翻译为
# select * from twitter_tweets
# where user_id = xxx
# order by created_at desc
# 这句 SQL 查询会用到 user 和 created_at 的联合索引
# 单纯的 user 索引是不够的
queryset = Tweet.objects.filter(
user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
# many = true means it will return a list of dict
serializer = TweetSerializer(page,
context={'request': request},
many=True)
return self.get_paginated_response(serializer.data)
def create(self, request, *args, **kwargs):
"""
重载 create 方法，因为需要默认用当前登录用户作为 tweet.user
"""
serializer = TweetCreateSerializer(
data=request.data,
context={'request': request},
)
# use default validator, like min max length
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def list(self, request):
"""
重载 list 方法，不列出所有 tweets，必须要求指定 user_id 作为筛选条件
"""
user_id = request.query_params['user_id']
# get tweets from redis cache instead of DB
cached_tweets = TweetService.get_cached_tweets(user_id=user_id)
page = self.paginator.paginate_cached_list(cached_tweets, request)
if page is None:
queryset = Tweet.objects.filter(user_id=user_id).order_by('-created_at')
page = self.paginate_queryset(queryset)
serializer = TweetSerializer(
page,
context={'request': request},
many=True,
)
# 一般来说 json 格式的 response 默认都要用 hash 的格式
# 而不能用 list 的格式（约定俗成）
# return Response({'tweets': serializer.data})
return self.get_paginated_response(serializer.data)
def create(self, request):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
"success": False,
"message": "Please check input",
"errors": serializer.errors,
}, status=400)
# otherwise we have a tweet instance here
# save() will call create method in TweetSerializerForCreate
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
# Here I use TweetSerializer to show whats in the tweet
# reminder: It is different from TweetSerializerForCreate
return Response(
TweetSerializer(tweet, context={'request': request}).data,
status=201,
)
def user_detail_view(request, username):
user = get_object_or_404(User, username=username)
tweets = Tweet.objects.filter(user=user.id).order_by('-date_created')
user_serializer = UserSerializer(user, context={'request': request})
profile_serializer = ProfileSerializer(user.profile)
tweets_serializer = TweetSerializer(tweets, many=True)
if request.user.username == username:
user_serializer = CurrentUserSerializer(user)
response_data = {
'user_data': user_serializer.data,
'profile_data': profile_serializer.data,
'tweets_data': tweets_serializer.data
}
for data, tweet in zip(tweets_serializer.data, tweets):
data['isLiked'] = request.user in tweet.likes.all()
return Response(response_data, status=status.HTTP_200_OK)