class CompanyDetailedInfoSerializer(CompanyBasicInfoSerializer):
admins = serpy.MethodField()
roles = serpy.MethodField()
website = serpy.Field()
facebook = serpy.Field()
twitter = serpy.Field()
linkedin = serpy.Field()
id = serpy.Field()
city = serpy.MethodField()
city_raw = serpy.MethodField()
def get_admins(self, instance):
from django.contrib.postgres.aggregates.general import ArrayAgg
qs = Membership.objects.filter(company_id=instance.id).select_related(
'user', 'role')
qs = qs.annotate(arr=ArrayAgg('jobs'))
return MembershipBasicInfoSerializer(qs, many=True).data
def get_roles(self, instance):
return CompanyRolesSerializer(
instance.roles.filter(company__id=instance.id), many=True).data
def get_city(self, obj):
if obj.city:
return obj.city.pk
def get_city_raw(self, obj):
if obj.city:
return ", ".join([
obj.city.name,
obj.city.region.name if obj.city.region else 'NA',
obj.city.country.name
])
class CohortSmallSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
slug = serpy.Field()
name = serpy.Field()
syllabus = SyllabusCertificateSerializer()
class HostelSerializer(serpy.Serializer):
google = HostelField()
hostelworld = HostelField()
booking = HostelField()
avg_rating = serpy.Field()
rating = serpy.Field()
reviews = ReviewSerializer(many=True)
class ServerSerializer(serpy.Serializer):
id = serpy.Field()
name = serpy.Field()
character_count = serpy.Field()
online_count = serpy.Field()
ip_address = serpy.Field()
last_sync = DatetimeToUnixField()
class PointSerializer(serpy.Serializer):
x = serpy.Field()
y = serpy.Field()
mean = serpy.MethodField()
def get_mean(self, obj):
return (obj.x + obj.y)
class EventTinySerializer(serpy.Serializer):
id = serpy.Field()
slug = serpy.Field()
title = serpy.Field()
starting_at = serpy.Field()
ending_at = serpy.Field()
event_type = EventTypeSmallSerializer()
class FoodDonationSerializers(serpy.Serializer):
id = serpy.Field()
id_stripe = serpy.Field()
food = FoodRunSerializers()
user = accounts_serializers.UserSerializers()
amount = serpy.Field()
class UserSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
first_name = serpy.Field()
last_name = serpy.Field()
email = serpy.Field()
class CompanyBasicInfoSerializer(TBLightSerializer):
name = serpy.Field()
slug = serpy.Field()
size = serpy.Field()
verified = serpy.Field()
avatar = serpy.MethodField()
gravatar_id = serpy.MethodField()
city_raw = serpy.MethodField()
def get_avatar(self, instance):
request = self.context.get('request')
if request and instance.avatar:
avatar_url = instance.avatar.url
return request.build_absolute_uri(avatar_url)
def get_gravatar_id(self, obj):
return get_user_gravatar_id(obj.owner)
def get_city_raw(self, obj):
if obj.city:
return ", ".join([
obj.city.name,
obj.city.region.name if obj.city.region else 'NA',
obj.city.country.name
])
class Meta:
model = Company
fields = '__all__'
class EntitySerializer(ModelSerializer):
"""Serializer for entities."""
name = serpy.Field()
unabbreviated_name = serpy.Field()
aliases = serpy.Field()
birth_date = serpy.MethodField('get_serialized_birth_date')
death_date = serpy.MethodField('get_serialized_death_date')
description = serpy.Field(attr='description.html', required=False)
serialized_images = serpy.Field()
categorizations = CategorizationSerializer(many=True,
attr='categorizations.all',
call=True)
def get_model(self, instance) -> str: # noqa
"""Return the model name of the instance."""
return f'entities.{instance.__class__.__name__.lower()}'
def get_serialized_birth_date(self, instance: 'Entity'):
"""Return the entity's birth date, serialized."""
return instance.birth_date.serialize() if instance.birth_date else None
def get_serialized_death_date(self, instance: 'Entity'):
"""Return the entity's death date, serialized."""
return instance.death_date.serialize() if instance.death_date else None
class GetAcademySerializer(serpy.Serializer):
id = serpy.Field()
slug = serpy.Field()
name = serpy.Field()
country = CountrySerializer(required=False)
city = CitySerializer(required=False)
logo_url = serpy.Field()
class BadgeSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
slug = serpy.Field()
name = serpy.Field()
logo_url = serpy.Field()
class DragonSerializer(serpy.Serializer):
"""Dragon serilizer."""
ip_address = serpy.Field()
worker = serpy.Field()
mac_address = serpy.Field()
overview = serpy.Field()
class UserSmallSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
first_name = serpy.Field()
last_name = serpy.Field()
profile = ProfileSmallSerializer(required=False, many=False)
class PortfolioSerializers(serpy.Serializer):
"""
This class convert user data into json
"""
id = serpy.Field()
homeless = accounts_serializers.HomelessProfileSerializers()
userRegisterer = accounts_serializers.UserSerializers()
image = serpy.MethodField()
details = serpy.Field()
def get_image(self, obj):
print('********************************************')
print(obj)
print('********************************************')
"""
With this method obtain phone number of the user
:param obj: object User
:type obj: Model User
:return: if phone number is None return None
:return: phone number
"""
if obj.image:
return obj.image.url
return None
class UserMeSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
email = serpy.Field()
first_name = serpy.Field()
last_name = serpy.Field()
github = serpy.MethodField()
profile = ProfileSerializer(required=False)
roles = serpy.MethodField()
cohorts = serpy.MethodField()
date_joined = serpy.Field()
def get_github(self, obj):
github = CredentialsGithub.objects.filter(user=obj.id).first()
if github is None:
return None
return GithubSmallSerializer(github).data
def get_roles(self, obj):
roles = ProfileAcademy.objects.filter(user=obj.id)
return ProfileAcademySmallSerializer(roles, many=True).data
def get_cohorts(self, obj):
cohorts = CohortUser.objects.filter(user__id=obj.id)
return GETCohortUserSmallSerializer(cohorts, many=True).data
class AssetMidSerializer(AssetSerializer):
solution_url = serpy.Field()
readme = serpy.Field()
interactive = serpy.Field()
with_solutions = serpy.Field()
with_video = serpy.Field()
class ClientSerializer(serpy.Serializer):
id = serpy.IntField()
client_name = serpy.Field()
client_first_name = serpy.Field()
client_last_name = serpy.Field()
client_address = serpy.Field()
client_email = serpy.Field()
client_phone_number = serpy.IntField()
class AcademySerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
name = serpy.Field()
logo_url = serpy.Field()
website_url = serpy.Field()
street_address = serpy.Field()
class GetCohortSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
slug = serpy.Field()
name = serpy.Field()
kickoff_date = serpy.Field()
certificate = GetCertificateSerializer()
academy = GetAcademySerializer()
class GetCategorySerializer(serpy.Serializer):
id = serpy.Field()
slug = serpy.Field()
name = serpy.Field()
medias = serpy.MethodField()
def get_medias(self, obj):
return Media.objects.filter(categories__id=obj.id).count()
class ProgramSerializer(serpy.Serializer):
id = serpy.IntField()
program_name = serpy.Field()
program_product = ProductSerializer()
program_client = ClientSerializer()
program_start_date = serpy.Field()
program_end_date = serpy.Field()
program_total_amount = serpy.IntField()
class GETCohortUserSmallSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
cohort = GetMeCohortSerializer()
role = serpy.Field()
finantial_status = serpy.Field()
educational_status = serpy.Field()
created_at = serpy.Field()
class SwaggerMethodSerializer(serpy.Serializer):
consumes = LiteralField(None, display_none=False)
produces = LiteralField(["application/json"])
responses = SwaggerResponseSerializer(attr='output_type')
parameters = SwaggerParamSerializer(many=True)
summary = serpy.Field()
operationId = serpy.Field(attr='id')
tags = serpy.Field()
class CardSerializerNoPending(serpy.Serializer):
id = serpy.IntField()
user = NestedUserDetail()
card_template = NestedTemplate()
value = serpy.Field()
position = serpy.Field()
created = serpy.Field()
updated = serpy.Field()
class EventCheckinSerializer(serpy.Serializer):
id = serpy.Field()
email = serpy.Field()
status = serpy.Field()
created_at = serpy.Field()
attended_at = serpy.Field()
attendee = UserSerializer(required=False)
event = EventTinySerializer()
class PlaceSerializer(GenericSerializer):
id = serpy.Field(attr='uri')
name = serpy.Field()
quality = serpy.Field(required=False)
stop_area = StopAreaSerializer(display_none=False)
stop_point = StopPointSerializer(display_none=False)
administrative_region = AdminSerializer(display_none=False)
embedded_type = EnumField(attr='embedded_type')
class UserSerializers(serpy.Serializer): """ This class convert user data into json """ id = serpy.Field() first_name = serpy.Field() last_name = serpy.Field() email = serpy.Field()
class ListOriginIssueSerializer(serializers.LightSerializer):
id = serpy.Field()
ref = serpy.Field()
subject = serpy.Field()
def to_value(self, instance):
if instance is None:
return None
return super().to_value(instance)
class SyllabusGetSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
version = serpy.Field()
course = serpy.MethodField()
updated_at = serpy.Field()
json = serpy.Field()
def get_course(self, obj):
return obj.course.slug
