class MovieSerializer(serializers.ModelSerializer):
id = serializers.IntegerField()
name = serializers.CharField(max_length=50)
score = serializers.IntegerField()
author_id = serializers.IntegerField()
class Meta:
model = Movie
fields = '__all__'
class VideoSerializer(serializers.Serializer):
dependency_count = serializers.SerializerMethodField()
duration = serializers.IntegerField()
license_name = serializers.SerializerMethodField()
license_url = serializers.SerializerMethodField()
name = serializers.CharField(max_length=100)
url = serializers.URLField()
stream_url = serializers.URLField()
image_url = serializers.URLField()
provider_name = serializers.CharField(max_length=100)
tags = serializers.SerializerMethodField()
def get_dependency_count(self, obj):
data = self.context.get(obj.id)
if data:
return data.get('dep_count', 0)
return 0
def get_license_name(self, obj):
value = obj.license_name
if value is None or len(value) == 0:
return None
return value
def get_license_url(self, obj):
value = obj.license_url
if value is None or len(value) == 0:
return None
return value
def get_tags(self, obj):
sorted_categories = sorted(
obj.categories,
key=lambda cat: obj.categories.get(cat, 'weight', default=0))
return ','.join([cat.name for cat in sorted_categories])
def __init__(self, *args, **kwargs):
# super hates my additional kwargs
sparse = kwargs.pop('sparse', False)
version_serializer = kwargs.pop('version_serializer', False)
super(BaseShareSerializer, self).__init__(*args, **kwargs)
if sparse:
# clear the fields if they asked for sparse
self.fields.clear()
else:
# remove hidden fields
excluded_fields = ['change', 'sources']
for field_name in tuple(self.fields.keys()):
if 'version' in field_name or field_name in excluded_fields:
self.fields.pop(field_name)
# version specific fields
if version_serializer:
self.fields.update({
'action': serializers.CharField(max_length=10),
'persistent_id': serializers.IntegerField()
})
# add fields with improper names
self.fields.update({
'type': fields.TypeField(),
})
class ExamSerializer(serializers.ModelSerializer):
test_assignment_id = serializers.IntegerField()
questions = serializers.SerializerMethodField()
results = serializers.SerializerMethodField()
class Meta:
model = Exam
fields = [
'id',
'test_assignment_id',
'user',
'results',
'questions',
]
read_only_fields = ['user', 'progress']
def get_results(self, obj):
return obj.test_results()
def get_questions(self, obj):
# todo serialize many questions
serializer = QuestionSerializer(obj.test_assignment.questions.all(),
many=True)
return serializer.data
def create(self, validated_data):
from afi_backend.exams.api.serializers import QuestionSerializer
# Create Exam using test_assignment_id
test_assignment = TestAssignment.objects.get(
id=validated_data['test_assignment_id'])
exam = Exam.objects.create(user=self.context['request'].user,
test_assignment=test_assignment)
return exam
class AuthorSerializer(serializers.ModelSerializer):
id = serializers.IntegerField()
name = serializers.CharField(max_length=50)
email = serializers.CharField(max_length=30)
class Meta:
model = Author
fields = '__all__'
class KeywordedResponseSerializer(serializers.ModelSerializer):
class Meta:
model = KeywordedResponse
fields = '__all__'
id = serializers.IntegerField(read_only=True)
keyword = serializers.CharField(read_only=True)
response = serializers.CharField(read_only=True)
class IgnoreNumberSerializer(serializers.ModelSerializer):
class Meta:
model = IgnoreNumber
fields = '__all__'
id = serializers.IntegerField(read_only=True)
number = serializers.CharField(read_only=True)
note = serializers.CharField(read_only=True)
class NewMemberNoticeSerializer(serializers.ModelSerializer):
class Meta:
model = NewMemberNotice
fields = '__all__'
id = serializers.IntegerField(read_only=True)
title = serializers.CharField(read_only=True)
response = serializers.CharField(read_only=True)
class WriteonlyTestSerializer(serializers.ModelSerializer):
'''Serializer for testing the absence of write_only fields'''
comments = serializers.ResourceRelatedField(
many=True, write_only=True, queryset=Comment.objects.all())
rating = serializers.IntegerField(write_only=True)
class Meta:
model = Entry
fields = ('comments', 'rating')
class OrganismRetriveSerializer(OrganismSerializer):
count = serializers.IntegerField(required=False)
class Meta:
model = m_models.Organism
exclude = (
'id',
'ancestors',
)
class TokenProxySerializer(serializers.ModelSerializer):
username = serializers.CharField(write_only=True, required=False)
password = serializers.CharField(write_only=True, required=False)
municipality = serializers.IntegerField(required=False)
token = serializers.SerializerMethodField()
def get_token(self, obj):
client = HousingStatClient()
token_resp = client.get_token(username=obj.username,
password=obj.password)
if token_resp["success"] is True:
return token_resp["token"]
raise ValidationError({
token_resp["status_code"]: {
"source": "external",
"reason": token_resp["reason"],
}
})
def create(self, validated_data):
user = self.context["request"].user
username = validated_data.get("username")
password = validated_data.get("password")
municipality = validated_data.get("municipality")
if username and password and municipality:
user_creds, _ = models.HousingStatCreds.objects.update_or_create(
owner=user.username,
defaults={
"username": username,
"password": password,
"municipality": municipality,
},
)
else:
user_creds = models.HousingStatCreds.objects.filter(
owner=user.username)
user_creds.update(**validated_data)
user_creds = user_creds.first()
if not user_creds:
raise ValidationError({
400: {
"source":
"internal",
"reason":
f'No housing stat credentials found for user "{user.username}"',
}
})
return user_creds
class Meta:
model = models.HousingStatCreds
fields = ("username", "password", "token", "municipality")
class ExamProgressSerializer(serializers.Serializer):
answer_id = serializers.IntegerField(source='chosen_aswers.id',
read_only=True)
chosen_answers = AnswerSerializer(read_only=True, many=True)
class Meta:
model = Progress
fields = [
'answer_id',
'chosen_answers',
]
class UserSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
first_name = serializers.CharField(read_only=True)
last_name = serializers.CharField(read_only=True)
class Meta:
model = User
fields = [
"id", "first_name", "last_name", "available_from", "available_to",
"facebook_link", "interests"
]
read_only_fields = ["id", "first_name", "last_name", "facebook_link"]
class KeggOrthologRetrieveSerializer(m_serializers.DynamicDocumentSerializer,
serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='emgapi_v1:kegg-orthologs-detail',
lookup_field='accession',
)
count = serializers.IntegerField(required=True)
class Meta:
model = m_models.KeggOrtholog
fields = '__all__'
class GoTermRetriveSerializer(m_serializers.DynamicDocumentSerializer,
serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='emgapi_v1:goterms-detail',
lookup_field='accession',
)
count = serializers.IntegerField(required=False)
class Meta:
model = m_models.GoTerm
fields = '__all__'
class EntrySerializer(serializers.Serializer):
blog = serializers.IntegerField()
comments = CommentSerializer(many=True, required=False)
comment = CommentSerializer(required=False)
headline = serializers.CharField(allow_null=True, required=True)
body_text = serializers.CharField()
def validate(self, attrs):
body_text = attrs['body_text']
if len(body_text) < 5:
raise serializers.ValidationError({'body_text': {
'title': 'Too Short title', 'detail': 'Too short'}
})
def __new__(cls, name, bases, attrs):
new_class = super().__new__(cls, name, bases, attrs)
new_class._declared_fields["id"] = serializers.IntegerField(
read_only=True)
for fieldname, field in json_api_model._meta.fields.items():
if (isinstance(field, fields.Attribute)
and not isinstance(field, fields.Relationship)
and (only_fields is None or fieldname in only_fields)):
new_class._declared_fields[fieldname] = MAPPING.get(
field.__class__,
serializers.ReadOnlyField,
)(read_only=True)
return new_class
class EntrySerializer(serializers.Serializer):
blog = serializers.IntegerField()
comments = CommentSerializer(many=True, required=False)
comment = CommentSerializer(required=False)
headline = serializers.CharField(allow_null=True, required=True)
body_text = serializers.CharField()
def validate(self, attrs):
body_text = attrs["body_text"]
if len(body_text) < 5:
raise serializers.ValidationError(
{"body_text": {"title": "Too Short title", "detail": "Too short"}}
)
class AntiSmashGeneClusterRetrieveSerializer(
m_serializers.DynamicDocumentSerializer,
serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(
view_name='emgapi_v1:antismash-gene-clusters-detail',
lookup_field='accession',
)
count = serializers.IntegerField(required=True)
class Meta:
model = m_models.AntiSmashGeneCluster
fields = '__all__'
class HistoryVideoSerializer(serializers.Serializer):
count = serializers.SerializerMethodField()
date = serializers.SerializerMethodField()
duration = serializers.IntegerField()
url = serializers.URLField()
image_url = serializers.URLField()
license_name = serializers.SerializerMethodField()
license_url = serializers.SerializerMethodField()
name = serializers.CharField(max_length=100)
progress = serializers.SerializerMethodField()
provider_name = serializers.CharField(max_length=100)
stream_url = serializers.URLField()
tags = serializers.SerializerMethodField()
def get_date(self, obj):
data = self.context.get(obj.id)
if data:
return data[0]
return '1970-01-01'
def get_count(self, obj):
data = self.context.get(obj.id)
if data:
return data[1]
return 1
def get_progress(self, obj):
data = self.context.get(obj.id)
if data:
return data[2]
return 1
def get_license_name(self, obj):
value = obj.license_name
if value is None or len(value) == 0:
return None
return value
def get_license_url(self, obj):
value = obj.license_url
if value is None or len(value) == 0:
return None
return value
def get_tags(self, obj):
sorted_categories = sorted(
obj.categories,
key=lambda cat: obj.categories.get(cat, 'weight', default=0))
return ','.join([cat.name for cat in sorted_categories])
class CourseLectureSerializer(serializers.ModelSerializer):
included_serializers = {
'lecturer': events_serializers.LecturerSerializer,
}
part = serializers.CharField(source='part.name')
part_id = serializers.IntegerField(source='part.id')
tests = TestAssignmentSerializer(many=True, read_only=True)
class Meta:
model = CourseLecture
fields = [
'course',
'description',
'lecturer',
'name',
'part',
'part_id',
'vimeo_video_id',
'tests',
]
class CartOrderItemSerializer(serializers.ModelSerializer):
item_type = serializers.CharField()
object_id = serializers.IntegerField()
customer_email = serializers.EmailField()
class Meta:
model = OrderItem
fields = ['item_type', 'object_id', 'customer_email']
def create(self, validated_data):
content_type = ContentType.objects.get(
model=validated_data['item_type'])
user = User.objects.get(email=validated_data['customer_email'])
order_item = OrderItem.objects.create(
customer=user,
content_type=content_type,
object_id=validated_data['object_id'])
return order_item
class FlowResultsResponseSerializer(serializers.Serializer):
"""
FlowResultsResponseSerializer for handling publishing of Flow Results
Response package.
"""
id = serializers.CharField() # pylint: disable=invalid-name
responses = serializers.ListField()
duplicates = serializers.IntegerField(read_only=True)
class JSONAPIMeta: # pylint: disable=old-style-class,no-init,R0903
"""
JSON API metaclass.
"""
resource_name = 'responses'
def create(self, validated_data):
duplicates = 0
request = self.context['request']
responses = validated_data['responses']
uuid = UUID(validated_data['id'])
xform = get_object_or_404(XForm,
Q(uuid=str(uuid)) | Q(uuid=uuid.hex),
deleted_at__isnull=True)
for submission in parse_responses(responses):
xml_file = BytesIO(
dict2xform(submission, xform.id_string,
'data').encode('utf-8'))
error, _instance = safe_create_instance(request.user.username,
xml_file, [], None,
request)
if error and error.status_code != 202:
raise serializers.ValidationError(error)
if error and error.status_code == 202:
duplicates += 1
return FlowResultsResponse(xform.uuid, responses, duplicates)
def update(self, instance, validated_data):
pass
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 GenericForeignKeySerializer(ContentTypeFieldSerializer):
"""
Serializer class that provides fields and methods for dealing
with generic foreign keys
"""
target_id = serializers.IntegerField(source='target_object_id',
required=False)
def validate(self, attrs):
"""
Validate target id
"""
if self.instance is not None:
# we are doing an update
target_id = attrs.get('target_object_id',
self.instance.target_object_id)
target_model_contenttype = attrs.get(
'target_content_type', self.instance.target_content_type)
else:
# we are creating a new object
target_id = attrs.get('target_object_id')
target_model_contenttype = attrs.get('target_content_type')
# Target_id is not required as such this may be none
# If target_id is none there is no need to validate it
if target_id is not None:
target_model_class = target_model_contenttype.model_class()
try:
target_model_class.objects.get(pk=target_id)
except target_model_class.DoesNotExist:
raise serializers.ValidationError(
{'target_id': TARGET_DOES_NOT_EXIST})
return attrs
return attrs
class ItemSerializer(serializers.ModelSerializer):
sale = get_ResourceRelatedField('items', 'sales', queryset=Sale.objects)
group = get_ResourceRelatedField('items', 'itemgroups', queryset=ItemGroup.objects)
usertype = get_ResourceRelatedField('items', 'usertypes', queryset=UserType.objects)
fields = get_ResourceRelatedField('items', 'fields', queryset=Field.objects, many=True, required=False)
quantity_left = serializers.IntegerField(read_only=True)
included_serializers = {
'itemfields': 'sales.serializers.ItemFieldSerializer',
'sale': 'sales.serializers.SaleSerializer',
'itemgroup': ItemGroupSerializer,
'usertype': UserTypeSerializer,
}
class Meta:
model = Item
fields = '__all__' # DEBUG
# fields = ('id', 'name', 'description', 'remaining_quantity',
# 'initial_quantity','sale_id', 'itemspecifications')
class JSONAPIMeta:
# included_resources = ['itemgroup', 'sale', 'usertype']
pass
class DummySerializer(serializers.Serializer):
body = serializers.CharField()
id = serializers.IntegerField()
class CustomModelSerializer(serializers.Serializer):
body = serializers.CharField()
id = serializers.IntegerField()
class ProjectSerializer(serializers.Serializer):
id = serializers.IntegerField()
name = serializers.CharField()
class RoomNodeInstallationSerializer(serializers.HyperlinkedModelSerializer):
included_serializers = {
"node": "core.serializers.NodeSerializer",
"room": "core.serializers.RoomSerializer",
# "timeseries": "core.serializers.TimeseriesSerializer",
}
node = ResourceRelatedField(
queryset=Node.objects.all(),
related_link_url_kwarg="installation_pk",
related_link_view_name="installation-related-node",
)
room = ResourceRelatedField(
queryset=Room.objects.all(), related_link_view_name="installation-related"
)
to_timestamp_s = serializers.IntegerField(required=False)
# Image of the installation (optional). Handle upload in a separate serializer.
image = serializers.ImageField(required=False, read_only=True)
# Additional fields to merge the node installation with its samples.
timeseries = serializers.ListField(child=SimpleSampleSerializer(), read_only=True)
query_timestamp_s = serializers.IntegerField(read_only=True)
sample_count = serializers.IntegerField(read_only=True)
url = serializers.HyperlinkedIdentityField(view_name="installation-detail")
class Meta:
model = RoomNodeInstallation
fields = [
"room",
"node",
"timeseries",
"query_timestamp_s",
"from_timestamp_s",
"to_timestamp_s",
"sample_count",
"description",
"image",
"is_public",
"url",
]
def __init__(self, *args, **kwargs):
# Don't pass the "include_timeseries" arg up to the superclass
include_timeseries = kwargs.pop("include_timeseries", None)
# Instantiate the superclass normally
super().__init__(*args, **kwargs)
if not include_timeseries:
self.fields.pop("timeseries")
def get_owner(self):
"""Return the owner of the resource, once data is validated."""
room = self.validated_data["room"]
site = room.site
owner = site.operator
return owner
def validate(self, attrs):
"""
Ensure that the node is owned by the same organization as the room.
"""
logger.debug(
"For a new or updated installation, validate that node and room belong to the same owner."
)
try:
room = attrs["room"]
node = attrs["node"]
except KeyError:
raise serializers.ValidationError(
"Both the Room reference and the node reference must be provided."
)
if room.site.operator != node.owner:
raise serializers.ValidationError(
"In an installation, Node and room must belong to the same owner."
)
return attrs
