def follow(self, request, pk):
# egde case check: duplicate follow action (e.g. multiple clicks from frontend)
# silent processing. No need to report error.
# because this kind of duplicated operation are mostly because of internet delay,
if FriendshipService.has_followed(request.user.id, int(pk)):
return Response(
{
'success': True,
'duplicate': True,
'error': [{
'pk': f'you have followed the user with id={pk}'
}],
},
status=status.HTTP_400_BAD_REQUEST)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
return Response(
FollowingSerializer(instance, context={
'request': request
}).data,
status=status.HTTP_201_CREATED,
)
def follow(self, request, pk):
# check if user with id=pk exists
to_follow_user = self.get_object()
if FriendshipService.has_followed(request.user.id, to_follow_user.id):
return Response({
'success': False,
'message': 'Please check input',
'errors': [{'pk': f'You has followed user with id={pk}'}],
}, status=status.HTTP_400_BAD_REQUEST)
# /api/friendships/<pk>/follow/
serializer = FriendshipSerializerForCreate(data={
'from_user_id': request.user.id,
'to_user_id': to_follow_user.id,
})
if not serializer.is_valid():
return Response({
'success': False,
'message': 'Please check input',
'errors': serializer.errors,
}, status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
return Response(
FollowingSerializer(instance, context={'request': request}).data,
status=status.HTTP_201_CREATED
)
def follow(self, request, pk):
if FriendshipService.has_followed(request.user.id, int(pk)):
return Response({
'success': True,
'duplicate': True,
},
status=status.HTTP_201_CREATED)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
return Response(
FollowingSerializer(instance, context={
'request': request
}).data,
status=status.HTTP_201_CREATED,
)
def follow(self, request, pk):
# check if the user to follow exists
to_user = self.get_object()
# Friendship already existed. Raise error
# avoid duplicated friendships in HBase
if FriendshipService.has_followed(from_user_id=request.user.id,
to_user_id=to_user.id):
return Response({
'success': True,
'duplicated': True,
},
status=status.HTTP_201_CREATED)
# Friendship not exists, creat new friendship
serializer = FriendshipCreateSerializer(
data={
'from_user_id':
request.user.id, # only logged in user can follow
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
friendship = serializer.save()
return Response(
{
'success': True,
'friendship': FriendshipCreateSerializer(friendship).data,
},
status=status.HTTP_201_CREATED)
def follow(self, request, pk):
# check i fuser with id=pk exists
# self.get_object()
# 特殊判断重复 follow 的情况 （比如前端猛点多次follow）
# 静默处理， 不报错， 因为这类重复操作 因为网络延迟的原因会比较多， 没必要当做错误处理
if FriendshipService.has_followed(request.user.id, int(pk)):
return Response({
'success': True,
'duplicate': True,
},
status=status.HTTP_201_CREATED)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response({'success': True}, status=status.HTTP_201_CREATED)
def follow(self, request, pk):
# 特殊判断重复 follow 的情况（比如前端猛点好多少次 follow)
# 静默处理，不报错，因为这类重复操作因为网络延迟的原因会比较多，没必要当做错误处理
to_follow_user = self.get_object()
if FriendshipService.has_followed(request.user.id, to_follow_user.id):
return Response(
{
'success': False,
'message': 'Please check input',
'errors': [{
'pk': f'You has followed user with id={pk}'
}],
},
status=status.HTTP_400_BAD_REQUEST)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
return Response(
FollowingSerializer(instance, context={
'request': request
}).data,
status=status.HTTP_201_CREATED,
)
def follow(self, request, pk):
# /api/friendships/<pk>/follow/
# 特殊判断重复 follow 的情况（比如前端猛点好多少次 follow)
# 静默处理，不报错，因为这类重复操作因为网络延迟的原因会比较多，没必要当做错误处理
# get_object 会检测if user with id=pk 是否存在，如果不存在会return 404 异常
follow_user = self.get_object()
if FriendshipService.has_followed(request.user.id, int(pk)):
return Response({
'success': True,
'duplicate': True,
},
status=status.HTTP_201_CREATED)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
return Response(
# instead returning success=> true, returning the pk (the request tries to follow the pk) data
# the return data includes user_id, created_at
FollowingSerializer(instance, context={
'request': request
}).data,
status=status.HTTP_201_CREATED,
)
def follow(self, request, pk):
# dup follow e.g. front end click follow many times
# keep silent network delay, it is not a real error
if FriendshipService.has_followed(request.user.id, int(pk)):
return Response({
'success': True,
'duplicate': True,
}, status=status.HTTP_201_CREATED)
serializer = FriendshipSerializerForCreate(data={
'from_user_id': request.user.id,
'to_user_id': pk,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
}, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
#FriendshipService.invalidate_following_cache(request.user.id)
return Response({'success': True}, status=status.HTTP_201_CREATED)
def follow(self, request, pk):
# check if user with id=pk exists
to_follow_user = self.get_object()
if FriendshipService.has_followed(request.user.id, to_follow_user.id):
return Response({
'success': False,
'message': "Please check input",
'errors': [{'pk': f'You has followed user with id={pk}'}],
}, status=status.HTTP_400_BAD_REQUEST)
serializer = FriendshipSerializerForCreate(data={
'from_user_id': request.user.id,
'to_user_id': to_follow_user.id,
})
if not serializer.is_valid():
return Response({
"success": False,
"errors": serializer.errors,
}, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response({'success': True}, status=status.HTTP_201_CREATED)
def follow(self, request, pk):
# /api/friendships/<pk>/follow/
# raise 404 if no user with id=pk
to_follow_user = self.get_object()
# 特殊判断重复 follow 的情况（比如前端猛点好多少次 follow)
# 静默处理，不报错，因为这类重复操作因为网络延迟的原因会比较多，没必要当做错误处理
# 或者报400
if FriendshipService.has_followed(request.user.id, to_follow_user.id):
return Response(
{
'success': False,
'errors': [{
'pk': f'You have followed user with id={pk}'
}],
},
status=status.HTTP_400_BAD_REQUEST)
serializer = FriendshipSerializerForCreate(
data={
'from_user_id': request.user.id,
'to_user_id': to_follow_user.id,
})
if not serializer.is_valid():
return Response({
'success': False,
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
instance = serializer.save()
# 手动invalidate cache 或者利用listener自动调用 invalidate_following_cache
# FriendshipService.invalidate_following_cache(request.user.id)
return Response(FollowingSerializer(instance,
context={
'request': request
}).data,
status=status.HTTP_201_CREATED)
def get_has_followed(self, obj):
if self.context['request'].user.is_anonymous:
return False
return FriendshipService.has_followed(self.context['request'].user,
obj.to_user)
