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_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)
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_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__'
