class AddressSer(serializers.ModelSerializer):
province = StringRelatedField(label="省", read_only=True)
city = StringRelatedField(label="市", read_only=True)
district = StringRelatedField(label="省", read_only=True)
province_id = serializers.IntegerField(label="省id", write_only=True)
city_id = serializers.IntegerField(label="市id", write_only=True)
district_id = serializers.IntegerField(label="区id", write_only=True)
class Meta:
model = Address
# fields = '__all__'
exclude = ('create_time', 'update_time', 'user', 'is_deleted')
# extra_kwargs = {
# "province": {"read_only": True},
# "city": {"read_only": True},
# "district": {"read_only": True},
# # "is_deleted": {"read_only": True},
# }
def validate_moble(self, value):
"""验证手机号"""
if not re.match(r'1[1-9]\d{9}$', value):
raise serializers.ValidationError('手机格式不对')
return value
def create(self, validated_data):
# validated_datat校验通过的参数
validated_data["user"] = self.context["request"].user
# 调用父类方法创建
return super().create(validated_data)
class StatisticMapSerializer(ImageSerializer):
cognitive_paradigm_cogatlas = StringRelatedField(read_only=True)
cognitive_paradigm_cogatlas_id = PrimaryKeyRelatedField(
read_only=True, source="cognitive_paradigm_cogatlas")
cognitive_contrast_cogatlas = StringRelatedField(read_only=True)
cognitive_contrast_cogatlas_id = PrimaryKeyRelatedField(
read_only=True, source="cognitive_contrast_cogatlas")
map_type = serializers.SerializerMethodField()
analysis_level = serializers.SerializerMethodField()
def get_map_type(self, obj):
return obj.get_map_type_display()
def get_analysis_level(self, obj):
return obj.get_analysis_level_display()
class Meta:
model = StatisticMap
exclude = ['polymorphic_ctype', 'ignore_file_warning', 'data']
def value_to_python(self, value):
if not value:
return value
try:
return json.loads(value)
except (TypeError, ValueError):
return value
def to_representation(self, obj):
ret = super(ImageSerializer, self).to_representation(obj)
for field_name, value in obj.data.items():
if field_name not in ret:
ret[field_name] = self.value_to_python(value)
return ret
class AccessLogSerializer(BaseSerializer):
report_type = StringRelatedField()
organization = StringRelatedField()
platform = StringRelatedField()
metric = StringRelatedField()
target = StringRelatedField()
class Meta:
model = AccessLog
# fields = ('date', 'report_type', 'organization', 'platform', 'target', 'value')
def to_representation(self, obj: AccessLog):
data = {
'date': obj.date.isoformat(),
'report_type': str(obj.report_type),
'platform': str(obj.platform),
'organization': str(obj.organization),
'target': str(obj.target),
'metric': str(obj.metric),
'value': obj.value
}
data.update(getattr(obj, 'mapped_dim_values_', {}))
return data
def get_fields(self):
return []
class PreSaleSerializer(serializers.ModelSerializer):
brand = StringRelatedField()
thema = StringRelatedField()
image = serializers.StringRelatedField(
source='presaleimage_set',
many=True,
)
list = serializers.SerializerMethodField()
class Meta:
model = PreSale
fields = ('__all__')
def get_list(self, obj):
import random
pk_list = []
while True:
max_id = PreSale.objects.all()
max_id = len(max_id)
pk = random.randint(1, max_id)
ins = PreSale.objects.get(pk=pk)
if ins.pk in pk_list:
pass
else:
if obj.pk == ins.pk:
pass
else:
pk_list.append(ins.pk)
if len(pk_list) >= 4:
break
return pk_list
class SessionSerializer(serializers.ModelSerializer):
event = StringRelatedField()
published_speaker = StringRelatedField()
class Meta:
model = Talk
fields = ['url', 'title', 'abstract', 'published_speaker', 'event']
class PostSerializer(serializers.ModelSerializer):
user = UserProfileSerializer(read_only=True)
images = PostImageSerializer(source='postimages_set', many=True, read_only=True)
pyeong = StringRelatedField(many=True, read_only=True)
colors = StringRelatedField(many=True, read_only=True)
housingtype = StringRelatedField(many=True, read_only=True, )
style = StringRelatedField(many=True, read_only=True, )
class Meta:
model = Posts
fields = (
'id',
'user',
'title',
'content',
'main_image',
'images',
'pyeong',
'colors',
'housingtype',
'style',
)
def create(self, validated_data):
images_data = self.context.get('view').request.FILES
user = self.context.get("request").user
validated_data["user"] = user
post = super().create(validated_data)
for image_data in images_data.values():
PostImages.objects.create(
post=post,
image=image_data,
)
return post
class PlanReadSerializer(ModelSerializer):
workout = StringRelatedField(read_only=True)
user = StringRelatedField(read_only=True)
class Meta:
model = Plan
fields = ['id', 'name', 'workout', 'user']
extra_kwargs = {'id': {'read_only': True}}
class LegacyEventSerializer(ModelSerializer):
class Meta:
model = Event
questionaire = LegacyQuestionSetSerializer(read_only=True)
feedbacksheet = LegacyQuestionSetSerializer(read_only=True)
organizers = StringRelatedField(many=True, read_only=True)
members = StringRelatedField(many=True, read_only=True)
organizing_committee = SlugRelatedField("slug", many=True, read_only=True)
thumbnail = Base64ImageField(max_length=0, use_url=True)
images = LegacyEventImageSerializer(many=True, read_only=True)
class ImportBatchSerializer(ModelSerializer):
user = UserSerializer(read_only=True)
report_type = StringRelatedField()
organization = StringRelatedField()
platform = StringRelatedField()
class Meta:
model = ImportBatch
fields = ('pk', 'created', 'organization', 'platform', 'report_type',
'system_created', 'user', 'owner_level')
class _SeriesDetailSerializer(ModelSerializer):
"""
Serializer for series details.
.. admonition:: TODO
:class: warning
Make M2M fields editable.
"""
updated = DateTimeField(source='latest_upload',
read_only=True,
help_text='The latest chapter upload date.')
views = IntegerField(min_value=0,
read_only=True,
help_text='The total chapter views of the series.')
aliases = StringRelatedField(
many=True,
required=False,
help_text='The alternative titles of the series.')
authors = StringRelatedField(many=True,
required=False,
help_text='The authors of the series.')
artists = StringRelatedField(many=True,
required=False,
help_text='The artists of the series.')
categories = StringRelatedField(many=True,
required=False,
help_text='The categories of the series.')
url = URLField(source='get_absolute_url',
read_only=True,
help_text='The absolute URL of the series.')
def create(self, validated_data: Dict) -> Series:
"""Create a new ``Series`` instance."""
# manually set the manager to the current user
return super().create({
**validated_data, 'manager_id':
self.context['request'].user.id
})
class Meta:
model = Series
fields = ('slug', 'title', 'url', 'cover', 'updated', 'description',
'views', 'completed', 'licensed', 'format', 'aliases',
'authors', 'artists', 'categories')
extra_kwargs = {
'format': {
'write_only': True,
'default': 'Vol. {volume}, Ch. {number}: {title}'
}
}
class ClientSerializer(serializers.ModelSerializer):
contracts = ContractNestedSerializer(many=True, read_only=True)
sales_contact = StringRelatedField()
class Meta:
model = Client
fields = [
'id',
'first_name',
'last_name',
'company_name',
'sales_contact',
'email',
'phone',
'mobile',
'converted',
'contracts',
'date_created',
'date_updated',
'url',
]
extra_kwargs = {"url": {"view_name": "api:client-detail"}}
read_only_fields = [
'converted',
'sales_contact',
'date_created',
'date_updated',
]
class EventSerializer(serializers.ModelSerializer):
contract = ContractNestedSerializer(read_only=True)
support_contact = StringRelatedField()
class Meta:
model = Event
fields = [
'support_contact',
'attendees',
'event_date',
'notes',
'completed',
'contract',
'date_created',
'date_updated',
'url',
]
extra_kwargs = {"url": {"view_name": "api:event-detail"}}
read_only_fields = [
'support_contact',
'date_created',
'date_updated',
]
def validate_contract(self, contract_pk):
contract = Contract.objects.get(pk=contract_pk)
if Event.objects.filter(contract=contract).exists():
raise ValidationError('An event already exists for this contract',
code='unique')
class JobSerializer(serializers.ModelSerializer):
"""Serializer without hyperlinks for internal use"""
algorithm_image = StringRelatedField()
inputs = ComponentInterfaceValueSerializer(many=True)
outputs = ComponentInterfaceValueSerializer(many=True)
status = CharField(source="get_status_display", read_only=True)
algorithm_title = CharField(
source="algorithm_image.algorithm.title", read_only=True
)
class Meta:
model = Job
fields = [
"pk",
"api_url",
"algorithm_image",
"inputs",
"outputs",
"status",
"rendered_result_text",
"algorithm_title",
"started_at",
"completed_at",
]
class UserGroupSerializer(DynamicFieldsModelSerializer):
groups = StringRelatedField(many=True)
# groups = SerializerMethodField()
class Meta:
model = get_user_model()
exclude = ('password', )
class SessionResultSerializer(serializers.ModelSerializer):
player = StringRelatedField(many=False)
session = SlugRelatedField(many=False, read_only=True, slug_field='date')
class Meta:
model = SessionResult
fields = ('id', 'player', 'result', 'session')
class LegacyTeamSerializer(ModelSerializer):
class Meta:
model = Team
thumbnail = Base64ImageField(max_length=None, use_url=True, required=False)
users = StringRelatedField(many=True, read_only=True)
images = LegacyTeamImageSerializer(many=True, read_only=True)
class LegacyEntrySerializer(ModelSerializer):
class Meta:
model = Entry
thumbnail = Base64ImageField(max_length=0,
allow_empty_file=True,
use_url=True)
author = StringRelatedField(read_only=True)
class ArticleModelSerializer(serializers.ModelSerializer):
user = UserModelSerializer(read_only=True)
user_id = serializers.IntegerField(label='用户id', write_only=True)
collected_users = StringRelatedField(label='收藏用户', read_only=True, many=True)
class Meta:
model = Article
fields = '__all__'
class PartialRecipeSerializer(serializers.ModelSerializer):
"""
Partial recipe serializer
"""
images = StringRelatedField(many=True)
class Meta:
model = Recipe
fields = ('id', 'title_it', 'title_en', 'categories', 'date', 'images', 'likes')
class DetailedRecipeSerializer(serializers.ModelSerializer):
"""
Full recipe serializer
"""
images = StringRelatedField(many=True)
recipeIngredients = RecipeIngredientSerializer(many=True)
class Meta:
model = Recipe
fields = ('id', 'title_en', 'title_it', 'categories', 'date', 'images', 'recipeIngredients', 'body_en', 'body_it', 'likes', 'persons')
class LieuSerializer(HyperlinkedModelSerializer):
str = ReadOnlyField(source='__str__')
nature = StringRelatedField()
front_url = HyperlinkedIdentityField(view_name='lieu_detail',
lookup_field='slug')
class Meta(object):
model = Lieu
fields = ('id', 'str', 'nom', 'nature', 'parent', 'front_url', 'url')
class LessonSerializer(serializers.ModelSerializer):
category = LabelTypeSerializer()
type = LessonTypeSerializer()
labels = StringRelatedField(many=True)
teacher = TeacherSerializer()
class Meta:
model = Lesson
fields = "__all__"
class EnsembleSerializer(HyperlinkedModelSerializer):
str = ReadOnlyField(source='__str__')
html = ReadOnlyField()
type = StringRelatedField()
front_url = HyperlinkedIdentityField(view_name='ensemble_detail',
lookup_field='slug')
class Meta(object):
model = Ensemble
fields = ('id', 'str', 'html', 'type', 'front_url', 'url')
class ProductSerializer(ModelSerializer):
category = StringRelatedField(read_only=True)
# category = CategorySerializer()
class Meta:
model = Product
fields = [
"id", "name", "price", "count", "created_date", "category", "image"
]
class CountrySerializer(ModelSerializer):
continent = SlugRelatedField(slug_field='name', read_only=True)
currencies = StringRelatedField(source='currency_set',
many=True,
read_only=True)
class Meta:
model = Country
fields = '__all__'
class StatisticMapSerializer(serializers.HyperlinkedModelSerializer):
file = HyperlinkedFileField()
collection = HyperlinkedRelatedURL(read_only=True)
url = HyperlinkedImageURL(source='get_absolute_url')
cognitive_paradigm_cogatlas = StringRelatedField(read_only=True)
cognitive_paradigm_cogatlas_id = PrimaryKeyRelatedField(
read_only=True, source="cognitive_paradigm_cogatlas")
class Meta:
model = StatisticMap
exclude = ['polymorphic_ctype', 'ignore_file_warning']
class UserAddressSerializer(ModelSerializer):
"""地址管理的序列化器"""
# 需求:序列化时,返回省市区的名称,而不是默认返回主键id
province = StringRelatedField(read_only=True)
city = StringRelatedField(read_only=True)
district = StringRelatedField(read_only=True)
# 新增三个属性: 新地址时用到
province_id = serializers.IntegerField(label='省ID')
city_id = serializers.IntegerField(label='市ID')
district_id = serializers.IntegerField(label='区ID')
def create(self, validated_data):
# 新增一条地址数据时,需要自动设置user字段,因为用户没有传递此字段给服务器
validated_data['user'] = self.context.get('request').user
return super().create(validated_data) # 新增 一条地址数据
class Meta:
model = Address
exclude = ('user', 'is_deleted', 'create_time', 'update_time')
class ClientNestedSerializer(serializers.ModelSerializer):
sales_contact = StringRelatedField()
class Meta:
model = Client
fields = [
'id',
'first_name',
'last_name',
'company_name',
'sales_contact',
'url',
]
extra_kwargs = {"url": {"view_name": "api:client-detail"}}
class EventListSerializer(serializers.ModelSerializer):
contract = ContractNestedSerializer()
support_contact = StringRelatedField()
class Meta:
model = Event
fields = [
'support_contact',
'attendees',
'event_date',
'completed',
'contract',
'url',
]
extra_kwargs = {"url": {"view_name": "api:event-detail"}}
class OeuvreSerializer(HyperlinkedModelSerializer):
str = ReadOnlyField(source='__str__')
titre_significatif = ReadOnlyField(source='get_titre_significatif')
titre_non_significatif = ReadOnlyField(source='get_titre_non_significatif')
description = ReadOnlyField(source='get_description')
genre = StringRelatedField()
auteurs = PrimaryKeyRelatedField(many=True, read_only=True)
creation = AncrageSpatioTemporelSerializer()
front_url = HyperlinkedIdentityField(view_name='oeuvre_detail',
lookup_field='slug')
class Meta(object):
model = Oeuvre
fields = ('id', 'str', 'extrait_de', 'titre_significatif',
'titre_non_significatif', 'description', 'genre', 'auteurs',
'creation', 'front_url', 'url')