class ApuestaSerializer(HyperlinkedModelSerializer):
partido = HyperlinkedRelatedField(view_name='gambler:partido-detail', read_only=True)
resultado = HyperlinkedRelatedField(view_name='gambler:resultado-detail', read_only=True)
class Meta:
model = Apuesta
fields = ('partido', 'resultado', 'apuesta',)
class SucursalSerializer(HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='iSupermarket:sucursal-detail')
companyia = HyperlinkedRelatedField(queryset=Companyia.objects.all(), view_name='iSupermarket:companyia-detail')
sucursalreview_set = HyperlinkedRelatedField(many=True, read_only=True, view_name='iSupermarket:sucursalreview-detail')
user = CharField(read_only=True)
class Meta:
model = Sucursal
fields = ('url', 'name','location','zipCode','StateOrProvince', 'country', 'companyia','user', 'sucursalreview_set')
class RestaurantSerializer(HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='myrestaurants:restaurant-detail')
dishes = HyperlinkedRelatedField(many=True, read_only=True, view_name='myrestaurants:dish-detail')
restaurantreview_set = HyperlinkedRelatedField(many=True, read_only=True, view_name='myrestaurants:restaurantreview-detail')
user = CharField(read_only=True)
class Meta:
model = Restaurant
fields = ('url', 'name', 'street', 'number', 'city', 'zipCode', 'stateOrProvince',
'country', 'telephone', 'web', 'user', 'date', 'dishes', 'restaurantreview_set')
class PlaylistSerializer(serializers.HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='playItAPI:playlist-detail')
user = HyperlinkedRelatedField(view_name='playItAPI:user-detail',
read_only=True)
pub = HyperlinkedRelatedField(view_name='playItAPI:pub-detail',
read_only=True)
class Meta:
model = Playlist
fields = ('id', 'url', 'pub', 'name', 'user')
def __init__(self, *args, **kwargs):
super(HyperLinkedRelationalSerializer, self).__init__(*args, **kwargs)
hyperlink_args = {
key: value
for key, value in kwargs.items() if key not in FIELD_KEYS
}
hyperlink_args["view_name"] = self.opts.view_name
hyperlink_args["queryset"] = self.opts.queryset
self.hyperlinked_related_field = HyperlinkedRelatedField(
**hyperlink_args)
class AlumneSerializer(HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='alumne-detail')
Curs = HyperlinkedRelatedField(many=True, read_only=True, view_name='curs-detail')
alumnereview_set = HyperlinkedRelatedField(many=True, read_only=True, view_name='alumne-detail')
user = CharField(read_only=True)
class Meta:
model = Alumne
fields = ('url', 'name', 'nif', 'country', 'city', 'curs', 'user', 'alumnereview_set')
class ResultSerializer(serializers.ModelSerializer):
job = HyperlinkedRelatedField(
read_only=True, view_name="api:algorithms-job-detail"
)
images = HyperlinkedRelatedField(
many=True, read_only=True, view_name="api:image-detail"
)
class Meta:
model = Result
fields = ["pk", "job", "images", "output", "api_url"]
class JugadorSerializer(serializers.HyperlinkedModelSerializer):
clan = HyperlinkedRelatedField(read_only=True,
view_name='ClashofClans:clan_detail')
lliga = HyperlinkedRelatedField(read_only=True,
view_name='ClashofClans:lliga_detail')
user = CharField(read_only=True)
class Meta:
model = Jugador
fields = ('nom', 'localitzacio', 'id', 'nivell', 'lliga', 'clan',
'user')
class HyperLinkedRelationalSerializer(serializers.HyperlinkedModelSerializer):
_options_class = HyperLinkedRelationalSerializerOptions
def __init__(self, *args, **kwargs):
super(HyperLinkedRelationalSerializer, self).__init__(*args, **kwargs)
hyperlink_args = {
key: value
for key, value in kwargs.items() if key not in FIELD_KEYS
}
hyperlink_args["view_name"] = self.opts.view_name
hyperlink_args["queryset"] = self.opts.queryset
self.hyperlinked_related_field = HyperlinkedRelatedField(
**hyperlink_args)
def initialize(self, *args, **kwargs):
self.hyperlinked_related_field.initialize(**kwargs)
return super(HyperLinkedRelationalSerializer,
self).initialize(**kwargs)
def field_from_native(self, data, files, field_name, into):
"""
Override default so that the serializer can be used as a writable
nested field across relationships.
"""
if self.read_only:
return
data_fields = data.get(field_name, None)
if not data_fields and self.required:
raise ValidationError("%s is required" % field_name)
if data_fields:
if self.many:
into[field_name] = []
for data_field in data_fields:
if isinstance(data_field, str) or isinstance(
data_field, unicode):
into[field_name].append(
self.hyperlinked_related_field.from_native(
data_field))
else:
into[field_name].append(
super(HyperLinkedRelationalSerializer,
self).field_from_native(
data, files, field_name, into))
else:
if isinstance(data_fields, str) or isinstance(
data_fields, unicode):
into[
field_name] = self.hyperlinked_related_field.from_native(
data_fields)
class SongSerializer(HyperlinkedModelSerializer):
uri = HyperlinkedIdentityField(view_name='musicseaapp:album-detail')
group = HyperlinkedRelatedField(view_name='musicseaapp:group-detail',
read_only=True)
album = HyperlinkedRelatedField(view_name='musicseaapp:album-detail',
read_only=True)
user = CharField(read_only=True)
class Meta:
model = Song
fields = ('uri', 'name', 'album', 'group', 'lyrics', 'about', 'image',
'user')
class OwnedAchievementSerializer(HyperlinkedModelSerializer):
uri = HyperlinkedIdentityField(
view_name='steamapp:ownedachievement-detail')
steamid = HyperlinkedRelatedField(view_name='steamapp:player-detail',
read_only=True)
achid = HyperlinkedRelatedField(view_name='steamapp:achievement-detail',
read_only=True)
user = CharField(read_only=True)
class Meta:
model = OwnedAchievement
fields = ('uri', 'steamid', 'achid', 'nickname', 'achieved', 'user')
class JobSerializer(serializers.ModelSerializer):
algorithm_image = HyperlinkedRelatedField(
queryset=AlgorithmImage.objects.all(),
view_name="api:algorithms-image-detail",
)
image = HyperlinkedRelatedField(
queryset=Image.objects.all(), view_name="api:image-detail"
)
class Meta:
model = Job
fields = ["pk", "algorithm_image", "image", "api_url"]
def get_data_basket(self, DATA, format):
"Parse basket from relation hyperlink"
basket_parser = HyperlinkedRelatedField(view_name='basket-detail',
queryset=Basket.objects,
format=format)
try:
basket_uri = DATA.get('basket')
data_basket = basket_parser.from_native(basket_uri)
except ValidationError as e:
raise exceptions.NotAcceptable(e.messages)
else:
return data_basket
class PubSerializer(serializers.HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='playItAPI:pub-detail')
user = HyperlinkedRelatedField(view_name='playItAPI:user-detail',
read_only=True)
playlists = HyperlinkedRelatedField(many=True,
read_only=True,
view_name='playItAPI:playlist-detail')
class Meta:
model = Pub
fields = ('id', 'url', 'name', 'street', 'number', 'city', 'zipCode',
'stateOrProvince', 'country', 'user', 'playlists')
class OwnedGameSerializer(HyperlinkedModelSerializer):
uri = HyperlinkedIdentityField(view_name='steamapp:ownedgame-detail')
steamid = HyperlinkedRelatedField(view_name='steamapp:player-detail',
read_only=True)
appid = HyperlinkedRelatedField(view_name='steamapp:game-detail',
read_only=True)
user = CharField(read_only=True)
class Meta:
model = OwnedGame
fields = ('uri', 'steamid', 'appid', 'nickname', 'gamename',
'timeplayed_forever', 'user')
def parse_basket_from_hyperlink(DATA, format): # pylint: disable=redefined-builtin
"Parse basket from relation hyperlink"
basket_parser = HyperlinkedRelatedField(view_name="basket-detail",
queryset=Basket.objects,
format=format)
try:
basket_uri = DATA.get("basket")
data_basket = basket_parser.to_internal_value(basket_uri)
except ValidationError as e:
raise exceptions.NotAcceptable(e.messages)
else:
return data_basket
class ArchiveSerializer(serializers.ModelSerializer):
images = HyperlinkedRelatedField(read_only=True,
many=True,
view_name="api:image-detail")
algorithms = HyperlinkedRelatedField(read_only=True,
many=True,
view_name="api:algorithm-detail")
# Include the read only name for legacy clients
name = ReadOnlyField()
class Meta:
model = Archive
fields = ("id", "name", "title", "images", "algorithms", "api_url")
class PaymentSerializer(HyperlinkedModelSerializer):
upsell = HyperlinkedRelatedField(read_only=True,
required=False,
view_name='app-upsell-detail')
account = HyperlinkedRelatedField(read_only=True,
required=False,
source='app_payment_account',
view_name='app-payment-account-detail')
class Meta:
model = Webapp
fields = ('upsell', 'account')
view_name = 'app-payments-detail'
class AlbumSerializer(HyperlinkedModelSerializer):
uri = HyperlinkedIdentityField(view_name='musicseaapp:album-detail')
group = HyperlinkedRelatedField(view_name='musicseaapp:group-detail',
read_only=True)
songs = HyperlinkedRelatedField(many=True,
read_only=True,
view_name='musicseaapp:song-detail')
user = CharField(read_only=True)
class Meta:
model = Album
fields = ('uri', 'name', 'group', 'songs', 'release', 'bibliography',
'image', 'user')
class AnswerSerializer(HyperlinkedModelSerializer):
creator = SlugRelatedField(read_only=True, slug_field="username")
question = HyperlinkedRelatedField(
view_name="api:reader-studies-question-detail",
queryset=Question.objects.all(),
)
images = HyperlinkedRelatedField(
many=True, queryset=Image.objects.all(), view_name="api:image-detail"
)
def validate(self, attrs):
question = attrs["question"]
images = attrs["images"]
answer = attrs["answer"]
creator = self.context.get("request").user
if not question.reader_study.is_reader(user=creator):
raise ValidationError("This user is not a reader for this study.")
if not question.is_answer_valid(answer=answer):
raise ValidationError(
f"You answer is not the correct type. "
f"{question.get_answer_type_display()} expected, "
f"{type(answer)} found."
)
if len(images) == 0:
raise ValidationError(
"You must specify the images that this answer corresponds to."
)
reader_study_images = question.reader_study.images.all()
for im in images:
if im not in reader_study_images:
raise ValidationError(
f"Image {im} does not belong to this reader study."
)
if Answer.objects.filter(
creator=creator, question=question, images__in=images
).exists():
raise ValidationError(
f"User {creator} has already answered this question "
f"for at least 1 of these images."
)
return attrs
class Meta:
model = Answer
fields = ("answer", "api_url", "creator", "images", "pk", "question")
class Obra_TeatreSerializer(HyperlinkedModelSerializer):
url = HyperlinkedIdentityField(view_name='obra_Teatre-detail')
nom = HyperlinkedIdentityField(view_name='nom_obra-detail')
escriptor = HyperlinkedRelatedField(many=False,
read_only=True,
view_name='escriptor-detail')
representacions = HyperlinkedRelatedField(many=True,
read_only=True,
view_name='representacio-detail')
user = CharField(read_only=True)
class Meta:
model = Obra_Teatre
fields = ('nom', 'Tipus', 'escriptor', 'representacions', 'user')
def get_data_basket(self, DATA, format):
"Parse basket from relation hyperlink"
basket_parser = HyperlinkedRelatedField(
view_name='basket-detail',
queryset=Basket.objects,
format=format
)
try:
basket_uri = DATA.get('basket')
data_basket = basket_parser.from_native(basket_uri)
except ValidationError as e:
raise exceptions.NotAcceptable(e.messages)
else:
return data_basket
def parse_basket_from_hyperlink(DATA, format): # noqa
"Parse basket from relation hyperlink"
basket_parser = HyperlinkedRelatedField(
view_name='basket-detail',
queryset=Basket.objects,
format=format
)
try:
basket_uri = DATA.get('basket')
data_basket = basket_parser.to_internal_value(basket_uri)
except ValidationError as e:
raise exceptions.NotAcceptable(e.messages)
else:
return data_basket
class AlbumSerializer(ModelSerializer):
detail = HyperlinkedIdentityField(view_name='album-detail')
gallery_detail = HyperlinkedRelatedField(source='gallery',
view_name='gallery-detail',
read_only=True)
parent_detail = HyperlinkedRelatedField(source='parent',
view_name='album-detail',
read_only=True)
thumbnail_detail = HyperlinkedRelatedField(source='thumbnail',
view_name='image-detail',
read_only=True)
class Meta:
model = Album
exclude = ('visibility', )
class ReleaseSerializer(HyperlinkedModelSerializer):
uri = HyperlinkedIdentityField(view_name='mygames:platform-detail')
game = HyperlinkedRelatedField(read_only=True,
view_name='mygames:game-detail')
region = HyperlinkedRelatedField(many=True,
read_only=True,
view_name='mygames:region-detail')
platform = HyperlinkedRelatedField(many=True,
read_only=True,
view_name='mygames:platform-detail')
class Meta:
model = Release
fields = ('uri', 'game', 'platform', 'region', 'release_date')
class AddonPaymentAccountSerializer(HyperlinkedModelSerializer):
addon = HyperlinkedRelatedField(view_name='app-detail')
payment_account = HyperlinkedRelatedField(
view_name='payment-account-detail')
class Meta:
model = AddonPaymentAccount
fields = ('addon', 'payment_account', 'created', 'modified', 'url')
view_name = 'app-payment-account-detail'
def validate(self, attrs):
if attrs['addon'].premium_type in amo.ADDON_FREES:
raise ValidationError('App must be a premium app.')
return attrs
class NotebookSerializer(ModelSerializer):
owner = ReadOnlyField(source='owner.username')
notes = HyperlinkedRelatedField(many=True, read_only=True, view_name='api:note-detail')
class Meta:
model = Notebook
fields = ('id', 'title', 'colour', 'owner', 'notes', )
class RawImageFileSerializer(serializers.ModelSerializer):
upload_session = HyperlinkedRelatedField(
queryset=RawImageUploadSession.objects.all(),
view_name="api:upload-session-detail",
)
def validate_upload_session(self, value):
user = self.context.get("request").user
if not user.has_perm("change_rawimageuploadsession", value):
raise ValidationError(
"User does not have permission to change this raw image upload session"
)
return value
class Meta:
model = RawImageFile
fields = [
"pk",
"upload_session",
"filename",
"api_url",
"consumed",
"staged_file_id",
]
class CategoryDetailSerializer(ModelSerializer):
photo = SerializerMethodField()
posts = HyperlinkedRelatedField(
many=True,
read_only=True,
view_name='posts-api:detail',
lookup_field='slug'
)
class Meta:
model = Category
fields = [
'name',
'photo',
'posts',
]
def get_photo(self, obj):
try:
photo = obj.photo.url
except:
photo = None
return photo
def get_posts(self, obj):
category_name = obj.name
return Post.objects.filter(category__name=category_name)
class QuestionSerializer(HyperlinkedModelSerializer):
answer_type = CharField(source="get_answer_type_display")
reader_study = HyperlinkedRelatedField(view_name="api:reader-study-detail",
read_only=True)
form_direction = CharField(source="get_direction_display")
image_port = CharField(source="get_image_port_display")
options = CategoricalOptionSerializer(many=True, read_only=True)
class Meta:
model = Question
fields = (
"answer_type",
"api_url",
"form_direction",
"help_text",
"image_port",
"pk",
"question_text",
"reader_study",
"required",
"options",
)
swagger_schema_fields = swagger_schema_fields_for_charfield(
answer_type=model._meta.get_field("answer_type"),
form_direction=model._meta.get_field(
"direction"), # model.direction gets remapped
image_port=model._meta.get_field("image_port"),
)
class AlgorithmImageSerializer(serializers.ModelSerializer):
algorithm = HyperlinkedRelatedField(read_only=True,
view_name="api:algorithm-detail")
class Meta:
model = AlgorithmImage
fields = ["pk", "api_url", "algorithm"]
class CheckSerializer(HyperlinkedModelSerializer):
user = HyperlinkedRelatedField(
'api-user-detail', read_only=True, default=CurrentUserDefault())
patch = HiddenField(default=CurrentPatchDefault())
url = CheckHyperlinkedIdentityField('api-check-detail')
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
data['state'] = val
break
return super(CheckSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(CheckSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
return data
class Meta:
model = Check
fields = ('id', 'url', 'patch', 'user', 'date', 'state', 'target_url',
'context', 'description')
read_only_fields = ('date',)
extra_kwargs = {
'url': {'view_name': 'api-check-detail'},
}
class HyperLinkedRelationalSerializer(serializers.HyperlinkedModelSerializer):
_options_class = HyperLinkedRelationalSerializerOptions
def __init__(self, *args, **kwargs):
super(HyperLinkedRelationalSerializer, self).__init__(*args, **kwargs)
hyperlink_args = {key: value for key, value in kwargs.items() if key not in FIELD_KEYS}
hyperlink_args["view_name"] = self.opts.view_name
hyperlink_args["queryset"] = self.opts.queryset
self.hyperlinked_related_field = HyperlinkedRelatedField(**hyperlink_args)
def initialize(self, *args, **kwargs):
self.hyperlinked_related_field.initialize(**kwargs)
return super(HyperLinkedRelationalSerializer, self).initialize(**kwargs)
def field_from_native(self, data, files, field_name, into):
"""
Override default so that the serializer can be used as a writable
nested field across relationships.
"""
if self.read_only:
return
data_fields = data.get(field_name, None)
if not data_fields and self.required:
raise ValidationError("%s is required" % field_name)
if data_fields:
if self.many:
into[field_name] = []
for data_field in data_fields:
if isinstance(data_field, str) or isinstance(data_field, unicode):
into[field_name].append(self.hyperlinked_related_field.from_native(data_field))
else:
into[field_name].append(super(HyperLinkedRelationalSerializer, self).field_from_native(data, files, field_name, into))
else:
if isinstance(data_fields, str) or isinstance(data_fields, unicode):
into[field_name] = self.hyperlinked_related_field.from_native(data_fields)
def __init__(self, *args, **kwargs):
super(HyperLinkedRelationalSerializer, self).__init__(*args, **kwargs)
hyperlink_args = {key: value for key, value in kwargs.items() if key not in FIELD_KEYS}
hyperlink_args["view_name"] = self.opts.view_name
hyperlink_args["queryset"] = self.opts.queryset
self.hyperlinked_related_field = HyperlinkedRelatedField(**hyperlink_args)
