class ActivitySerializer(serializers.ModelSerializer): actor = GenericRelatedField({ User: UserSerializer(), Post: PostSerializer(), Destination: DestinationSerializer(), Address: AddressSerializer() }) target = GenericRelatedField({ User: UserSerializer(), Post: PostSerializer(), Destination: DestinationSerializer(), Address: AddressSerializer() }) action_object = GenericRelatedField({ User: UserSerializer(), Post: PostSerializer(), Destination: DestinationSerializer(), Address: AddressSerializer() }) class Meta: model = Activity fields = [ 'id', 'verb', 'created', 'address', 'actor', 'actor_content_type', 'target', 'action_object', 'action_object_content_type' ] def to_representation(self, instance): self.fields['address'] = DAddressSerializer(read_only=True) return super(ActivitySerializer, self).to_representation(instance)
def test_subclass_uses_registered_parent(self): tagged_item = GenericRelatedField({ Note: NoteSerializer(), }, read_only=True) # NoteProxy instance should use the NoteSerializer, # since no more specific serializer is registered proxied = NoteProxy.objects.get(pk=self.note.pk) serializer = tagged_item.get_serializer_for_instance(proxied) self.assertIsInstance(serializer, NoteSerializer)
class TagSerializer(serializers.ModelSerializer): fields = { Bookmark: BookmarkSerializer(), Note: NoteSerializer(), } first = GenericRelatedField(fields) second = GenericRelatedField(fields) class Meta: model = Tag
def test_deprecated_method_called(self): f = GenericRelatedField({ Bookmark: serializers.HyperlinkedRelatedField( view_name='bookmark-detail', queryset=Bookmark.objects.all()), }) with warnings.catch_warnings(record=True) as w: f.determine_serializer_for_data('http://testserver/bookmark/1/') self.assertEqual(len(w), 1) self.assertIs(w[0].category, DeprecationWarning)
def test_subclass_uses_registered_subclass(self): tagged_item = GenericRelatedField({ Note: NoteSerializer(), NoteProxy: NoteProxySerializer(), }, read_only=True) # NoteProxy instance should use the NoteProxySerializer in # preference to the NoteSerializer proxied = NoteProxy.objects.get(pk=self.note.pk) serializer = tagged_item.get_serializer_for_instance(proxied) self.assertIsInstance(serializer, NoteProxySerializer) # But Note instance should use the NoteSerializer serializer = tagged_item.get_serializer_for_instance(self.note) self.assertIsInstance(serializer, NoteSerializer)
class RatingSerializer(serializers.ModelSerializer): added_by = serializers.HyperlinkedRelatedField( many=False, read_only=True, view_name='api:profile-detail') rated_object = GenericRelatedField({ Statement: serializers.HyperlinkedRelatedField( queryset=Statement.objects.all(), view_name='api:statement-detail', ), StatementLink: serializers.HyperlinkedRelatedField( queryset=StatementLink.objects.all(), view_name='api:statementlink-detail', ), Profile: serializers.HyperlinkedRelatedField( queryset=Profile.objects.all(), view_name='api:profile-detail', ), }) date_added = serializers.ReadOnlyField() class Meta: model = Rating fields = ('rated_object', 'rating', 'rating_type', 'added_by', 'date_added')
class ModerationPenaltyModeratedObjectSerializer(serializers.ModelSerializer): category = ModerationCategorySerializer() content_object = GenericRelatedField({ Post: ModerationPenaltyModeratedObjectPostSerializer(), PostComment: ModerationPenaltyModeratedObjectPostCommentSerializer(), Community: ModerationPenaltyModeratedObjectCommunitySerializer(), User: ModerationPenaltyModeratedObjectUserSerializer(), }) class Meta: model = ModeratedObject fields = ( 'id', 'object_type', 'object_id', 'content_object', 'verified', 'status', 'description', 'category', )
class RecordSerializer(serializers.ModelSerializer): content_object = GenericRelatedField({ Person: PersonSerializer(), Respondent: RespondentSerializer() }) average_indexed_monthly_covered_earning = MoneySerializer() basic_primary_insurance_amount = MoneySerializer() wep_primary_insurance_amount = MoneySerializer() average_indexed_monthly_non_covered_earning = MoneySerializer() monthly_non_covered_pension = MoneySerializer() wep_reduction = MoneySerializer() final_primary_insurance_amount = MoneySerializer() benefit = MoneySerializer() government_pension_offset = MoneySerializer() spousal_insurance_benefit = MoneySerializer() survivor_insurance_benefit = MoneySerializer() class Meta: model = Record fields = ('id', 'object_id', 'content_object', 'earliest_retirement_age', 'normal_retirement_age', 'average_indexed_monthly_covered_earning', 'basic_primary_insurance_amount', 'wep_primary_insurance_amount', 'average_indexed_monthly_non_covered_earning', 'monthly_non_covered_pension', 'wep_reduction', 'final_primary_insurance_amount', 'max_delay_retirement_credit', 'delay_retirement_credit', 'max_early_retirement_reduction', 'early_retirement_reduction', 'benefit', 'government_pension_offset', 'spousal_insurance_benefit', 'survivor_insurance_benefit')
class SimpleActivitySerializer(serializers.ModelSerializer): action = serializers.CharField(source='verb') activity_type = serializers.SerializerMethodField() activity = GenericRelatedField( { get_user_model(): SimpleUserSerializer(), Channel: ChannelSerializer(), ChannelUser: ChannelUserSerializer(), Message: MessageSerializer(), Comment: CommentSerializer(), Upload: UploadSerializer(), Connection: ConnectionSerializer(), Task: SimpleTaskSerializer(), Application: ApplicationSerializer(), Participation: ParticipationSerializer(), Estimate: SimpleEstimateSerializer(), Quote: SimpleQuoteSerializer(), ProgressEvent: SimpleProgressEventSerializer(), ProgressReport: ProgressReportSerializer(), Integration: SimpleIntegrationSerializer(), IntegrationActivity: SimpleIntegrationActivitySerializer() }, source='action_object') class Meta: model = Action exclude = ('verb', 'actor_object_id', 'actor_content_type', 'action_object_object_id', 'action_object_content_type', 'target_object_id', 'target_content_type') def get_activity_type(self, obj): return get_instance_type(obj.action_object)
class GetNotificationsNotificationSerializer(serializers.ModelSerializer): content_object = GenericRelatedField({ PostCommentNotification: PostCommentNotificationSerializer(), PostCommentReplyNotification: PostCommentReplyNotificationSerializer(), PostCommentReactionNotification: PostCommentReactionNotificationSerializer(), PostReactionNotification: PostReactionNotificationSerializer(), ConnectionRequestNotification: ConnectionRequestNotificationSerializer(), ConnectionConfirmedNotification: ConnectionConfirmedNotificationSerializer(), FollowNotification: FollowNotificationSerializer(), PostCommentUserMentionNotification: PostCommentUserMentionNotificationSerializer(), PostUserMentionNotification: PostUserMentionNotificationSerializer(), CommunityInviteNotification: CommunityInviteNotificationSerializer() }) class Meta: model = Notification fields = ( 'id', 'notification_type', 'content_object', 'read', 'created', )
class EventSerializer(serializers.HyperlinkedModelSerializer): content_object = GenericRelatedField({ Achieve: AchieveSerializer(read_only=True, allow_null=True), Friendship: FriendshipSerializer(read_only=True, allow_null=True), Post: PostSerializer(read_only=True), }) # content_type = fields.CharField(read_only=True) content_type = fields.SerializerMethodField('get_event_type') created = serializers.DateTimeField(read_only=True, format='%X %d %b %Y') author = UserSerializer() class Meta: model = Event fields = ('id', 'author', 'created', 'title', 'content_object', 'content_type') # exclude = ('content_object',) depth = 0 def get_event_type(self, obj): # print(ContentTypeManager().get_for_model(obj), dir(ContentTypeManager().get_for_model(obj))) content_object_name = str(type(obj.content_object)).replace( '\'>', '').split('.') return content_object_name[len(content_object_name) - 1]
class UserFavorSerializer(serializers.ModelSerializer): user = serializers.PrimaryKeyRelatedField( default=serializers.CurrentUserDefault(), queryset=UserProfile.objects.all()) # read-only fields add_time = serializers.DateTimeField(default=serializers.CreateOnlyDefault( datetime.now()), format='%Y-%m-%d %H:%M:%S', read_only=True) fav_object = GenericRelatedField({Article: FavorArticleSerializer()}, read_only=True) # write-only fields fav_type = serializers.IntegerField(write_only=True, min_value=1) class Meta: model = UserFavorite fields = ('id', 'user', 'add_time', 'fav_object', 'fav_type', 'fav_id') validators = [ UniqueTogetherValidator( message="已经收藏", fields=('user', 'fav_type', 'fav_id'), queryset=UserFavorite.objects.all().filter(is_valid=True)) ] def create(self, validated_data): content_type = ContentType_Map.get(validated_data.get("fav_type")) validated_data.update({"content_type": content_type}) return validated_data
class SensorAssignmentSerializer(serializers.HyperlinkedModelSerializer): assignment = GenericRelatedField({ models.Tap: serializers.HyperlinkedRelatedField( queryset=models.Tap.objects.all(), view_name='tap-detail', ), models.Kegerator: serializers.HyperlinkedRelatedField( queryset=models.Kegerator.objects.all(), view_name='kegerator-detail', ), models.Fermenter: serializers.HyperlinkedRelatedField( queryset=models.Fermenter.objects.all(), view_name='fermenter-detail', ), models.Chamber: serializers.HyperlinkedRelatedField( queryset=models.Chamber.objects.all(), view_name='chamber-detail', ), }) class Meta: model = models.SensorAssignment fields = ('created_at', 'modified_at', 'start_datetime', 'end_datetime', 'sensor', 'assignment', 'url')
class MatchSerializer(serializers.HyperlinkedModelSerializer): is_vote = serializers.SerializerMethodField() content_object = GenericRelatedField( { Profile: serializers.HyperlinkedRelatedField( queryset=Profile.objects.all(), view_name="profile-detail" ), Match: serializers.HyperlinkedRelatedField( queryset=Match.objects.all(), view_name="match-detail" ), } ) class Meta: model = Match fields = ( "id", "user", "content_object", "is_vote", ) def get_is_vote(self, obj) -> bool: user = self.context.get('request').user return match_services.is_vote(obj, user)
class ActivitySerializer(SimpleActivitySerializer): actor_type = serializers.SerializerMethodField() target_type = serializers.SerializerMethodField() actor = GenericRelatedField({ get_user_model(): SimpleUserSerializer(), Integration: SimpleIntegrationSerializer() }) target = GenericRelatedField({ get_user_model(): SimpleUserSerializer(), Channel: ChannelSerializer(), ChannelUser: ChannelUserSerializer(), Message: MessageSerializer(), Comment: CommentSerializer(), Upload: UploadSerializer(), Connection: ConnectionSerializer(), Task: SimpleTaskSerializer(), Application: ApplicationSerializer(), Participation: ParticipationSerializer(), ProgressEvent: SimpleProgressEventSerializer(), ProgressReport: SimpleProgressReportSerializer(), Integration: SimpleIntegrationSerializer(), IntegrationActivity: SimpleIntegrationActivitySerializer() }) class Meta(SimpleActivitySerializer.Meta): fields = '__all__' exclude = None def get_actor_type(self, obj): return get_instance_type(obj.actor) def get_target_type(self, obj): return get_instance_type(obj.target)
def test_subclass_uses_registered_subclass(self): tagged_item = GenericRelatedField( { Note: NoteSerializer(), NoteProxy: NoteProxySerializer(), }, read_only=True) # NoteProxy instance should use the NoteProxySerializer in # preference to the NoteSerializer proxied = NoteProxy.objects.get(pk=self.note.pk) serializer = tagged_item.get_serializer_for_instance(proxied) self.assertIsInstance(serializer, NoteProxySerializer) # But Note instance should use the NoteSerializer serializer = tagged_item.get_serializer_for_instance(self.note) self.assertIsInstance(serializer, NoteSerializer)
class PostMediaSerializer(serializers.ModelSerializer): content_object = GenericRelatedField({ PostImage: PostImageSerializer(), PostVideo: PostVideoSerializer(), }) class Meta: model = PostMedia fields = ('id', 'type', 'content_object', 'order')
class ScheduleViewSerializer(serializers.ModelSerializer): """ Serializer to view the schedule """ activities = ScheduleActivityViewSerializer(many=True, read_only=True) owner = GenericRelatedField({models.User: UserDisplaySerializer()}) class Meta: model = models.Schedule fields = ['id', "title", "activities", "owner"] read_only_fields = ['id', 'title', "activities", "owner"]
class TransactionSerializer(serializers.ModelSerializer): target = GenericRelatedField({ Stock: StockSerializer(), }) user = serializers.HyperlinkedRelatedField(read_only=True, view_name='accounts:account-detail') class Meta: model = Transaction fields = ('id', 'user', 'verb', 'created', 'target')
class ProductSerializer(serializers.ModelSerializer): item = GenericRelatedField({ Trouser: TrouserSerializer(), Wavecap: WavecapSerializer(), }) class Meta: model = Product fields = ("item",)
class RelationshipSerializer(serializers.ModelSerializer): # person1_id = serializers.IntegerField() # person2_id = serializers.IntegerField() content_object1 = GenericRelatedField({ Person: PersonSerializer(), Respondent: RespondentSerializer() }) content_object2 = GenericRelatedField({ Person: PersonSerializer(), Respondent: RespondentSerializer() }) class Meta: model = Relationship fields = ('id', 'object_id1', 'object_id2', 'content_object1', 'content_object2', 'person1_role', 'person2_role', 'relationship_type', 'start_date', 'end_date')
class FeedSerializer(serializers.ModelSerializer): content_object = GenericRelatedField({ Story: StorySerializer(), Character: CharacterSerializer(), Plot: PlotSerializer(), Group: GroupSerializer(), }) class Meta: model = Feed fields = ['id', 'content_object', 'created_at', 'feed_content']
class RescueBagReqQtySerializer(serializers.ModelSerializer): required_quantity = serializers.IntegerField() content_type = ContentTypeSerializer() base = GenericRelatedField({ models.Molecule: MoleculeSerializer(), models.Equipment: EquipmentSerializer() }) class Meta: # noqa: D106 model = models.RescueBagReqQty fields = ('required_quantity', 'base', 'content_type')
class ScheduleSerializer(serializers.ModelSerializer): owner = GenericRelatedField( { models.User: UserDisplaySerializer(), models.OGroup: MinimalGroupSerializer() }, read_only=True) class Meta: model = models.Schedule exclude = ['object_id', 'content_type'] read_only_fields = ['id', "owner"]
class ProductSerializer(serializers.ModelSerializer): url = serializers.HyperlinkedIdentityField(view_name="product-detail", lookup_field="slug") category = CategoryDetailSerializer() owner = GenericRelatedField({ Seller: SellerDetailSerializer(), Moderator: ModeratorDetailSerializer(), Admin: AdminDetailSerializer() }) class Meta: model = Product exclude = ('slug', 'content_type', 'object_id')
class Meta: model = Student fields = ['major', 'pay', 'standing', 'method', 'subject', 'location', 'description', 'schedule', 'user', 'email'] subject = GenericRelatedField({ Subject: SubjectSerializer(), }) class Meta: model = Subject fields = ('subject', 'semester', 'course_number')
class ActivitySerializer(SimpleActivitySerializer): actor_type = serializers.SerializerMethodField() target_type = serializers.SerializerMethodField() actor = GenericRelatedField({ get_user_model(): SimpleUserSerializer(), Integration: SimpleIntegrationSerializer() }) target = GenericRelatedField({ get_user_model(): SimpleUserSerializer(), Comment: CommentSerializer(), Connection: ConnectionSerializer(), Task: SimpleTaskSerializer(), Application: ApplicationSerializer(), Participation: ParticipationSerializer(), TaskRequest: TaskRequestSerializer(), ProgressEvent: SimpleProgressEventSerializer(), ProgressReport: SimpleProgressReportSerializer(), Integration: SimpleIntegrationSerializer(), IntegrationActivity: SimpleIntegrationActivitySerializer() }) class Meta(SimpleActivitySerializer.Meta): pass def get_actor_type(self, obj): return get_instance_type(obj.actor) def get_target_type(self, obj): return get_instance_type(obj.target)
class ServerSerializer(serializers.ModelSerializer): operations = serializers.DictField(read_only=False) connection = GenericRelatedField({ SimpleAuthConnection: SimpleAuthConnectionSerializer(), TokenAuthConnection: TokenAuthConnectionSerializer() }) class Meta: model = Server fields = ("id", "created_at", "updated_at", "server_type", "title", "url", "connection", "operations")
class TagSerializer(serializers.ModelSerializer): tagged_item = GenericRelatedField( { Bookmark: BookmarkSerializer(), }, read_only=True) class Meta: model = Tag exclude = ( 'id', 'content_type', 'object_id', )
class Meta: model = Tutor fields = ['pay', 'subject', 'credentials', 'method', 'location', 'description', 'schedule', 'rating', 'num_of_ratings', 'user', 'email'] subject = GenericRelatedField({ Subject: SubjectSerializer(), }) class Meta: model = Subject fields = ('subject', 'semester', 'course_number')
class TaskSerializer(serializers.ModelSerializer): contract_title = contract_serializer.ContractSerializer(read_only=True) case_title = case_serializer.CaseSerializer(read_only=True) task_object = GenericRelatedField({ Case: case_serializer.CaseSerializer(), Contract: contract_serializer.ContractSerializer() }) class Meta: model = Task fields = '__all__'