class FoodOrderDetailSerializer(ModelSerializer):
url = new_detail_url
user = UserDetailSerializer(read_only=True)
meal = MealDetailSerializer(read_only=True)
class Meta:
model = FoodOrder
fields = [
'url',
'id',
'user',
'meal',
'amount',
'status',
'location',
'lat',
'lng',
'refrence',
'timestamp',
]
class PatientListSerializer(ModelSerializer):
url = patient_detail_url
patient = UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='patient-api:delete',
lookup_field='id' #or primary key <pk>
)
class Meta:
model = PatientProfile
fields = [
'url',
'patient',
'id',
'location',
'latitude',
'longitude',
'timestamp',
'updated',
'delete_url',
]
class FaqsListSerializer(ModelSerializer):
url = new_detail_url
user = UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='faqs-api:delete',
lookup_field='pk' #or primary key <pk>
)
class Meta:
model = Faq
fields = [
'url',
'id',
'user',
'name',
'question',
'answer',
'link',
'timestamp',
'delete_url',
]
class AmbulanceListSerializer(ModelSerializer):
url = new_detail_url
user = UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='ambulance-api:delete',
lookup_field='pk'#or primary key <pk>
)
class Meta:
model = AmbulanceRequests
fields = [
'url',
'id',
'user',
'status',
'location',
'problem',
'lat',
'lng',
'timestamp',
'delete_url',
]
class RestaurantListSerializer(ModelSerializer):
url = new_detail_url
UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='restaurants-api:delete',
lookup_field='pk' #or primary key <pk>
)
class Meta:
model = Restaurant
fields = [
'url',
'id',
'user',
'name',
'location',
'lat',
'lng',
'updated',
'timestamp',
'delete_url',
]
class LostsListSerializer(ModelSerializer):
url = new_detail_url
user = UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='lostandfound-api:delete',
lookup_field='pk' #or primary key <pk>
)
class Meta:
model = Lost
fields = [
'url',
'id',
'user',
'name',
'contact',
'place',
'image',
'updated',
'timestamp',
'delete_url',
]
class NoticesListSerializer(ModelSerializer):
url = new_detail_url
user = UserDetailSerializer(read_only=True)
delete_url = HyperlinkedIdentityField(
view_name='notices-api:delete',
lookup_field='pk' #or primary key <pk>
)
class Meta:
model = Notice
fields = [
'url',
'id',
'user',
'title',
'content',
'image',
'image1',
'updated',
'timestamp',
'delete_url',
]
class FinancialStatementListSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
url = new_detail_url
delete_url = HyperlinkedIdentityField(
view_name='financial-api:delete',
lookup_field='pk'#or primary key <pk>
)
class Meta:
model = FinancialStatement
fields = [
'url',
'id',
'user',
'description',
'date',
'debit',
'credit',
'closing_balance',
'updated',
'timestamp',
'delete_url',
]
class ReportSerializer(serializers.ModelSerializer):
"""
Serializer that represents a report.
"""
reporter = UserDetailSerializer(read_only=True)
report_string = serializers.SerializerMethodField()
created_naturaltime = serializers.SerializerMethodField()
class Meta:
model = Report
fields = [
'id',
'report_string',
'reporter',
'comment',
'subject',
'board',
'created',
'created_naturaltime',
]
def get_report_string(self, obj):
"""Returns string representation of report."""
return str(obj)
def get_is_commenter(self, obj):
"""Checks if user is the commenter."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user == obj.commenter:
return True
return False
def get_created_naturaltime(self, obj):
"""Returns human readable time."""
return naturaltime(obj.created)
class NotificationSerializer(serializers.ModelSerializer):
"""
Serializer that represents a report
"""
Actor = UserDetailSerializer(read_only=True)
notification_string = serializers.SerializerMethodField()
created_naturaltime = serializers.SerializerMethodField()
class Meta:
model = Notification
fields = [
'id',
'notification_string',
'Actor',
'Object',
'is_read',
'created',
'created_naturaltime',
]
def get_notification_string(self, obj):
"""Returns string representation of notification"""
return str(obj)
def get_is_reviewer(self, obj):
"""Checks if user is the commenter"""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user == obj.reviewer:
return True
return False
def get_created_naturaltime(self, obj):
"""Returns human readable time"""
return naturaltime(obj.created)
class CommentSerializer(serializers.ModelSerializer):
"""
Serializer that represents a comment.
"""
commenter = UserDetailSerializer(read_only=True)
is_commenter = serializers.SerializerMethodField()
created_naturaltime = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = [
'id',
'body',
'subject',
'commenter',
'is_commenter',
'created',
'created_naturaltime',
]
def get_is_commenter(self, obj):
"""Checks if user is the commenter."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user == obj.commenter:
return True
return False
def get_created_naturaltime(self, obj):
"""Returns human readable time."""
return naturaltime(obj.created)
def create(self, validated_data):
"""Handles the creation of comment."""
instance = self.Meta.model(**validated_data)
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
instance.save()
# Use celery to create notifications in the background.
subject = validated_data['subject']
if user is not subject.author:
Notification.objects.create(Actor=user,
Object=subject,
Target=subject.author,
notif_type='comment')
# Checks if someone is mentioned in the comment
body = validated_data['body']
words_list = body.split(" ")
names_list = []
for word in words_list:
# if first two letters of the word is "u/" then the rest of the word
# will be treated as a username
if word[:2] == "u/":
username = word[2:]
try:
mentioned_user = User.objects.get(username=username)
if mentioned_user not in names_list:
if user is not mentioned_user:
Notification.objects.create(
Actor=user,
Object=subject,
Target=mentioned_user,
notif_type='comment_mentioned')
names_list.append(mentioned_user)
except: # noqa: E722
pass
return instance
class BoardSerializer(serializers.ModelSerializer):
"""
Serializer that represents a board.
"""
admins = UserDetailSerializer(read_only=True, many=True)
subscribers_count = serializers.SerializerMethodField()
created = serializers.DateTimeField(read_only=True)
created_naturaltime = serializers.SerializerMethodField()
is_subscribed = serializers.SerializerMethodField()
cover_url = serializers.SerializerMethodField()
total_posts = serializers.SerializerMethodField()
is_admin = serializers.SerializerMethodField()
class Meta:
model = Board
fields = [
'id', 'title', 'slug', 'description', 'cover', 'cover_url',
'total_posts', 'admins', 'subscribers_count', 'created',
'created_naturaltime', 'is_subscribed', 'is_admin',
]
def get_admins(self, obj):
"""Returns a list of admins."""
return obj.get_admins()
def get_total_posts(self, obj):
"""Calculates number of total posts in a board."""
return obj.submitted_subjects.count()
def get_cover_url(self, obj):
"""Returns board cover url."""
request = self.context.get('request')
cover_url = obj.get_picture()
return request.build_absolute_uri(cover_url)
def get_subscribers_count(self, obj):
"""Calculates number of subscribers."""
return obj.subscribers.all().count()
def get_is_subscribed(self, obj):
"""Checks if user is subscribed to the board."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user in obj.subscribers.all():
return True
return False
def get_created_naturaltime(self, obj):
"""Returns human readable time."""
return naturaltime(obj.created)
def get_is_admin(self, obj):
"""Checks if user is admin."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user in obj.admins.all():
return True
return False
def create(self, validated_data):
"""Handles the creation of board."""
instance = self.Meta.model(**validated_data)
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
instance.save()
instance.admins.add(user)
instance.subscribers.add(user)
instance.save()
return instance
class SubjectSerializer(serializers.ModelSerializer):
"""
Serializer that represents a subject.
"""
body_linkified = serializers.SerializerMethodField()
author = UserDetailSerializer(read_only=True)
board_slug = serializers.SerializerMethodField()
stars_count = serializers.SerializerMethodField()
comments_count = serializers.SerializerMethodField()
is_starred = serializers.SerializerMethodField()
created = serializers.DateTimeField(read_only=True)
created_naturaltime = serializers.SerializerMethodField()
is_author = serializers.SerializerMethodField()
class Meta:
model = Subject
fields = [
'id',
'title',
'slug',
'body',
'body_linkified',
'photo',
'author',
'board',
'board_slug',
'stars_count',
'comments_count',
'is_starred',
'created',
'created_naturaltime',
'is_author',
]
def get_body_linkified(self, obj):
"""Linkifies the body."""
return obj.linkfy_subject()
def get_board_slug(self, obj):
"""Returns board slug."""
return obj.board.slug
def get_stars_count(self, obj):
"""Counts stars on subject."""
return obj.points.all().count()
def get_comments_count(self, obj):
"""Counts comments on subject."""
return obj.comments.all().count()
def get_is_starred(self, obj):
"""Check if user has starred subject."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user in obj.points.all():
return True
return False
def get_created_naturaltime(self, obj):
"""Returns human readable time."""
return naturaltime(obj.created)
def get_is_author(self, obj):
"""Checks if user is the author of the subject."""
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user == obj.author:
return True
return False
def create(self, validated_data):
"""Handles the creation of board."""
instance = self.Meta.model(**validated_data)
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
instance.save()
# Use celery to create notifications in the background.
title = validated_data['title']
body = validated_data['body']
# Checks if someone is mentioned in the subject
words = title + ' ' + body
words_list = words.split(" ")
names_list = []
for word in words_list:
# if first two letter of the word is "u/" then the rest of the word
# will be treated as a username
if word[:2] == "u/":
username = word[2:]
try:
mentioned_user = User.objects.get(username=username)
if mentioned_user not in names_list:
instance.mentioned.add(user)
if user is not mentioned_user:
Notification.objects.create(
Actor=user,
Object=instance,
Target=mentioned_user,
notif_type='subject_mentioned')
names_list.append(user)
except: # noqa: E722
pass
return instance
class PostSerializer(serializers.ModelSerializer):
body_linkified = serializers.SerializerMethodField()
author = UserDetailSerializer(read_only=True)
group_slug = serializers.SerializerMethodField()
comments_count = serializers.SerializerMethodField()
created = serializers.DateTimeField(read_only=True)
created_naturaltime = serializers.SerializerMethodField()
is_author = serializers.SerializerMethodField()
class Meta:
model = Post
fields = [
'id',
'title',
'slug',
'body',
'body_linkified',
'photo',
'author',
'group',
'group_slug',
'comments_count',
'created',
'created_naturaltime',
'is_author',
]
def get_body_linkified(self, obj):
return obj.linkfy_post()
def get_group_slug(self, obj):
return obj.group.slug
def get_stars_count(self, obj):
return obj.points.all().count()
def get_comments_count(self, obj):
return obj.comments.all().count()
def get_created_naturaltime(self, obj):
return naturaltime(obj.created)
def get_is_author(self, obj):
user = None
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
if user == obj.author:
return True
return False
def create(self, validated_data):
instance = self.Meta.model(**validated_data)
request = self.context.get('request')
if request and hasattr(request, 'user'):
user = request.user
instance.save()
title = validated_data['title']
body = validated_data['body']
words = title + ' ' + body
words_list = words.split(" ")
names_list = []
for word in words_list:
if word[:2] == "u/":
username = word[2:]
try:
mentioned_user = User.objects.get(username=username)
if mentioned_user not in names_list:
instance.mentioned.add(user)
if user is not mentioned_user:
Notification.objects.create(
Actor=user,
Object=instance,
Target=mentioned_user,
notif_type='post_mentioned')
names_list.append(user)
except:
pass
return instance
