class GoodsListSerializer(serializers.ModelSerializer): benefits = SerializerMethodField() plans = SerializerMethodField() class Meta: model = Goods fields = ('id', 'name', 'goodstype', 'images', 'price', 'benefits', 'scores', 'content', 'get_absolute_url', 'plans') def get_plans(self, obj): market_plans = MarketPlan.objects.filter(goods=obj.id, is_enabled=1) serializer = MarketPlanSerializer(market_plans, many=True) return serializer.data def get_benefits(self, obj): if obj.benefits == 0: return 0 diff_price = obj.price - obj.benefits if diff_price > 0: return diff_price else: return 0
class DocumentTypeSerializer(serializers.ModelSerializer): document_count = serializers.IntegerField(read_only=True) def get_slug(self, obj): return slugify(obj.name) slug = SerializerMethodField() class Meta: model = DocumentType fields = ("id", "slug", "name", "match", "matching_algorithm", "is_insensitive", "document_count")
class CommentListSerializer(ModelSerializer): replies = SerializerMethodField() user = UserSerializer() post = PostCommentSerializer() class Meta: model = Comment fields = "__all__" # depth = 1 def get_replies(self, obj): if obj.any_children: return CommentListSerializer(obj.children(), many=True).data
class UserShortSerializer(serializers.ModelSerializer): """ representation of the short user info """ avatar_url = SerializerMethodField() bio = SerializerMethodField() class Meta: model = User fields = ['username', 'avatar_url', 'bio', 'id'] def get_avatar_url(self, obj: User) -> str: """ get loadable avatar url """ return prepare_s3_image_url(obj.avatar.url) def get_bio(self, obj: User) -> str: """ get short user bio """ return obj.page.get_short_bio()
class PlaylistSerializer(ModelSerializer): songs = SongShortInfoSerializer(many=True, ) is_fan = SerializerMethodField() class Meta: model = Playlist fields = ('name', 'songs', 'songs_amount', 'is_private', 'owner', 'is_fan', 'total_likes') read_only_fields = ('songs_amount', ) def get_is_fan(self, obj) -> bool: user = self.context.get('request').user return likes_services.is_fan(obj, user)
def get_get_fields(self): fields = { "length": IntegerField(), "breadth": IntegerField(), "height": IntegerField(), "id": IntegerField() } if self.context["request"] and self.context[ "request"].user and self.context["request"].user.is_staff: fields["created_by_id"] = IntegerField() fields["updated_at"] = SerializerMethodField() return fields
class TrackSerializer(serializers.ModelSerializer): points = SerializerMethodField() user = UserSerializer() class Meta: model = Track fields = ['id', 'user', 'name', 'description', 'active', 'point_count', 'points', 'start_date', 'end_date'] def get_points(selfset, obj): queryset = Point.objects.filter(track__id=obj.pk) queryset = queryset.filter(active=True) serializer = PointSerializer(queryset, many=True) return serializer.data
class ResultSerializer(serializers.ModelSerializer): class Meta: model = Result fields = ('resource_uri', 'name', 'status', 'last_update', 'data', 'log_url') resource_uri = HyperlinkedResultField(view_name='results-detail') log_url = SerializerMethodField(required=False) data = JSONField(required=False) def get_log_url(self, obj): request = self.context['request'] return obj.get_log_url(request)
class MinimalRatingMapSerializer(serializers.ModelSerializer): release = NameCubeReleaseSerializer() created_at = serializers.DateTimeField(read_only=True, format=JAVASCRIPT_DATETIME_FORMAT) event_type = SerializerMethodField() class Meta: model = models.RatingMap fields = ('id', 'created_at', 'release', 'event_type') @classmethod def get_event_type(cls, instance: models.RatingMap) -> str: return _CONTENT_TYPE_RATING_MAP[instance.ratings_for_content_type_id]
class CommentSerializer(ItemMetaDataSerializer): related = serializers.PrimaryKeyRelatedField(queryset=Confession.objects, required=True) parent = serializers.PrimaryKeyRelatedField(queryset=Comment.objects, required=False) reply_count = SerializerMethodField(required=False) likes_count = SerializerMethodField(required=False) dislikes_count = SerializerMethodField(required=False) report_count = serializers.IntegerField(required=False) class Meta: model = Comment fields = '__all__' depth = 1 read_only_fields = ('related', 'reply_count', 'likes_count', 'dislikes_count', 'report_count') def get_reply_count(self, obj): if obj.item_is_parent: return obj.children().count() return 0 def get_likes_count(self, obj): try: return len(obj.likes) except AttributeError: return 0 def get_dislikes_count(self, obj): try: return len(obj.dislikes) except AttributeError: return 0 def get_report_count(self, obj): try: return ReportComment.objects.filter(comment_id=obj.id).count() except AttributeError: return 0
class TourSerializer(serializers.ModelSerializer): hotel = HotelSerializer(many=True, read_only=True) place = PlaceSerializer(many=True, read_only=True) tour_photos = SerializerMethodField() class Meta: model = Tour fields = "__all__" @staticmethod def get_tour_photos(instance): photos = instance.tour_photos.all().order_by("id") return PhotoSerializer(photos, many=True, read_only=True).data
class MenuSerializer(ModelSerializer): """ Menu model's serializer """ dishes_number = SerializerMethodField() class Meta: model = Menu fields = '__all__' def get_dishes_number(self, menu): return menu.dishes.count()
class PontoTuristicoSerializer(ModelSerializer): atracoes = AtracaoSerializer(many=True) endereco = EnderecoSerializer() descricao_completa = SerializerMethodField() class Meta: model = PontoTuristico fields = ('id', 'nome', 'descricao', 'aprovado', 'foto', 'atracoes', 'comentarios', 'avaliacoes', 'endereco', 'descricao_completa', 'descricao_completa2') def get_descricao_completa(self, obj): return '%s - %s' % (obj.nome, obj.descricao)
class TransactionSerializer(serializers.ModelSerializer): fuel = serializers.SlugRelatedField(slug_field="fuel_price", queryset=FuelPrices.objects.all(), allow_null=True, required=False) gas_station_assigned = serializers.SlugRelatedField( slug_field="name", queryset=GasolineStation.objects.all(), allow_null=True, required=False) fuel_name = SerializerMethodField() fuel_price = SerializerMethodField() class Meta: model = Transactions fields = "__all__" def get_fuel_name(self, obj): return "%s" % (obj.fuel.name) def get_fuel_price(self, obj): return "%s" % (obj.fuel.price)
class PostListSerializer(ModelSerializer): url = post_detail_url comments_count = SerializerMethodField() author = SerializerMethodField() category = SlugRelatedField( many=True, read_only=True, slug_field='name' ) class Meta: model = Post fields = ['url', 'title', 'category', 'author', 'status', 'published', 'comments_count'] def get_comments_count(self, obj): return obj.comments.count() def get_author(self, obj): return obj.author.username def get_category(self, obj): return obj.category.name
class StoryDetailSerializer(ModelSerializer): user = SerializerMethodField() comments = CommentsListSerializer(many=True, read_only=True) class Meta: model = StoryModel fields = [ 'pk', 'title', 'content', 'created', 'updated', 'user', 'full_detail', 'comments' ] def get_user(self, obj): return obj.user.get_full_name()
class PageListSerializer(BaseModelSerializer): path = SerializerMethodField() class Meta: model = Page fields = ( "slug", "title", "path", ) def get_path(self, obj): return obj.get_path()
class CampaignAsCourseSerializer(EnumSupportSerializerMixin, ModelSerializer): title = SerializerMethodField() class Meta: model = Campaign fields = [ 'id', 'title', 'graders' ] def get_title(self, obj: Campaign): return obj.course_data.course_group.course.title
class PontoTuristicoSerializer(ModelSerializer): recursos = RecursoSerializer(many=True) endereco = EnderecoSerializer() descricao_completa = SerializerMethodField() doc_identificacao = DocIdentificacaoSerializer() # aprovacao = SerializerMethodField() class Meta: model = PontoTuristico fields = [ 'id', 'nome', 'descricao', 'aprovado', 'recursos', 'comentarios', 'avaliacoes', 'endereco', 'foto', 'descricao_completa', 'aprovacao', 'doc_identificacao' ] read_only_fields = ['comentarios', 'avaliacoes'] def cria_recursos(self, recursos, ponto): for recurso in recursos: rc = Recurso.objects.create(**recurso) ponto.recursos.add(rc) def create(self, validated_data): recursos = validated_data['recursos'] del validated_data['recursos'] endereco = validated_data['endereco'] del validated_data['endereco'] doc = validated_data['doc_identificacao'] del validated_data['doc_identificacao'] doci = DocIdentificacao.objects.create(**doc) ponto = PontoTuristico.objects.create(**validated_data) self.cria_recursos(recursos, ponto) end = Endereco.objects.create(**endereco) ponto.endereco = end ponto.doc_identificacao = doci ponto.save() return ponto def get_descricao_completa(self, obj): return '%s - %s' % (obj.nome, obj.descricao) # def get_aprovacao(self, obj): # return '%s - %s' % (obj.id, obj.aprovado)
class PontoTuristicoSerializer(ModelSerializer): atracoes = AtracaoSerializer(many=True) endereco = EnderecoSerializer() descricao_completa = SerializerMethodField() doc_identificacao = DocIdentificacaoSerializer() class Meta: model = PontoTuristico fields = ( 'id', 'nome', 'descricao', 'aprovado', 'atracoes', 'comentarios', 'avaliacoes', 'endereco', 'descricao_completa', 'descricao_completa2', 'doc_identificacao' ) read_only_fields = ('comentarios',) def cria_atracoe(self, atracoes, ponto): for atracao in atracoes: at = Atracao.objects.create(**atracao) ponto.atracoes.add(at) def create(self, validated_data): atracoes = validated_data['atracoes'] del validated_data['atracoes'] endereco = validated_data['endereco'] del validated_data['endereco'] avaliacoes = validated_data['avaliacoes'] del validated_data['avaliacoes'] doc = validated_data['doc_identificacao'] del validated_data['doc_identificacao'] doci = DocIdentificacao.objects.create(**doc) ponto = PontoTuristico.objects.create(**validated_data) self.cria_atracoe(atracoes, ponto) ponto.avaliacoes.set(avaliacoes) end = Endereco.objects.create(**endereco) ponto.endereco = end ponto.doc_identificacao = doci ponto.save() return ponto def get_descricao_completa(self, obj): return '%s - %s' % (obj.nome, obj.descricao)
class SongPlainSerializer(serializers.ModelSerializer): """ All fields are shown as plain text """ user_valoration = ValorationField() avg_valoration = SerializerMethodField() count_valoration = SerializerMethodField() def get_avg_valoration(self, song): """ Average valoration of all users """ return Valoration.objects.filter(song=song).aggregate(avg=Avg('valoration'))['avg'] def get_count_valoration(self, song): """ Average valoration of all users """ return Valoration.objects.filter(song=song).aggregate(count=Count('valoration'))['count'] class Meta: model = Song read_only_fields = [ "id", "title", "duration", "stream_url", "album", "genre", "episode", "avg_valoration", "count_valoration", "created_at", ] fields = read_only_fields + [ "user_valoration", # the writable field ]
class ChannelDetailSerializer(ModelSerializer): user = UserDetailSerializer(read_only=True) followers = SerializerMethodField(read_only=True) comics = SerializerMethodField(read_only=True) recent_comics = SerializerMethodField(read_only=True) most_viewed_comics = SerializerMethodField(read_only=True) class Meta: model = Profile fields = ('id', 'user', 'about', 'profileImage', 'followers', 'comics', 'recent_comics', 'most_viewed_comics', ) def get_followers(self, obj): serializer = FollowerSerializer(obj.profile_followers, many=True) return serializer.data def get_comics(self, obj): comic = Comic.objects.filter(user=obj.user) print('this is the comic', comic) serializer = ComicListSerializer(comic, many=True) return serializer.data def get_recent_comics(self, obj): comic = Comic.objects.get_publisher_recent_comics(user=obj.user) serializer = ComicListSerializer(comic, many=True) return serializer.data def get_most_viewed_comics(self, obj): comic = Comic.objects.filter(user=obj.user).order_by('-view_count') serializer = ComicListSerializer(comic, many=True) return serializer.data
class PostDetailSerializer(ModelSerializer): url = post_detail_url user = UserDetailSerializer(read_only=True) image = SerializerMethodField() html = SerializerMethodField() comments = SerializerMethodField() class Meta: model = Post fields = [ 'id', 'user', 'title', 'slug', 'content', 'html', 'publish', 'url', 'image', 'comments', ] def get_html(self, obj): return obj.get_markdown() def get_image(self, obj): try: image = obj.image.url except: image = None return image def get_comments(self, obj): c_qs = Comment.objects.filter_by_instance(obj) comments = CommentSerializer(c_qs, many=True).data return comments
class PackageVersionSerializerExperimental(serializers.ModelSerializer): download_url = SerializerMethodField() namespace = SerializerMethodField() full_name = SerializerMethodField() dependencies = SerializerMethodField() def get_download_url(self, instance): return make_full_url(self.context["request"], instance.download_url) def get_full_name(self, instance): return instance.full_version_name def get_namespace(self, instance): return instance.package.owner.name def get_dependencies(self, instance): return [ dependency.full_version_name for dependency in instance.dependencies.all() ] class Meta: model = PackageVersion ref_name = "PackageVersionExperimental" fields = ( "namespace", "name", "version_number", "full_name", "description", "icon", "dependencies", "download_url", "downloads", "date_created", "website_url", "is_active", )
class ProfileMainSerializer(serializers.ModelSerializer): def get_nickname(self,obj): return obj.user.nickname def get_following(self, obj): return Relation.objects.filter(from_user=obj.user).count() def get_follower(self, obj): return Relation.objects.filter(to_user=obj.user).count() def get_post_count(self, obj): return Post.objects.filter(author=obj.user).count() def get_waiting(self, obj): return WaitingRelation.objects.filter(receive_user=obj.user).count() def get_image(self, obj): try: image = ProfileImage.objects.filter(user=obj.user).get() serializer = ProfileImageSerializer(image) if serializer: return serializer.data raise exceptions.ValidationError({"detail": "excepted error"}) except ObjectDoesNotExist: data = { "profile_image": "https://static.octocolumn.com/media/example/2_x20_.jpeg", "cover_image": "https://static.octocolumn.com/media/example/1.jpeg" } return data # def get_birth_day(self, obj): # return str(obj.month) + '/' + str(obj.day) + '/' + str(obj.year) post_count = SerializerMethodField() follower = SerializerMethodField() following = SerializerMethodField() waiting = SerializerMethodField() image = SerializerMethodField() nickname = SerializerMethodField() # birth_day = SerializerMethodField() class Meta: model = Profile fields = ( 'nickname', 'facebook', 'instagram', 'twitter', 'web', 'intro', 'follower', 'following', 'post_count', 'waiting', 'image' )
class MenuSerializer(serializers.ModelSerializer): # categories = CategorySerializer(many=True) categories = SerializerMethodField(method_name='get_categories') @staticmethod def get_categories(menu): return { c.name: CategorySerializer().to_representation(instance=c) for c in menu.categories.all() } class Meta: model = Menu fields = ['menuVersion', 'categories']
class LabelExportSerializer(ModelSerializer): surface = SerializerMethodField() class Meta: model = Label fields = [ 'id', 'class_id', 'shape', 'surface', ] def get_surface(self, obj): return obj.surface.replace(',', '')
class PizzaSerializer(DynamicModelSerializer): cost = SerializerMethodField() toppings = DynamicRelationField(ToppingSerializer, many=True) groups = DynamicRelationField('PizzaGroupSerializer', many=True) menu = DynamicRelationField(MenuSerializer) class Meta: model = Pizza name = 'pizza' fields = ('id', 'name', 'price', 'from_date', 'to_date', 'cost', 'toppings', 'menu', 'groups') def get_cost(self, obj): return obj.toppings.aggregate(cost=Sum('cost'))['cost']
class ListLessonsSerializer(ModelSerializer): class Meta: model = BaseLesson fields = ( "id", "name", "is_complete", ) read_only_fields = ("is_complete", ) is_complete = SerializerMethodField() def get_is_complete(self, lesson: BaseLesson) -> bool: return lesson.is_completed_by(user=self.context["user"])
class FriendOfFriendSerializer(CurrentFriendsSerializer): relation = SerializerMethodField() class Meta(CurrentFriendsSerializer.Meta): fields = CurrentFriendsSerializer.Meta.fields + ('relation', ) def get_relation(self, instance): main_user = self.context['main_user'] # breakpoint() if not isinstance(main_user, AnonymousUser): return friend_request_status(main_user, get_friends(instance), get_subscriptions(instance), get_requested(instance)) return None