def comment(self, request, pk):
user = request.user
obj = get_obj(self.model_class,pk)
serializer = CommentSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse(u'数据格式错误', code=JsonResponse.CODE_ERROR_DATA, data=serializer.errors)
comment = Comment.objects.create(author=user, content_object=obj, **serializer.validated_data)
serializer = CommentSerializer(comment)
return JsonResponse(u'ok', data=serializer.data,status=1)
class VideoSerializer(serializers.HyperlinkedModelSerializer):
url = VideoUrlHyperlinkedIdentityField("video_detail_api")
#category = CategorySerializer(many=False, read_only=True)
comment_set = CommentSerializer(many=True, read_only=True)
category_url = serializers.CharField(source='category.get_absolute_url',
read_only=True)
#category_image = serializers.CharField(source='category.get_image_url', read_only=True)
#category = serializers.PrimaryKeyRelatedField(queryset=Category.objects.all())
class Meta:
model = Video
fields = [
"url",
'id',
'slug',
'title',
'order',
'embed_code',
'free_preview',
'share_message',
'timestamp',
#"category",
#"category_image",
"category_url",
"comment_set",
]
class PostCommentSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True, read_only=True)
class Meta:
model = Post
exclude = ['creator']
read_only_fields = ['create_at']
class PermissionDetailSerializer(PermissionListSerializer):
"""
Serializer for the detail view of Permission viewset
"""
comments = CommentSerializer(
many=True,
read_only=True,
)
class Meta:
"""
Meta class for PermissionDetailSerializer
"""
model = Permission
exclude = [
'datetime_created',
]
read_only = [
'id',
'subscriber',
'authority',
'status_display_name',
'last_modified_by',
'latest_comment_by',
]
def comment(self, request, *args, **kwargs):
"""Create comment for entity"""
pk = self.get_object().pk
serializer = CommentSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(entity_type=self.entity_type.value, entity_id=pk)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def get_comments(self, obj):
content_type = obj.get_content_type
object_id = obj.id
c_qs = Comment.objects.filter_by_instance(
obj) # c_qs --> comments queryset
comments = CommentSerializer(c_qs, many=True).data
return comments
class ArticleDetailSerializer(serializers.ModelSerializer):
article_comments = CommentSerializer(many=True,
read_only=True,
source='comments')
#nickname = serializers.CharField(source='author.nickname', read_only=True)
#article = serializers.SerializerMethodField()
#TODO:nickname = UserNicknameSerializer(many=True, read_only=True)
class Meta:
model = Articles
fields = (
'id',
#TODO:'parent',
#'article',
#todo:'nickname',
'title',
'short_description',
'content',
'slug',
'date_posted',
'date_updated',
'image',
'article_choices',
'author',
'article_comments',
)
def put(self, request, id, format=None):
if id.startswith('commentID='):
id = id[10:]
else:
return Response({'Invalid id of comment.'},
status=status.HTTP_404_NOT_FOUND)
serializer = CommentSerializer(data=request.data)
if serializer.is_valid() is False:
return Response(
{
'message':
'Cannnot update comment with provided information.'
},
status=status.HTTP_400_BAD_REQUEST)
comment = Comment.objects.filter(id=id).first()
if comment is None:
return Response({'No comment has that id.'},
status=status.HTTP_404_NOT_FOUND)
self.check_object_permissions(request, comment)
data = serializer.validated_data
comment.content = data.get('content')
comment.save()
return Response(data, status=status.HTTP_200_OK)
class PostDetailSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True)
class Meta:
model = Post
fields = ('id', 'title', 'content', 'owner', 'created_at', 'comments')
read_only_fields = ('id', 'title' 'owner', 'create_at', 'content')
def get_comments(self, post):
data = Comment.objects.filter(parent=post)
paginator = CommentsPageNumberPagination()
page = paginator.paginate_queryset(data, self.context['request'])
serializer = CommentSerializer(page, many=True).data
return paginator.get_paginated_response(serializer).data
def comments(self, request: Request, pk=Optional[str]) -> Response:
post = self.get_object()
queryset = (
post.comment_set.select_related("author").order_by("-created")
)
serializer = CommentSerializer(queryset, many=True)
return Response(serializer.data)
def comments_list(request):
"""
List comments.
"""
if request.method == 'GET':
data = []
nextPage = 1
previousPage = 1
customers = Comment.objects.all()
page = request.GET.get('page', 1)
paginator = Paginator(customers, 10)
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages)
serializer = CommentSerializer(data, context={'request': request}, many=True)
if data.has_next():
nextPage = data.next_page_number()
if data.has_previous():
previousPage = data.previous_page_number()
url = reverse('list_comments_api_v1')
return Response({
'data': serializer.data,
'count': paginator.count,
'numpages': paginator.num_pages,
'nextlink': url + '?page=' + str(nextPage),
'prevlink': url + '?page=' + str(previousPage)
})
class ReviewForRestaurantSerializer(serializers.ModelSerializer):
author = UserSerializer(
required=False,
read_only=True,
)
comments = CommentSerializer(
required=False,
read_only=True,
many=True,
)
amount_of_likes = serializers.SerializerMethodField()
def get_amount_of_likes(self, obj):
return len(obj.users_who_liked.all())
amount_of_comments = serializers.SerializerMethodField()
def get_amount_of_comments(self, obj):
return len(obj.comments.all())
logged_in_user_is_review_author = serializers.SerializerMethodField()
def get_logged_in_user_is_review_author(self, obj):
return self.context['request'].user == obj.author
class Meta:
model = Review
fields = [
'id', 'text_content', 'rating', 'created', 'author', 'comments',
'restaurant_review_about', 'users_who_liked', 'amount_of_likes',
'amount_of_comments', 'logged_in_user_is_review_author'
]
class UserSerializer(serializers.ModelSerializer):
password = serializers.CharField(write_only=True)
password_confirmation = serializers.CharField(write_only=True)
images = PopulatedImageSerializer(many=True, required=False)
videos = PopulatedVideoSerializer(many=True, required=False)
articles = PopulatedArticleSerializer(many=True, required=False)
trainings = PopulatedTrainingSerializer(many=True, required=False)
student_trainings = PopulatedTrainingSerializer(many=True, required=False)
comments = CommentSerializer(many=True, required=False)
chats = PopulatedChatSerializer(many=True, required=False)
def validate(self, data):
password = data.pop('password')
password_confirmation = data.pop('password_confirmation')
if password != password_confirmation:
raise ValidationError({'password_confirmation': 'does not match'})
# try:
# validations.validate_password(password=password)
# except ValidationError as err:
# raise serializers.ValidationError({'password': err.messages})
data['password'] = make_password(password)
return data
class Meta:
model = User
fields = '__all__'
class PostSerializer(serializers.ModelSerializer):
user = AccountsSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(
queryset=Accounts.objects.all(), write_only=True)
tasks = TaskSerializer(many=True)
comments = CommentSerializer(many=True, read_only=True)
favorites = FavoriteSerializer(many=True, read_only=True)
class Meta:
model = Post
fields = [
'id', 'title', 'detail', 'limit', 'user', 'user_id', 'tasks',
'comments', 'favorites'
]
def create(self, validated_data):
tasks_data = validated_data.pop('tasks')
validated_data['user'] = validated_data.get('user_id', None)
if validated_data['user'] is None:
raise serializers.ValidationError("user not found.")
del validated_data['user_id']
post = Post.objects.create(**validated_data)
for task_data in tasks_data:
Task.objects.create(post=post, **task_data)
return post
class ArticleRetrieveSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True, read_only=True)
created_time = serializers.DateTimeField(format='%Y-%m-%d %H:%M')
class Meta:
model = Article
fields = '__all__'
def get(self, request, userName):
# Blog.objects.filter(entry__headline__contains='Lennon', entry__pub_date__year=2008)
selectedUser = User.objects.get(username=userName)
selectedComment = Comment.objects.filter(owner=selectedUser)
serializer = CommentSerializer(selectedComment, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def add_comment(
self, request: Request, pk=Optional[str]
) -> Response:
serializer = CommentSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(post=self.get_object(), author=self.request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def test_get_comment_detail(self, api_client, setup_test):
# get API response
response = api_client.get(self.get_comment_url)
# get data from db
comments = Comment.objects.all()
serializer = CommentSerializer(comments, many=True)
assert response.data == serializer.data[0]
assert response.status_code == status.HTTP_200_OK
def test_list_all_comments(self, api_client, setup_test):
# get API response
response = api_client.get(self.list_comments_url)
# get data from db
comments = Comment.objects.all()
serializer = CommentSerializer(comments, many=True)
assert response.data['data'] == serializer.data
assert response.status_code == status.HTTP_200_OK
def get_comments(self, request, pk=None):
retweet = self.get_object()
comments = Comment.objects.filter(retweet=retweet.id).order_by('date')
if (comments.count() > 0):
return (Response(CommentSerializer(comments, many=True).data))
else:
return Response([])
class MealSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True)
class Meta:
model = Meal
fields = [
'id', 'description', 'price', 'portion', 'image', 'category',
'comments'
]
def __call__(self, qs):
from comments.serializers import CommentSerializer
for comment in qs.iterator():
serializer = CommentSerializer(comment)
rec = etree.Element(
'comment',
**{key: str(val)
for key, val in serializer.data.items()})
yield etree.tostring(rec)
class QuestionSerializer(serializers.ModelSerializer):
url = serializers.HyperlinkedIdentityField(view_name='question-detail')
user = UserSerializer(read_only=True)
tags = serializers.SlugRelatedField(many=True,
read_only=True,
slug_field='name',
allow_null=True)
comment = CommentSerializer(many=True, read_only=True)
class Meta:
model = Question
fields = [
'id',
'url',
'user',
'title',
'body',
'tags',
'comment',
'registered_date',
]
def __init__(self, *args, **kwargs):
super(QuestionSerializer, self).__init__(*args, **kwargs)
def create(self, validated_data):
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
question = Question.objects.create(user=user,
title=validated_data['title'],
body=validated_data['body'])
for item in request.data['tags']:
tag, created = Tag.objects.get_or_create(name=item, is_public=True)
question.tags.add(tag)
return question
def update(self, question, validated_data):
question.title = validated_data.get('title', question.body)
question.body = validated_data.get('body', question.body)
tags_to_update = self.initial_data.get('tags')
temp = []
for tag in tags_to_update:
tag, created = Tag.objects.get_or_create(name=tag, is_public=True)
temp.append(tag)
question.tags.set(temp)
return super(QuestionSerializer, self).update(question, validated_data)
class PostByAccountSerializer(serializers.ModelSerializer):
tasks = TaskSerializer(many=True)
comments = CommentSerializer(many=True, read_only=True)
favorites = FavoriteSerializer(many=True, read_only=True)
class Meta:
model = Post
fields = [
'id', 'title', 'detail', 'limit', 'tasks', 'comments', 'favorites'
]
def comments(self, request, pk):
"""
Endpoint for querying Comments on a photo.
"""
photo = Photo.objects.get(id=pk)
comments = Comment.objects.filter(photo=photo)
serializer = CommentSerializer(comments,
many=True,
context={'request': request})
return Response(serializer.data)
class CardSerializer(serializers.ModelSerializer):
comments = CommentSerializer(many=True, required=False)
members = serializers.PrimaryKeyRelatedField(many=True,
required=False,
read_only=True)
owner = serializers.PrimaryKeyRelatedField(read_only=True)
class Meta:
model = Card
fields = '__all__'
class PostListSerializer(serializers.ModelSerializer):
owner = UserSerializer(many=False)
comments = CommentSerializer(many=True)
url = HyperlinkedIdentityField(view_name='posts:detail', )
class Meta:
model = Post
fields = ('id', 'title', 'content', 'owner', 'created_at', 'comments',
'url')
read_only_fields = ('id', 'owner', 'created_at', 'comments')
def test_list_comments(self):
"""
测试某篇文章的评论列表接口
"""
url = reverse('v1:post-comment', kwargs={'pk': self.post3.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
serializer = CommentSerializer(instance=[self.comment2, self.comment1],
many=True)
self.assertEqual(response.data['results'], serializer.data)
class PostSerializer(serializers.ModelSerializer):
author_detail = UserSerializer(source='author', read_only=True)
comments = CommentSerializer(many=True, required=False)
class Meta:
model = Post
fields = [
'id', 'title', 'content', 'author', 'created_at', 'comments',
'author_detail'
]
