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