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)