class SnippetFileSerializer(BaseSerializer):
pk = IntegerField(read_only=False, required=False)
language = PrimaryKeyRelatedField(queryset=Language.objects.all())
class Meta:
model = File
fields = (
'pk',
'url',
'language',
'name',
'content',
'created_date',
'modified_date',
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if USER_ID_ATTRIBUTE == 'id':
# id field is read_only by default, that needs to be changed
# so that the field will be validated
self.fields['id'] = IntegerField(label='ID')
else:
# if the user id attribute isn't id, modify the id field to point to the right attribute.
# the field needs to be of the right type so that validation works correctly
model_field_type = type(
get_user_model()._meta.get_field(USER_ID_ATTRIBUTE))
serializer_field = self.serializer_field_mapping[model_field_type]
self.fields['id'] = serializer_field(source=USER_ID_ATTRIBUTE,
label='ID')
class ToppingSerializer(DynamicModelSerializer):
class Meta:
model = Topping
name = 'topping'
fields = (
'id',
'name',
'taxed_cost',
'pizzas',
) + (('metadata', ) if Topping.metadata else ())
defered_fields = ('pizzas', )
pizzas = DynamicRelationField('PizzaSerializer', many=True, required=False)
taxed_cost = IntegerField(source='cost')
class CommentSerializer(StandardizedModelSerializer):
contact = ContactSerializer()
user = IntegerField(source='user_id', required=False)
def create(self, validated_data):
if 'user' not in validated_data:
validated_data['user'] = self.context['request'].user
return super().create(validated_data)
class Meta:
model = Comment
read_only_fields = ('user', )
fields = ('_uid', '_type', '_version', 'created', 'updated', 'user',
'contact', 'message')
class EncodedVideoSerializer(serializers.ModelSerializer):
"""
Serializer for EncodedVideo object.
Uses the profile_name as it's profile value instead of a Profile object.
"""
profile = serializers.SlugRelatedField(slug_field="profile_name",
queryset=Profile.objects.all())
# Django Rest Framework v3 doesn't enforce minimum values for
# PositiveIntegerFields, so we need to specify the min value explicitly.
bitrate = IntegerField(min_value=0)
file_size = IntegerField(min_value=0)
# Django Rest Framework v3 converts datetimes to unicode by default.
# Specify format=None to leave them as datetimes.
created = DateTimeField(required=False, format=None)
modified = DateTimeField(required=False, format=None)
class Meta:
model = EncodedVideo
fields = (
"created",
"modified",
"url",
"file_size",
"bitrate",
"profile",
)
def get_identity(self, data):
"""
This hook is required for bulk update.
We need to override the default, to use the slug as the identity.
"""
return data.get('profile', None)
class PaymentSerializer(Serializer):
order = IntegerField()
source_type = CharField()
def validate_order(self, value):
o = Order.objects.get(id=value)
if o.status != 'pending':
raise ValidationError('Invalid order status: %s' % o.status)
return o
def validate_source_type(self, value):
if value not in Fascade.source_type_method_class_dict:
raise ValidationError('Payment type: %s not suppported' % value)
return value
class SubmissionSerializer(serializers.ModelSerializer):
""" Submission Serializer. """
# Django Rest Framework v3 uses the Django setting `DATETIME_FORMAT`
# when serializing datetimes. This differs from v2, which always
# returned a datetime. To preserve the old behavior, we explicitly
# set `format` to None.
# http://www.django-rest-framework.org/api-guide/fields/#datetimefield
submitted_at = DateTimeField(format=None, required=False)
created_at = DateTimeField(format=None, required=False)
# Django Rest Framework v3 apparently no longer validates that
# `PositiveIntegerField`s are positive!
attempt_number = IntegerField(min_value=0)
# Prevent Django Rest Framework from converting the answer (dict or str)
# to a string.
answer = RawField()
team_submission_uuid = serializers.SlugRelatedField(
slug_field='uuid',
source='team_submission',
queryset=TeamSubmission.objects.all(),
allow_null=True,
required=False,
)
def validate_answer(self, value):
"""
Check that the answer is JSON-serializable and not too long.
"""
# Check that the answer is JSON-serializable
try:
serialized = json.dumps(value)
except (ValueError, TypeError):
raise serializers.ValidationError(
"Answer value must be JSON-serializable")
# Check the length of the serialized representation
if len(serialized) > Submission.MAXSIZE:
raise serializers.ValidationError("Maximum answer size exceeded.")
return value
class Meta:
model = Submission
fields = ('uuid', 'student_item', 'attempt_number', 'submitted_at',
'created_at', 'answer', 'team_submission_uuid')
class Meta:
model = Order
fields = [
'billing_profile',
'order_id',
'cart',
'status',
'timestamp',
'shipping_total',
'cart_total',
'tax_total',
'total',
'total_in_paise',
]
total_in_paise = IntegerField(source='total_in_paise')
class TaskDetailSerializer(ModelSerializer):
descriptions = DescriptionSerializer(many=True, partial=True)
comments_count = IntegerField(source='comments.count', read_only=True)
users_commented_count = SerializerMethodField()
class Meta:
model = Task
fields = ('id', 'title', 'status', 'project', 'owner',
'assignee', 'descriptions', 'comments_count',
'users_commented_count')
def get_users_commented_count(self, obj):
count = Task.objects.values('id').annotate(
user_count=Count('comments__user', distinct=True))\
.filter(id=obj.id).first()
return count['user_count']
class MealUserSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=CurrentUserDefault())
exceeded_calories_per_day = serializers.ReadOnlyField()
calories = IntegerField(min_value=0)
class Meta:
model = Meal
fields = (
'date',
'time',
'text',
'calories',
'user',
'id',
'exceeded_calories_per_day',
)
class Meta:
_list_fields = _detail_fields = [
'id', 'field_type', 'dynamic_with_types'
]
_override_list_fields = _override_detail_fields = {
'dynamic_with_types':
fields.DynamicJsonTypeField(
field='field_type',
types={
'serializer': SomeSerializer(),
'many_serializers': SomeSerializer(many=True),
'integer': IntegerField(max_value=1337),
'boolean': 'boolean',
'image': fields.NamedBinaryImageInJsonField(),
}),
}
def get_post_fields(self):
if self.instance is None:
return {
"length": IntegerField(),
"breadth": IntegerField(),
"height": IntegerField(),
"created_by_id": IntegerField(required=True)
}
else:
return {
"length": IntegerField(),
"breadth": IntegerField(),
"height": IntegerField(),
}
def add_optional_fields(self, target):
# dynamically add optional fields - see https://www.django-rest-framework.org/api-guide/serializers/#dynamically-modifying-fields .
# note: we exclude 'niceties' like allow_null, help_text, required, style, etc.
# first clear all optional contexts for possible re-use by ListSerializer (many=True)
if 'range' in self.context:
del self.context['range']
if 'cats' in self.context:
del self.context['cats']
# add step_ahead_increment
if target.is_step_ahead and (target.step_ahead_increment is not None):
self.fields['step_ahead_increment'] = IntegerField()
# add unit
if target.unit is not None:
self.fields['unit'] = CharField()
# add range
data_type = target.data_types()[0] # the first is the preferred one
target_ranges_qs = target.ranges # target.value_i, target.value_f
if target_ranges_qs.count() != 0: # s/b exactly 2
value_column = 'value_i' if data_type == Target.INTEGER_DATA_TYPE else 'value_f'
target_ranges = target_ranges_qs.values_list(value_column,
flat=True)
target_ranges = sorted(target_ranges)
self.context['range'] = [target_ranges[0], target_ranges[1]]
self.fields['range'] = serializers.SerializerMethodField(
'get_range')
# add cats
cats_values = target.cats_values()
if cats_values and (target.type != Target.BINARY_TARGET_TYPE
): # skip implicit binary - added automatically
if data_type == Target.DATE_DATA_TYPE:
cats_values = [
cat_date.strftime(YYYY_MM_DD_DATE_FORMAT)
for cat_date in cats_values
]
self.context['cats'] = sorted(cats_values)
elif target.type in [
Target.NOMINAL_TARGET_TYPE, Target.DATE_TARGET_TYPE
]:
# handle the case of required cats list that must have come in but was empty
self.context['cats'] = []
if 'cats' in self.context:
self.fields['cats'] = serializers.SerializerMethodField('get_cats')
class FinancialAidSerializer(serializers.Serializer):
"""
Serializer for Financial Aid objects
"""
original_income = FloatField(min_value=0)
original_currency = CharField()
program_id = IntegerField()
def validate(self, data):
"""
Validators for this serializer
"""
data["program"] = get_object_or_404(Program, pk=data["program_id"])
if not data["program"].financial_aid_availability:
raise ValidationError("Financial aid not available for this program.")
if not ProgramEnrollment.objects.filter(program=data["program"], user=self.context["request"].user).exists():
raise ValidationError("User not in program.")
return data
def save(self):
"""
Override save method
"""
if self.validated_data["original_currency"] != "USD":
raise ValidationError("Only USD supported currently")
user = self.context["request"].user
tier_program = determine_tier_program(self.validated_data["program"], self.validated_data["original_income"])
financial_aid = FinancialAid.objects.create(
original_income=self.validated_data["original_income"],
original_currency=self.validated_data["original_currency"],
tier_program=tier_program,
user=user,
income_usd=self.validated_data["original_income"],
country_of_income=user.profile.country,
date_exchange_rate=datetime.datetime.now()
)
if determine_auto_approval(financial_aid) is True:
financial_aid.status = FinancialAidStatus.AUTO_APPROVED
else:
financial_aid.status = FinancialAidStatus.PENDING_DOCS
financial_aid.save()
# Add auditing here
return financial_aid
class SourceVersionDetailSerializer(SourceCreateOrUpdateSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='version')
short_code = CharField(source='mnemonic')
owner = CharField(source='parent_resource')
owner_type = CharField(source='parent_resource_type')
owner_url = CharField(source='parent_url')
versions = IntegerField(source='num_versions')
created_on = DateTimeField(source='created_at')
updated_on = DateTimeField(source='updated_at')
created_by = CharField(source='created_by.username', read_only=True)
updated_by = DateTimeField(source='updated_by.username', read_only=True)
supported_locales = ListField(required=False, allow_empty=True)
class Meta:
model = Source
lookup_field = 'mnemonic'
fields = (
'type',
'uuid',
'id',
'short_code',
'name',
'full_name',
'description',
'source_type',
'custom_validation_schema',
'public_access',
'default_locale',
'supported_locales',
'website',
'url',
'owner',
'owner_type',
'owner_url',
'versions',
'created_on',
'updated_on',
'created_by',
'updated_by',
'extras',
'external_id',
'versions_url',
'version',
'concepts_url',
)
class Ad(Document):
"""
Advertisement impression on Users mobile device.
Represents the base class for possible advertisement
impression types.
"""
url = StringField(required=False)
display_url = StringField(required=False)
# TBD (Sonu): Collection of product urls
final_urls = StringField(required=False)
mobile_urls = StringField(required=False)
app_urls = StringField(required=False)
# Customer trusted tracking
thirdparty_tracking_url = StringField(required=False)
# AdWise tracking
adwise_tracking_url = StringField(required=False)
# Location tag
# TBD: Make tags very generic by nature.
# For example, tags should be search'able- location,
# genre, keywords etc.
ad_location_tag = GeoPointField(required=False)
# Meta
ad_type = StringField(required=False)
custom_parameters = DictField(required=False)
device_preference = IntegerField(required=False)
# Campaign this Ad refers to.
campaign = ReferenceField('Campaign', required=False)
# List of extension
offerex = ListField(ReferenceField('OfferExtension'), required=False)
socialex = ListField(ReferenceField('SocialExtension'), required=False)
# reference - DRF field
url = fields.URLField(source='get_absolute_url', read_only=False)
# meta
meta = {'allow_inheritance': True}
class Meta:
abstract = True
def get_absolute_url(self):
return "/mediacontent/ads/%i/" % self.id
class PudoSerializer(serializers.SimpleSerializer):
name = CharField(blank=True)
zipcode = CharField(blank=True)
country = CharField(blank=True)
city = CharField(blank=True)
address = CharField(blank=True)
distance = DecimalField(blank=True)
is_open = BooleanField(blank=True)
lat = DecimalField(blank=True)
lng = DecimalField(blank=True)
site_id = IntegerField(blank=True)
pudo_id = CharField(blank=True)
price = DecimalField(max_digits=10,
decimal_places=2,
required=False,
blank=True)
opening_dates = PudoOpeningDateSerializer(many=True, blank=True)
class PaymentItemSerializer(ModelSerializer):
contractId = IntegerField(source='contract.id')
class Meta:
model = PaymentItem
exclude = ('contract', )
# Changes to `create()` and `update()` are needed to support `contractId` as field name instead of `contract_id`
# which is default for Django Rest Framework
def create(self, validated_data):
return Contract.objects.get(
pk=validated_data['contract']['id']).items.create(**validated_data)
def update(self, instance, validated_data):
validated_data['contract'] = Contract.objects.get(
pk=validated_data['contract']['id'])
return super().update(instance, validated_data)
class PerPageSerializerBase(Serializer):
per_page = IntegerField(default=DEFAULT_PAGE_SIZE, allow_null=True,
help_text='Количество элементов на странице')
def __init__(
self, max_per_page: int = 200,
*args: typing.Any, **kwargs: typing.Any,
) -> None:
super().__init__(*args, **kwargs)
self.max_per_page = max_per_page
def validate_per_page(self, value: typing.Optional[int]) -> int:
if value is None:
return DEFAULT_PAGE_SIZE
if value > self.max_per_page:
return self.max_per_page
return value
class ShippingPointListParamsSerializer(serializers.SimpleSerializer):
lat = DecimalField(required=False, default=None)
lng = DecimalField(required=False, default=None)
address = CharField(required=False)
search_type = IntegerField(required=True)
def perform_validation(self, attrs):
super(ShippingPointListParamsSerializer,
self).perform_validation(attrs)
position_in_params = 'lng' in attrs and 'lat' in attrs
address_in_params = 'address' in attrs
if not any([position_in_params, address_in_params]):
msg = _(u'Latitude\longitude or address are required')
self._errors['lng'] = msg
self._errors['lat'] = msg
self._errors['address'] = msg
return attrs
class MealAdminSerializer(serializers.ModelSerializer):
exceeded_calories_per_day = serializers.ReadOnlyField()
calories = IntegerField(min_value=0)
username = serializers.ReadOnlyField()
class Meta:
model = Meal
fields = (
'date',
'time',
'text',
'calories',
'user',
'id',
'exceeded_calories_per_day',
'username',
)
class BookmarkManualSerializer(Serializer):
id = IntegerField(read_only=True)
link = URLField(required=False, max_length=1000)
def create(self, validated_data):
"""
Create and return a new `Bookmark` instance, given the validated data.
"""
return Bookmark.objects.create(**validated_data)
def update(self, instance, validated_data):
"""
Update and return an existing `Snippet` instance, given the validated data.
"""
instance.url = validated_data.get('url', instance.url)
instance.save()
return instance
class CommentSerializer(StandardizedModelSerializer):
contact = PrimaryKeyModelSerializerField(
ContactSerializer,
allowed_objects=lambda serializer: serializer.Meta.model.objects.all())
user = IntegerField(source='user_id', required=False)
def create(self, validated_data):
if 'user' not in validated_data:
validated_data['user'] = self.context['request'].user
return super().create(validated_data)
class Meta:
model = Comment
read_only_fields = ('user',)
fields = (
'_uid', '_type', '_version', 'user', 'contact', 'message')
class CollectionCreateSerializer(CollectionCreateOrUpdateSerializer):
type = CharField(source='resource_type', read_only=True)
uuid = CharField(source='id', read_only=True)
id = CharField(required=True, validators=[RegexValidator(regex=NAMESPACE_REGEX)], source='mnemonic')
short_code = CharField(source='mnemonic', read_only=True)
name = CharField(required=True)
full_name = CharField(required=False)
description = CharField(required=False, allow_blank=True)
collection_type = CharField(required=False)
custom_validation_schema = CharField(required=False, allow_blank=True)
public_access = ChoiceField(required=False, choices=ACCESS_TYPE_CHOICES)
default_locale = CharField(required=False, allow_blank=True)
supported_locales = ListField(required=False, allow_empty=True)
website = CharField(required=False, allow_blank=True)
url = CharField(read_only=True)
versions_url = CharField(read_only=True)
concepts_url = CharField(read_only=True)
mappings_url = CharField(read_only=True)
owner = CharField(source='parent_resource', read_only=True)
owner_type = CharField(source='parent_resource_type', read_only=True)
owner_url = CharField(source='parent_url', read_only=True)
versions = IntegerField(source='num_versions', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
created_by = CharField(source='owner', read_only=True)
updated_by = CharField(read_only=True)
extras = JSONField(required=False)
external_id = CharField(required=False, allow_blank=True)
user_id = PrimaryKeyRelatedField(required=False, queryset=UserProfile.objects.all(), allow_null=True)
organization_id = PrimaryKeyRelatedField(required=False, queryset=Organization.objects.all(), allow_null=True)
version = CharField(default=HEAD)
def create(self, validated_data):
collection = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Collection.persist_new(collection, user)
self._errors.update(errors)
return collection
def create_version(self, validated_data):
collection = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Collection.persist_new_version(collection, user)
self._errors.update(errors)
return collection
class MappingDetailSerializer(MappingListSerializer):
type = CharField(source='resource_type', read_only=True)
uuid = CharField(source='id', read_only=True)
extras = JSONField(required=False, allow_null=True)
created_by = CharField(source='created_by.username', read_only=True)
updated_by = CharField(source='created_by.username', read_only=True)
parent_id = IntegerField(required=True, write_only=True)
map_type = CharField(required=True)
to_concept_url = CharField(required=False)
from_concept_url = CharField(required=False)
from_concept = ConceptDetailSerializer()
to_concept = ConceptDetailSerializer()
from_source = SourceDetailSerializer()
to_source = SourceDetailSerializer()
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
class Meta:
model = Mapping
fields = MappingListSerializer.Meta.fields + (
'type',
'uuid',
'extras',
'created_on',
'updated_on',
'created_by',
'updated_by',
'parent_id',
'internal_reference_id',
)
def create(self, validated_data):
mapping = Mapping.persist_new(data=validated_data,
user=self.context.get('request').user)
if mapping.errors:
self._errors.update(mapping.errors)
return mapping
def update(self, instance, validated_data):
errors = Mapping.create_new_version_for(
instance, validated_data,
self.context.get('request').user)
if errors:
self._errors.update(errors)
return instance
class UserPageSerializer(serializers.ModelSerializer):
owner = PhotoPageSerializer(many=True)
profile = FollowPageSerializer()
count_followers = IntegerField(source='followed_by.count')
photo = AvatarSerializer()
class Meta:
model = User
fields = (
'id',
'username',
'bio',
'count_followers',
'profile',
'photo',
'owner',
)
class CursorUUIDUncountedResponseSerializer(Serializer):
after = UUIDField(required=False,
allow_null=True,
help_text=_('After UUID'))
before = UUIDField(required=False,
allow_null=True,
help_text=_('Before UUID'))
per_page = IntegerField(
required=True,
max_value=DEFAULT_MAX_PAGE_SIZE,
help_text=_('Page size'),
)
has_next = BooleanField(help_text=_('Has result next page'))
url = CharField(help_text=_('Current page URL'))
after_url = CharField(help_text=_('URL of page after cursor position'),
allow_null=True)
before_url = CharField(help_text=_('URL of page before cursor position'),
allow_null=True)
class TaskSerializer(serializers.ModelSerializer):
text = CharField()
story_points = IntegerField()
start_date = DateTimeField()
end_date = DateTimeField()
executor = IdProfileSerializer(read_only=True)
class Meta:
model = Message
fields = [
'id',
'text',
'story_points',
'start_date',
'end_date',
'executor'
]
class CallEndSerializer(Serializer):
'''
Serializes a call end payload and returns a updated serialized
`CompletedCall`
if valid input.
'''
call_id = IntegerField(required=True)
timestamp = DateTimeField(required=True)
def save(self):
'''
Complete with validated data and returns a serialized `CompletedCall`.
'''
call = NotCompletedCall.objects.complete(
call_id=self.validated_data['call_id'],
ended_at=self.validated_data['timestamp'])
return CompletedCallSerializer(call).data
class OnlineMediaSource(MediaSource):
"""
Online media source represents a virtual source that can be
specified with a floating range of coverage.
Cloud media source have multiple locations to deliver ads in,
all simultaneously.
For example, online , etc.
"""
type = 'online'
home_url = StringField(required=True)
verification_url = StringField(required=True)
category = StringField(required=True)
# geo-fences
fence = GeoPointField(required=True)
radius = IntegerField(default=100)
def get_absolute_url(self):
return "/mediasource/online/%i/" % self.id
