class ChangeUserOrganizationRoleSerializer(serializers.Serializer):
"""
TODO: Can we merge this with the actual UserSerializer?
A: I dunno, but i doubled down in the next serializer
"""
role = serializers.ChoiceField(
choices=['Member', 'Admin']
)
user = serializers.PrimaryKeyRelatedField(
queryset=User.objects.get_queryset()
)
organization = serializers.PrimaryKeyRelatedField(
queryset=Organization.objects.get_queryset()
)
def save(self, **kwargs):
role = self.validated_data['role']
user = self.validated_data['user']
organization = self.validated_data['organization']
org_user, _ = organization.get_or_add_user(user)
if role == "Admin":
org_user.is_admin = True
else:
org_user.is_admin = False
org_user.save()
return True
class Meta:
model = User
class RegisterSerializer(serializers.ModelSerializer):
forum = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
user = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
class Meta:
model = models.Register
exclude = ('date', )
class ImageryRequestSerializer(serializers.HyperlinkedModelSerializer):
requested_scenes = serializers.PrimaryKeyRelatedField(many=True,
read_only=True)
job_bundles = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
class Meta:
model = ImageryRequest
fields = '__all__'
class EntrySerializer(serializers.ModelSerializer):
permissions = DRYPermissionsField()
competitor = serializers.PrimaryKeyRelatedField(
queryset=Competitor.objects.all(),
required=False,
allow_null=True,
)
# logs = StateLogSerializer(many=True)
statelogs = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
class Meta:
model = Entry
fields = (
'id',
'url',
'status',
'is_evaluation',
'is_private',
'draw',
'seed',
'prelim',
'participants',
'pos',
'representing',
'rank',
'description',
'notes',
'mus_points',
'per_points',
'sng_points',
'tot_points',
'mus_score',
'per_score',
'sng_score',
'tot_score',
'mus_rank',
'per_rank',
'sng_rank',
'tot_rank',
'session',
'group',
'competitor',
'contestants',
'permissions',
'statelogs',
)
def validate(self, data):
"""Check that the start is before the stop."""
# if data['is_private'] and data['contestants']:
# raise serializers.ValidationError("Can not be private and compete for an award.")
return data
class ChangePasswordSerializer(serializers.Serializer):
"""
When a user is logged in, allow them to change their own password
"""
current_password = serializers.CharField()
confirm_password = serializers.CharField()
password = serializers.CharField()
user = serializers.PrimaryKeyRelatedField(
queryset=User.objects.get_queryset()
)
def validate(self, data):
# Check current password
if not data['user'].check_password(data['current_password']):
raise serializers.ValidationError(
'Current password is not correct'
)
# Perform server side validation
if data['password'] != data['confirm_password']:
raise serializers.ValidationError(
'Password and Confirm Password should be the same'
)
return data
def save(self, **kwargs):
user = self.validated_data['user']
user.set_password(self.validated_data['password'])
user.save()
return True
class Meta:
model = User
class GroupSerializer(serializers.ModelSerializer):
"""This class is used to manage how we pass Group to the client app."""
members = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
class Meta:
model = Group
fields = '__all__'
class GuestLoginRequestSerializer(serializers.Serializer):
page = serializers.PrimaryKeyRelatedField(
queryset=Page.objects.all(),
many=False
)
email = serializers.EmailField()
def save(self, **kwargs):
email = self.validated_data['email']
page = self.validated_data['page']
group = page.group
try:
user = User.objects.get(username=email)
if group.is_guest(user):
generate_user_magic_link.delay(user_id=str(user.id), page_id=str(page.id))
return True
except Exception:
# ToDo: Probably add some sort of instrumentation here
return True
class Meta:
model = User
fields = (
'name',
'group'
)
class FullNormalizedDataSerializer(serializers.ModelSerializer):
tasks = serializers.PrimaryKeyRelatedField(many=True, read_only=False, queryset=CeleryTaskResult.objects.all())
source = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = models.NormalizedData
fields = ('data', 'source', 'raw', 'tasks')
class AnalysisSerializer(serializers.ModelSerializer):
dataset = serializers.PrimaryKeyRelatedField(queryset=Dataset.objects)
class Meta:
model = Analysis
fields = '__all__'
validators = []
depth = 2
class GuestUserCreateSerializer(serializers.Serializer):
"""
TODO: Matt rewrite with gin
"""
organization = serializers.PrimaryKeyRelatedField(
queryset=Organization.objects.get_queryset(),
many=False
)
email = serializers.EmailField()
name = serializers.CharField()
# I don't know why, but setting this to be a pk related field errors...
page = serializers.PrimaryKeyRelatedField(
queryset=Page.objects.all(),
many=False
)
def save(self, **kwargs):
email = self.validated_data['email']
user, created = User.objects.get_or_create(username=email)
if created:
user.name = self.validated_data['name']
organization = self.validated_data['organization']
org_user, _ = organization.get_or_add_user(user)
org_user.is_guest = True
org_user.is_admin = False
user.save()
org_user.save()
page = self.validated_data['page']
page.viewers.add(user)
page.save()
return user
class Meta:
model = User
fields = (
'name',
'group'
)
class FloorSerializer(serializers.ModelSerializer):
building = BuildingSerializer(read_only=True)
building_id = serializers.PrimaryKeyRelatedField(
read_only=False, queryset=Building.objects.all())
included_serializers = {'building': BuildingSerializer}
class Meta:
model = Floor
fields = ('id', 'building', 'name', 'building_id')
class JSONAPIMeta:
included_resources = ['building']
class ChangedFieldSerializer(serializers.Serializer):
title = serializers.CharField(max_length=200, required=False)
priority = serializers.IntegerField(min_value=1,
max_value=5,
required=False)
resolution = serializers.CharField(required=False)
due_date = serializers.DateTimeField(required=False, allow_null=True)
assigned_to = serializers.PrimaryKeyRelatedField(
required=False,
allow_null=True,
queryset=Person.objects.all(
) # TODO restrict this queryset to something more sensible
)
signaled_by = serializers.PrimaryKeyRelatedField(
required=False, allow_null=True, queryset=Person.objects.all())
organization = serializers.PrimaryKeyRelatedField(
required=False, allow_null=True, queryset=Organization.objects.all())
department = serializers.PrimaryKeyRelatedField(
required=False, allow_null=True, queryset=Team.objects.all())
class CommentSerializer(serializers.ModelSerializer):
topic = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
user = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
html_description = serializers.SerializerMethodField()
html_description = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
def get_html_description(self, obj):
# Parse markdown
return mistune.markdown(obj.description)
def get_likes(self, obj):
# Get likes comment
try:
likes = obj.likes_comment.users
except models.LikeComment.DoesNotExist:
likes = []
return likes
class Meta:
model = models.Comment
fields = '__all__'
class FullNormalizedDataSerializer(serializers.ModelSerializer):
# link to self
url = fields.ShareIdentityField(view_name='api:normalizeddata-detail')
tasks = serializers.PrimaryKeyRelatedField(
many=True,
read_only=False,
queryset=models.CeleryTaskResult.objects.all())
source = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = models.NormalizedData
fields = ('data', 'source', 'raw', 'tasks', 'url')
class GeneratedReportDownloadSerializer(serializers.Serializer):
"""
Serializer to automatically generate a downloadable report for a list of
Saved bills
"""
title = serializers.CharField()
organization = serializers.PrimaryKeyRelatedField(
queryset=Organization.objects.get_queryset(), many=False)
group = serializers.PrimaryKeyRelatedField(queryset=Group.objects.all(),
many=False)
def save(self, **kwargs):
org_id = str(self.validated_data['organization'].id)
title = self.validated_data['title']
url = GenerateReport(org_id=org_id,
group_id=str(
self.validated_data['group'].id)).from_group(
str(self.validated_data['group'].id),
title)
return url
class Meta:
model = Group
class ChangeUserStatusSerializer(serializers.Serializer):
"""
TODO: Can we merge this with the actual UserSerializer?
"""
status = serializers.BooleanField()
user = serializers.PrimaryKeyRelatedField(
queryset=User.objects.get_queryset()
)
def save(self, **kwargs):
user = self.validated_data['user']
user.is_active = self.validated_data['status']
user.save()
return True
class Meta:
model = User
class EntrySerializer(serializers.ModelSerializer):
permissions = DRYPermissionsField()
# logs = StateLogSerializer(many=True)
statelogs = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
included_serializers = {
'contestants': 'apps.smanager.serializers.ContestantSerializer',
'statelogs': 'apps.smanager.serializers.StateLogSerializer',
'group': 'apps.bhs.serializers.GroupSerializer',
}
class Meta:
model = Entry
fields = (
'id',
'url',
'status',
'is_evaluation',
'is_private',
'is_mt',
'draw',
'seed',
'prelim',
'participants',
'pos',
'representing',
'description',
'notes',
'session',
'group',
'contestants',
'permissions',
'statelogs',
)
class JSONAPIMeta:
included_resources = [
# 'appearances',
'contestants',
]
def validate(self, data):
"""Check that the start is before the stop."""
# if data['is_private'] and data['contestants']:
# raise serializers.ValidationError("Can not be private and compete for an award.")
return data
class ProfileSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
photo = CustomFileField(
validators=[valid_extension_image],
max_length=None,
allow_empty_file=True,
)
last_seen = serializers.SerializerMethodField()
online = serializers.SerializerMethodField()
def get_last_seen(self, obj):
return obj.last_seen
def get_online(self, obj):
return obj.online
class Meta:
model = models.Profile
fields = '__all__'
class EntrySerializer(serializers.ModelSerializer):
permissions = DRYPermissionsField()
statelogs = serializers.PrimaryKeyRelatedField(
many=True,
read_only=True,
)
included_serializers = {
}
class Meta:
model = Entry
fields = [
'id',
'status',
'is_evaluation',
'is_private',
'is_mt',
'is_senior',
'is_youth',
'draw',
'seed',
'prelim',
'base',
'participants',
'pos',
'representing',
'chapters',
'description',
'notes',
'image_id',
'group_id',
'name',
'kind',
'gender',
# 'district',
'division',
'bhs_id',
'code',
'owners',
'contests',
'repertories',
'session',
'statelogs',
'permissions',
]
read_only_fields = [
'image_id',
]
class JSONAPIMeta:
included_resources = [
# 'appearances',
]
def validate(self, data):
"""Check that the start is before the stop."""
# if data['is_private']:
# raise serializers.ValidationError("Can not be private and compete for an award.")
return data
class ContentTypeFieldSerializer(serializers.ModelSerializer):
"""
Serializer class that provides a contenty_type field
"""
target_content_type = serializers.PrimaryKeyRelatedField(
many=False, queryset=get_allowed_contenttypes())
class TopicSerializer(serializers.ModelSerializer):
total_comments = serializers.SerializerMethodField()
views = serializers.SerializerMethodField()
forum = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
user = serializers.PrimaryKeyRelatedField(many=False, read_only=True)
html_description = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
users_topic_comment = serializers.SerializerMethodField()
def get_total_comments(self, obj):
"""
Get total comments of topic
"""
return obj.topics.count()
def get_views(self, obj):
"""
Get total hitcounts
"""
hit = models.HitcountTopic.objects.filter(topic=obj)
if hit.exists():
count = len(hit.first().data)
else:
count = 0
return count
def get_html_description(self, obj):
# Parse markdown
return mistune.markdown(obj.description)
def get_likes(self, obj):
# Get likes topic
try:
likes = obj.likes_topic.users
except models.LikeTopic.DoesNotExist:
likes = []
return likes
def get_users_topic_comment(self, obj):
# I get the users who participated in the topic
users = []
list_users = []
username_topic = obj.user.username
for comment in obj.topics.all():
username = comment.user.username
if not (username in list_users):
photo = utils.get_photo_profile(comment.user.id)
record = {"username": username, "photo": photo}
# If is creator topic, add top
if username == username_topic:
users.insert(0, record)
else:
users.append(record)
list_users.append(username)
# If creator topic not exists, add
if not (username_topic in list_users) and obj.topics.count() > 0:
photo = utils.get_photo_profile(obj.user.id)
users.insert(0, {"username": username_topic, "photo": photo})
return users
class Meta:
model = models.Topic
fields = '__all__'
read_only_fields = ('slug', )
