class ScreenshotSerializer(serializers.ModelSerializer):
poster = BasicUserSerializer(read_only=True)
chapter = ChapterSerializer()
involved = BasicUserSerializer(many=True)
class Meta:
model = Screenshot
fields = (
'id',
'title',
'slug',
'views',
'created',
'image',
'poster',
'chapter',
'involved',
)
read_only_fields = (
'id',
'slug',
'views',
'created',
'poster',
)
class ReplySerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
liked_users = BasicUserSerializer(read_only=True, many=True)
is_liked = serializers.SerializerMethodField()
is_saved = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
class Meta:
model = Reply
fields = "__all__"
exclude_fields = ["saved_users", "liked_users"]
def get_is_liked(self, instance):
return instance.liked_users.filter(id=self.context["request"].user.id).exists()
def get_is_saved(self, instance):
return instance.saved_users.filter(id=self.context["request"].user.id).exists()
def get_likes(self, instance):
return instance.liked_users.count()
def create(self, validated_data):
# Set the user as the creator of the reply
validated_data["creator"] = self.context["request"].user
created_data: Reply = ModelSerializerExtension.create(self, validated_data)
create_tagged_user_notification(created_data)
return created_data
class GenericPostSerializer(GenericSerializer):
creator = BasicUserSerializer(read_only=True)
liked_users = BasicUserSerializer(read_only=True, many=True)
is_liked = serializers.SerializerMethodField()
is_saved = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
comments = serializers.SerializerMethodField()
def get_is_liked(self, instance):
return instance.liked_users.filter(
id=self.context['request'].user.id).exists()
def get_is_saved(self, instance):
return instance.saved_users.filter(
id=self.context['request'].user.id).exists()
def get_likes(self, instance):
return instance.liked_users.count()
def get_comments(self, instance):
return instance.comment_set.count()
def create(self, validated_data):
validated_data['creator'] = self.context['request'].user
return GenericSerializer.create(self, validated_data)
class CommentSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
liked_users = BasicUserSerializer(read_only=True, many=True)
is_liked = serializers.SerializerMethodField()
is_saved = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
replies = serializers.SerializerMethodField()
# Todo: Maybe in the future
# most_liked_reply = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = "__all__"
exclude_fields = ["saved_users", "liked_users"]
def get_is_liked(self, instance):
return instance.liked_users.filter(id=self.context["request"].user.id).exists()
def get_is_saved(self, instance):
return instance.saved_users.filter(id=self.context["request"].user.id).exists()
def get_likes(self, instance):
return instance.liked_users.count()
def get_replies(self, instance):
return instance.replies.count()
def get_most_liked_reply(self, instance):
# Retrieve the first most liked reply
most_liked_reply: Reply = (
instance.replies.annotate(likes=Count("liked_users"))
.order_by("-likes", "-datetime_created")
.first()
)
if most_liked_reply is None:
return None
most_liked_reply_serializer = ReplyDetailSerializer(
most_liked_reply, context=self.context
)
return most_liked_reply_serializer.data
def create(self, validated_data):
# Set the user as the creator of the comment
validated_data["creator"] = self.context["request"].user
created_data: Comment = ModelSerializerExtension.create(self, validated_data)
create_tagged_user_notification(created_data)
return created_data
class AbstractModelSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
liked_users = BasicUserSerializer(read_only=True, many=True)
is_liked = serializers.SerializerMethodField()
is_saved = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
comments = serializers.SerializerMethodField()
# Todo: Maybe in the future
# most_liked_comment = serializers.SerializerMethodField()
def get_is_liked(self, instance):
return instance.liked_users.filter(id=self.context["request"].user.id).exists()
def get_is_saved(self, instance):
return instance.saved_users.filter(id=self.context["request"].user.id).exists()
def get_likes(self, instance):
return instance.liked_users.count()
def get_comments(self, instance):
return instance.comments.count()
def get_most_liked_comment(self, instance):
# Retrieve the first most liked comment
most_liked_comment: Comment = (
instance.comments.annotate(likes=Count("liked_users"))
.order_by("-likes", "-datetime_created")
.first()
)
if most_liked_comment is None:
return None
most_liked_comment_serializer = CommentDetailSerializer(
most_liked_comment, context=self.context
)
return most_liked_comment_serializer.data
def create(self, validated_data):
# Set the user as the creator of the shared item
validated_data["creator"] = self.context["request"].user
created_data: AbstractPostModel = ModelSerializerExtension.create(
self, validated_data
)
create_tagged_user_notification(created_data)
return created_data
class NotificationSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
class Meta:
model = Notification
fields = "__all__"
exclude_fields = ["receivers", "viewers"]
class ChapterMemberSerializer(serializers.ModelSerializer):
member = BasicUserSerializer()
member_id = serializers.PrimaryKeyRelatedField(source='member',
queryset=User.objects.all())
division = BasicChapterDivisionSerializer()
division_id = serializers.PrimaryKeyRelatedField(
source='division', queryset=ChapterDivision.objects.all())
class Meta:
model = ChapterMember
fields = (
'id',
'member',
'member_id',
'join_date',
'leave_date',
'role',
'division',
'division_id',
)
read_only_fields = (
'id',
'member',
'join_date',
'leave_date',
'division',
)
class IssueSerializer(serializers.ModelSerializer):
chapter = ChapterSerializer(read_only=True)
chapter_id = serializers.PrimaryKeyRelatedField(source='chapter', queryset=Chapter.objects.all())
involved = BasicUserSerializer(many=True, read_only=True)
involved_ids = serializers.PrimaryKeyRelatedField(source='involved', queryset=User.objects.all(), many=True)
class Meta:
model = Issue
fields = (
'id',
'description',
'created',
'created_by',
'chapter',
'chapter_id',
'involved',
'involved_ids',
)
read_only_fields = (
'id',
'created',
'created_by',
'chapter',
'involved',
)
class MessageSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
previous_message = BasicMessageSerializer(read_only=True)
class Meta:
model = Message
fields = "__all__"
class EventItemSerializer(serializers.ModelSerializer):
item = ItemSerializer(read_only=True)
item_id = serializers.PrimaryKeyRelatedField(source='item',
queryset=Item.objects.all())
user = BasicUserSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(source='user',
queryset=User.objects.all())
class Meta:
model = EventItem
fields = (
'id',
'dkp',
'created',
'event',
'item',
'item_id',
'user',
'user_id',
)
read_only_fields = (
'id',
'created',
'event',
'item',
'user',
)
class ArticleSerializer(serializers.ModelSerializer):
author = BasicUserSerializer(read_only=True)
class Meta:
model = Article
fields = ('id', 'title', 'slug', 'created', 'last_updated', 'body',
'author')
read_only_fields = ('id', 'slug', 'created', 'last_updated', 'author')
class EventDetailSerializer(serializers.ModelSerializer):
location = LocationSerializer(read_only=True)
created_by = BasicUserSerializer(read_only=True)
event_leader = BasicUserSerializer(read_only=True)
event_leader_id = serializers.PrimaryKeyRelatedField(
source='event_leader', queryset=User.objects.all())
location_id = serializers.PrimaryKeyRelatedField(
source='location', queryset=Location.objects.all())
entities = EventEntitySerializer(read_only=True, many=True)
items = EventItemSerializer(read_only=True, many=True)
attendees = EventAttendanceSerializer(read_only=True, many=True)
class Meta:
model = Event
fields = (
'id',
'title',
'slug',
'created',
'created_by',
'dkp',
'event_leader',
'event_leader_id',
'section',
'location',
'location_id',
'started',
'stopped',
'scheduled',
'entities',
'items',
'attendees',
)
read_only_fields = (
'id',
'slug',
'created',
'created_by',
'event_leader'
'dkp',
'section',
'location',
)
class BasicMessageSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
class Meta:
model = Message
fields = [
"id",
"content",
"creator",
]
class DeviceSerializer(ModelSerializerExtension):
creator = BasicUserSerializer(read_only=True)
class Meta:
model = Device
fields = "__all__"
def create(self, validated_data):
# Set the user as the creator of the device
validated_data["creator"] = self.context["request"].user
return ModelSerializerExtension.create(self, validated_data)
class AwardRecipientSerializer(serializers.ModelSerializer):
recipient = BasicUserSerializer()
award = AwardSerializer()
class Meta:
model = AwardRecipient
fields = (
'id',
'recipient',
'award',
'reason',
)
read_only_fields = ('id', )
class ReviewSerializer(serializers.ModelSerializer):
user = BasicUserSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(source='user', queryset=User.objects.all())
created_by = BasicUserSerializer(read_only=True)
votes = VoteSerializer(read_only=True, many=True)
class Meta:
model = Review
fields = (
'id',
'user',
'user_id',
'description',
'created',
'created_by',
'votes',
)
read_only_fields = (
'id',
'created',
'created_by',
'votes',
)
class EventSerializer(serializers.ModelSerializer):
location = LocationSerializer(read_only=True)
created_by = BasicUserSerializer(read_only=True)
event_leader = BasicUserSerializer(read_only=True)
event_leader_id = serializers.PrimaryKeyRelatedField(
source='event_leader', queryset=User.objects.all())
location_id = serializers.PrimaryKeyRelatedField(
source='location', queryset=Location.objects.all())
class Meta:
model = Event
fields = (
'id',
'title',
'slug',
'created',
'created_by',
'dkp',
'event_leader',
'event_leader_id',
'section',
'location',
'location_id',
'started',
'stopped',
'scheduled',
)
read_only_fields = (
'id',
'slug',
'created',
'created_by',
'event_leader'
'dkp',
'section',
'location',
)
class QuoteSerializer(serializers.ModelSerializer):
poster = BasicUserSerializer(read_only=True)
involved = BasicUserSerializer(many=True, read_only=True)
involved_ids = serializers.PrimaryKeyRelatedField(source='involved', queryset=User.objects.all(), many=True)
class Meta:
model = Quote
fields = (
'id',
'title',
'slug',
'body',
'created',
'type',
'image',
'poster',
'involved',
'involved_ids',
)
read_only_fields = (
'id',
'slug',
'created',
'poster',
'involved',
)
def create(self, validated_data):
involved = validated_data.pop('involved')
quote = Quote(**validated_data)
quote.save()
quote.involved = involved
return quote
class CommentSerializer(serializers.ModelSerializer):
user = BasicUserSerializer(read_only=True)
deleted_by = BasicUserSerializer(read_only=True)
class Meta:
model = Comment
fields = (
'id',
'body',
'user',
'created',
'public',
'is_deleted',
'deleted_by',
'deleted_time',
)
read_only_fields = (
'id',
'created',
'public',
'is_deleted',
'deleted_by',
'deleted_time',
)
class DonateAmountSerializer(serializers.ModelSerializer):
user = BasicUserSerializer(read_only=True)
class Meta:
model = DonateAmount
fields = (
'id',
'user',
'amount',
'created',
)
read_only_fields = (
'id',
'user',
'created',
)
class VoteSerializer(serializers.ModelSerializer):
created_by = BasicUserSerializer(read_only=True)
class Meta:
model = Vote
fields = (
'id',
'vote',
'created',
'created_by',
)
read_only_fields = (
'id',
'created',
'created_by',
)
class FeedPostSerializer(ModelSerializer):
author = BasicUserSerializer(read_only=True)
class Meta:
model = FeedPost
fields = (
'id',
'author',
'created',
'body',
)
read_only_fields = (
'id',
'author',
'created',
)
class FeedItemSerializer(ModelSerializer):
user = BasicUserSerializer(read_only=True)
feed_post = FeedPostSerializer(read_only=True)
rank = RankSerializer(read_only=True)
award = AwardFullSerializer(read_only=True)
news = NewsSerializer(read_only=True)
chapter = ChapterSerializer(read_only=True)
quote = QuoteSerializer(read_only=True)
screenshot = ScreenshotSerializer(read_only=True)
class Meta:
model = FeedItem
fields = (
'id',
'user',
'type',
'created',
'public',
'is_deleted',
'deleted_by',
'deleted_time',
'chapter',
'news',
'rank',
'feed_post',
'award',
'quote',
'screenshot',
)
read_only_fields = (
'id',
'user',
'type',
'created',
'public',
'is_deleted',
'deleted_by',
'deleted_time',
'chapter',
'news',
'rank',
'feed_post',
'award',
'quote',
'screenshot',
)
class VoteSerializer(serializers.ModelSerializer):
user = BasicUserSerializer(read_only=True)
class Meta:
model = Vote
fields = (
'id',
'created',
'poll',
'item',
'user',
)
read_only_fields = (
'id',
'created',
'user',
)
class NotificationSerializer(ModelSerializer):
creator = BasicUserSerializer()
rank = RankSerializer()
award = AwardSerializer()
chapter = ChapterSerializer()
class Meta:
model = Notification
fields = (
'type',
'created',
'user',
'creator',
'chapter',
'rank',
'award',
)
def get(self, request, *args, **kwargs):
try:
if self.users_func is None:
obj_id = int(request.query_params['id'])
serializer = BasicUserSerializer(
self.field_func(obj_id=obj_id).all(),
many=True,
context={'request': request})
else:
serializer = self.serializer(
self.users_func(user_id=self.request.user.id).all(),
many=True,
context={'request': request})
return Response(serializer.data)
except ObjectDoesNotExist:
return Response({'detail': 'Item does not exist'},
status=status.HTTP_404_NOT_FOUND)
except KeyError:
return Response({'detail': 'Missing id query parameter'})
class EventAttendanceSerializer(serializers.ModelSerializer):
user = BasicUserSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(source='user',
queryset=User.objects.all())
class Meta:
model = EventAttendance
fields = (
'id',
'event',
'user',
'user_id',
'started',
'stopped',
'standby',
)
read_only_fields = (
'id',
'event',
)
class NoteSerializer(serializers.ModelSerializer):
created_by = BasicUserSerializer(read_only=True)
game = GameSerializer(read_only=True)
game_id = serializers.PrimaryKeyRelatedField(source='game', queryset=Game.objects.all())
class Meta:
model = Note
fields = (
'id',
'body',
'created',
'created_by',
'game',
'game_id',
)
read_only_fields = (
'id',
'created',
'created_by',
'game',
)
class GenericCommentDetailSerializer(GenericCommentSerializer):
tagged_users = BasicUserSerializer(read_only=True, many=True)
class RoomDetailSerializer(RoomSerializer):
members = BasicUserSerializer(read_only=True, many=True)
