class ReviewCreateSerializer(serializers.ModelSerializer):
movie = serializers.ModelSerializer(required=False)
user = serializers.ModelSerializer(required=False)
# like_user = serializers.ReadOnlyField(required=False)
class Meta:
model = Review
fields = ['movie', 'user', 'title', 'content']
class MovieStarPointUpdateSerializer(serializers.ModelSerializer):
# pointing_users = MovieStarPointSerializer(source='moviestarpoint_set', many=True, required=False)
pointing_user = serializers.ModelSerializer(required=False)
pointed_movie = serializers.ModelSerializer(required=False)
# star_point = serializers.ModelSerializer()
# print(star_point)
class Meta:
model = MovieStarPoint
fields = '__all__'
def _map_model_field(self, model_field, direction):
assert isinstance(model_field, models.Field)
# to get a fully initialized serializer field we use DRF's own init logic
try:
field_cls, field_kwargs = serializers.ModelSerializer().build_field(
field_name=model_field.name,
info=get_field_info(model_field.model),
model_class=model_field.model,
nested_depth=0,
)
field = field_cls(**field_kwargs)
except: # noqa
field = None
# For some cases, the DRF init logic either breaks (custom field with internal type) or
# the resulting field is underspecified with regards to the schema (ReadOnlyField).
if field and not anyisinstance(field, [serializers.ReadOnlyField, serializers.ModelField]):
return self._map_serializer_field(field, direction)
elif isinstance(model_field, models.ForeignKey):
return self._map_model_field(model_field.target_field, direction)
elif hasattr(models, model_field.get_internal_type()):
# be graceful when the model field is not explicitly mapped to a serializer
internal_type = getattr(models, model_field.get_internal_type())
field_cls = serializers.ModelSerializer.serializer_field_mapping[internal_type]
return self._map_serializer_field(field_cls(), direction)
else:
error(
f'could not resolve model field "{model_field}". failed to resolve through '
f'serializer_field_mapping, get_internal_type(), or any override mechanism. '
f'defaulting to "string"'
)
return build_basic_type(OpenApiTypes.STR)
class PaginationSerializer(ParamsSerializer):
count = s.IntegerField(label=_('总条目数'))
# next = s.URLField(label=_('下一页地址'), allow_null=True)
# previous = s.URLField(label=_('上一页地址'), allow_null=True)
page = s.IntegerField(label=_('当前页数'))
page_size = s.IntegerField(label=_('每页显示数量'))
filter = s.DictField(label=_('查询条件'))
results = s.ModelSerializer(many=True)
class CommentaireSerializer(serializers.ModelSerializer):
questionnaire = serializers.ModelSerializer()
class Meta:
model = Commentaire
fields = ('id', 'auteur', 'titre', 'questionnaire')
def get_questionnaire(self, obj):
return QuestionnaireSerializer(obj.questionnaire).data
class UserProfile(serializers.ModelSerializer):
user = serializers.ModelSerializer()
class Meta:
model = UserProfile
fields = (
'user',
'grantType',
)
def get_user(self):
user = self.data.user
return UserSerializer(user, context=self.context).data
def _map_model_field(self, model_field, direction):
assert isinstance(model_field, models.Field)
# to get a fully initialized serializer field we use DRF's own init logic
try:
field_cls, field_kwargs = serializers.ModelSerializer(
).build_field(
field_name=model_field.name,
info=get_field_info(model_field.model),
model_class=model_field.model,
nested_depth=0,
)
field = field_cls(**field_kwargs)
except: # noqa
field = None
# For some cases, the DRF init logic either breaks (custom field with internal type) or
# the resulting field is underspecified with regards to the schema (ReadOnlyField).
if field and isinstance(field, serializers.PrimaryKeyRelatedField):
# special case handling only for _resolve_path_parameters() where neither queryset nor
# parent is set by build_field. patch in queryset as _map_serializer_field requires it
if not field.queryset:
field.queryset = model_field.related_model.objects.none()
return self._map_serializer_field(field, direction)
elif field and not anyisinstance(
field, [serializers.ReadOnlyField, serializers.ModelField]):
return self._map_serializer_field(field, direction)
elif isinstance(model_field, models.ForeignKey):
return self._map_model_field(model_field.target_field, direction)
elif hasattr(models, 'JSONField') and isinstance(
model_field, models.JSONField):
# fix for DRF==3.11 with django>=3.1 as it is not yet represented in the field_mapping
return build_basic_type(OpenApiTypes.OBJECT)
elif hasattr(models, model_field.get_internal_type()):
# be graceful when the model field is not explicitly mapped to a serializer
internal_type = getattr(models, model_field.get_internal_type())
field_cls = serializers.ModelSerializer.serializer_field_mapping.get(
internal_type)
if not field_cls:
warn(
f'model field "{model_field.get_internal_type()}" has no mapping in '
f'ModelSerializer. it may be a deprecated field. defaulting to "string"'
)
return build_basic_type(OpenApiTypes.STR)
return self._map_serializer_field(field_cls(), direction)
else:
error(
f'could not resolve model field "{model_field}". failed to resolve through '
f'serializer_field_mapping, get_internal_type(), or any override mechanism. '
f'defaulting to "string"')
return build_basic_type(OpenApiTypes.STR)
def _build_concrete_fields(self):
helper_serializer = serializers.ModelSerializer()
for model_field in self.model_inspector.concrete_fields:
if type(model_field) in config.FIELD_TYPES:
field_class, field_kwargs = config.FIELD_TYPES[type(
model_field)]['serializer_class'], {
'required': not model_field.null
}
else:
field_class, field_kwargs = helper_serializer.build_standard_field(
model_field.name, model_field)
kwarg_overrides = self.serializer_field_kwargs.get(
model_field.name, {})
field_serializer = field_class(**{
**field_kwargs,
**kwarg_overrides
})
self.concrete_fields[model_field.name] = field_serializer
self.field_info.append(
FieldInfo(serializer_field_name=model_field.name,
model_field=model_field,
serializer=field_serializer))
if self.one_to_one_proxy_fields is not None:
for one_to_one_field_name, proxy_fields in self.one_to_one_proxy_fields.items(
):
for proxy_field_name in proxy_fields:
one_to_one_field = self.model_cls._meta.get_field(
one_to_one_field_name)
related_model_cls = one_to_one_field.related_model
model_proxy_field = related_model_cls._meta.get_field(
proxy_field_name)
field_class, field_kwargs = helper_serializer.build_standard_field(
model_proxy_field.name, model_proxy_field)
kwarg_overrides = self.serializer_field_kwargs.get(
model_proxy_field.name, {})
field_serializer = field_class(
**{
**field_kwargs,
**kwarg_overrides,
**{
'source':
one_to_one_field.name + '.' + model_proxy_field.name
}
})
self.concrete_fields[
model_proxy_field.name] = field_serializer
self.field_info.append(
FieldInfo(serializer_field_name=model_proxy_field.name,
model_field=model_proxy_field,
serializer=field_serializer))
class NoteSerializer(serializers.ModelSerializer):
serializers.ModelSerializer()
instance = serializers.PrimaryKeyRelatedField(queryset=Instance.objects.all())
class Meta:
model = Note
def save(self, user=None):
# This used to be in note_viewset
if user:
if not user.has_perm('change_xform', self.validated_data['instance'].xform):
msg = "You are not authorized to add/change notes on this form."
raise exceptions.PermissionDenied(msg)
return super(NoteSerializer, self).save()
class RequestBoardCreateSerializer(serializers.ModelSerializer):
user = serializers.ModelSerializer(required = False)
class Meta:
model = RequestBoard
# fields= '__all__'
fields = ['movie_id', 'movie_name', 'title','user']
class FreeBoardCreateSerializer(serializers.ModelSerializer):
user = serializers.ModelSerializer(required = False)
class Meta:
model = FreeBoard
# fields= '__all__'
fields = ['title', 'content', 'user']
def retrieve(self, request, pk=None):
queryset = Facility.objects.all()
facility = get_object_or_404(queryset, pk=pk)
serializer = serializers.ModelSerializer(facility)
return Response(serializer.data)
def list(self, request):
queryset = Facility.objects.all()
serializer = serializers.ModelSerializer(queryset)
return Response(serializer.data)
