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
