class PostDetailSerializer(ModelSerializer):
url = post_detail_url
user = UserDetailSerializer(read_only=True)
image = SerializerMethodField()
html = SerializerMethodField()
comments = SerializerMethodField()
class Meta:
model = Post
fields = [
'url',
'id',
'user',
'title',
'slug',
'content',
'html',
'publish',
'image',
'comments',
]
def get_html(self, obj):
return obj.get_markdown()
def get_image(self, obj):
try:
image = obj.image.url
except:
image = None
return image
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
user = serializer.validated_data['user']
serializer = UserDetailSerializer(user, context={'request': request})
return Response(serializer.data, HTTP_200_OK)
class CommentChildSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Comment
fields = [
'id',
'user',
'content',
'timestamp',
]
class PostListSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Post
fields = [
'user',
'title',
'content',
'publish',
'image',
]
class ActivitysCreateSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Activitys
fields = [
'user',
'activity_type',
'content_type',
'object_id',
]
def validate(self, data):
content_type = data.get("content_type")
content_qs = ContentType.objects.filter(model=content_type)
if not content_qs.exists() or content_qs.count() != 1:
raise ValidationError("This is not valid content type")
object_id = data.get("object_id")
obj_model = content_qs.first().model_class()
obj_qs = obj_model.objects.filter(id=object_id)
if not obj_qs.exists() or obj_qs.count() != 1:
raise ValidationError("Not valid Object Id")
activity_type = data.get("activity_type")
if not activity_type in ['L', "F", "U", "D"]:
raise ValidationError("Not valid activity")
return data
def create(self, data):
content_type = data.get("content_type")
object_id = data.get("object_id")
activity_type = data.get("activity_type")
user = self.context['user']
activity_qs = Activitys.objects.filter(content_type=content_type,
user=user,
object_id=object_id)
if activity_qs.exists():
raise ValidationError("Not valid opretion ")
activity = Activitys.objects.create(content_type=content_type,
object_id=object_id,
user=user,
activity_type=activity_type)
return activity
class PostCommentsCreateSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
type = CharField(required=False, write_only=True)
slug = SlugField(write_only=True)
parent_id = IntegerField(required=False)
class Meta:
model = Comments
fields = [
'id', 'user', 'type', 'slug', 'parent_id', 'content', 'timestamp'
]
def validate(self, data):
model_type = data.get("type", "posts")
model_qs = ContentType.objects.filter(model=model_type)
if not model_qs.exists() or model_qs.count() != 1:
raise ValidationError("This is not valid content type")
someModel = model_qs.first().model_class()
slug = data.get("slug")
obj_qs = someModel.objects.filter(slug=slug)
if not obj_qs.exists() or obj_qs.count() != 1:
raise ValidationError("This is not slug for comments")
parent_id = data.get("parent_id")
if parent_id:
parent_qs = Comments.objects.filter(id=parent_id)
if not parent_qs.exists() or parent_qs.count() != 1:
raise ValidationError("This is not valid parent")
return data
def create(self, validated_data):
content = validated_data.get("content")
model_type = validated_data.get("type", "posts")
slug = validated_data.get("slug")
parent_id = validated_data.get("parent_id")
parent_obj = None
if parent_id:
parent_obj = Comments.objects.filter(id=parent_id).first()
user = self.context['user']
comment = Comments.objects.create_by_model_type(model_type,
slug,
content,
user,
parent_obj=parent_obj)
return comment
class CommentDetailSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
reply_count = SerializerMethodField()
content_object_url = SerializerMethodField()
replies = SerializerMethodField()
class Meta:
model = Comment
fields = [
'id',
'user',
#'content_type',
#'object_id',
'content',
'reply_count',
'replies',
'timestamp',
'content_object_url',
]
read_only_fields = [
#'content_type',
#'object_id',
'reply_count',
'replies',
]
def get_content_object_url(self, obj):
try:
return obj.content_object.get_api_url()
except:
return None
def get_replies(self, obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
return None
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
class PostCommentsSerializer(ModelSerializer):
user = UserDetailSerializer()
replies = SerializerMethodField()
reply_count = SerializerMethodField()
class Meta:
model = Comments
fields = [
'user',
'id',
'parent',
'content',
'timestamp',
'replies',
'reply_count',
]
def get_replies(self, obj):
return PostCommentsSerializer(obj.childer(), many=True).data
def get_reply_count(self, obj):
return obj.childer().count()