class TestContentDetailImageSerializer(ContentSerializer):
"""Serializes the ExternalLink model."""
detail_image = ImageFieldSerializer()
class Meta:
model = TestContentDetailImage
class SectionSerializer(serializers.ModelSerializer):
query = JSONField(required=False, default={})
section_logo = ImageFieldSerializer(required=False, allow_null=True)
class Meta:
model = Section
class NotificationSerializer(serializers.ModelSerializer):
"""Basic model serializer for notifications.Notification."""
image = ImageFieldSerializer(required=False, allow_null=True)
class Meta:
model = Notification
class PollSerializer(ContentSerializer):
poll_image = ImageFieldSerializer(required=False)
answers = AnswerSerializer(many=True, read_only=True)
class Meta:
model = Poll
exclude = ('thumbnail_override', )
class AnswerSerializer(serializers.ModelSerializer):
answer_image = ImageFieldSerializer(
required=False,
allow_null=True,
)
poll = serializers.PrimaryKeyRelatedField(queryset=Poll.objects.all(),
required=False)
class Meta:
model = Answer
fields = (
'id',
'answer_text',
'poll',
'answer_image',
)
class VideohubVideoSerializer(serializers.ModelSerializer):
id = serializers.IntegerField()
image = ImageFieldSerializer(allow_null=True, default={})
hub_url = serializers.CharField(source="get_hub_url", read_only=True)
embed_url = serializers.CharField(source="get_embed_url", read_only=True)
api_url = serializers.CharField(source="get_api_url", read_only=True)
channel_id = serializers.IntegerField()
class Meta:
model = VideohubVideo
def save(self, **kwargs):
"""
Save and return a list of object instances.
"""
validated_data = [
dict(list(attrs.items()) + list(kwargs.items()))
for attrs in self.validated_data
]
if "id" in validated_data:
ModelClass = self.Meta.model
try:
self.instance = ModelClass.objects.get(id=validated_data["id"])
except ModelClass.DoesNotExist:
pass
return super(VideohubVideoSerializer, self).save(**kwargs)
def to_internal_value(self, data):
# Channel info passed as nested object, but we just store integer ID
channel = data.get('channel')
if channel and 'id' in channel:
data['channel_id'] = channel['id']
return super(VideohubVideoSerializer, self).to_internal_value(data)
class CampaignSerializer(serializers.ModelSerializer):
sponsor_logo = ImageFieldSerializer(required=False)
pixels = CampaignPixelField(many=True)
start_date = serializers.DateTimeField()
end_date = serializers.DateTimeField()
class Meta:
model = Campaign
def create(self, validated_data):
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
instance = ModelClass.objects.create(**validated_data)
# Save many-to-many relationships after the instance is created.
if many_to_many:
pixel_serializer = CampaignPixelField(data=many_to_many["pixels"],
many=True)
if not pixel_serializer.is_valid():
raise Exception("Ivalid pixel data")
pixel_serializer.save(campaign=instance)
return instance
def update(self, instance, validated_data):
pixels_data = validated_data.pop("pixels")
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
if pixels_data:
existing_pixel_ids = list(
instance.pixels.values_list("id", flat=True))
for pixel_data in pixels_data:
if pixel_data.get("id") in existing_pixel_ids:
existing_pixel_ids.remove(pixel_data["id"])
pixel_serializer = CampaignPixelField(data=pixels_data, many=True)
if not pixel_serializer.is_valid():
raise Exception("Ivalid pixel data")
pixel_serializer.save(campaign=instance)
for pixel_id in existing_pixel_ids:
print(pixel_id)
# We need to remove these...
CampaignPixel.objects.get(id=pixel_id).delete()
else:
for pixel in instance.pixels.all():
pixel.delete()
return instance
class ContentSerializer(serializers.ModelSerializer):
polymorphic_ctype = ContentTypeField(source="polymorphic_ctype_id",
read_only=True)
tags = TagField(allow_null=True,
many=True,
queryset=Tag.objects.all(),
required=False)
feature_type = FeatureTypeField(allow_null=True,
queryset=FeatureType.objects.all(),
required=False)
authors = AuthorField(
many=True,
allow_null=True,
queryset=get_user_model().objects.filter(**AUTHOR_FILTER),
required=False)
thumbnail = ImageFieldSerializer(allow_null=True, read_only=True)
first_image = ImageFieldSerializer(allow_null=True, read_only=True)
thumbnail_override = ImageFieldSerializer(allow_null=True, required=False)
absolute_url = serializers.ReadOnlyField(source="get_absolute_url")
status = serializers.ReadOnlyField(source="get_status")
template_type = serializers.SlugRelatedField(
slug_field="slug",
allow_null=True,
queryset=TemplateType.objects.all(),
required=False)
class Meta:
model = Content
def create(self, validated_data):
ModelClass = self.Meta.model
# Remove many-to-many relationships from validated_data.
# They are not valid arguments to the default `.create()` method,
# as they require that the instance has already been saved.
info = model_meta.get_field_info(ModelClass)
many_to_many = {}
for field_name, relation_info in info.relations.items():
if relation_info.to_many and (field_name in validated_data):
many_to_many[field_name] = validated_data.pop(field_name)
try:
instance = ModelClass.objects.create(**validated_data)
except TypeError as exc:
msg = ('Got a `TypeError` when calling `%s.objects.create()`. '
'This may be because you have a writable field on the '
'serializer class that is not a valid argument to '
'`%s.objects.create()`. You may need to make the field '
'read-only, or override the %s.create() method to handle '
'this correctly.\nOriginal exception text was: %s.' %
(ModelClass.__name__, ModelClass.__name__,
self.__class__.__name__, exc))
raise TypeError(msg)
# Save many-to-many relationships after the instance is created.
if many_to_many:
for field_name, value in many_to_many.items():
setattr(instance, field_name, value)
return instance
def update(self, instance, validated_data):
if getattr(settings, "CONTRIBUTIONS", {}).get("BYLINE_REPORT", False):
check_and_run_send_byline_email.delay(
instance.pk, validated_data.get("authors", []))
return super(ContentSerializer, self).update(instance, validated_data)
class EntrySerializer(BaseEntrySerializer, CopySerializer):
title = RichTextField(required=False, field_size="short")
image = ImageFieldSerializer(required=False, default=None, allow_null=True)
class GuideToEntrySerializer(BaseEntrySerializer, CopySerializer):
image = ImageFieldSerializer(required=False, default=None, allow_null=True)
class GuideToParentSerializer(serializers.Serializer):
copy = RichTextField(required=False, field_size="long")
sponsor_brand_messaging = serializers.CharField(required=False)
sponsor_product_shot = ImageFieldSerializer(
required=False, label="Sponsor Product Shot (1x1 Image)")
class ImageSerializerMixin(serializers.Serializer):
image = ImageFieldSerializer(required=False, allow_null=True)
class Meta:
abstract = True
class RecircContentSerializer(serializers.Serializer):
id = serializers.IntegerField()
thumbnail = ImageFieldSerializer(allow_null=True, read_only=True)
slug = serializers.CharField()
title = serializers.CharField()
feature_type = FeatureTypeField(queryset=FeatureType.objects.all())