class QualificationSerializer(serializers.ModelSerializer):
qt = ReadOnlyField(source="qualification")
desc = ReadOnlyField(source="description")
class Meta:
model = Qualification
fields = ['qt', 'desc']
class ReaderStudySerializer(HyperlinkedModelSerializer):
questions = QuestionSerializer(many=True, read_only=True)
hanging_list_images = SerializerMethodField()
help_text = ReadOnlyField()
case_text = ReadOnlyField(source="cleaned_case_text")
class Meta:
model = ReaderStudy
fields = (
"api_url",
"slug",
"description",
"help_text",
"hanging_list_images",
"is_valid",
"pk",
"questions",
"title",
"is_educational",
"has_ground_truth",
"case_text",
"allow_answer_modification",
"allow_case_navigation",
"allow_show_all_annotations",
)
def get_hanging_list_images(self, obj: ReaderStudy):
"""Used by hanging_list_images serializer field."""
return obj.get_hanging_list_images_for_user(
user=self.context["request"].user)
class WorkSerializer(serializers.ModelSerializer):
wp = ReadOnlyField(source="workprofile")
desc = ReadOnlyField(source="description")
class Meta:
model = Work
fields = ['wp', 'desc']
class TypeSerializer(serializers.ModelSerializer):
gt = ReadOnlyField(source="key")
desc = ReadOnlyField(source="description")
class Meta:
model = Type
fields = ['gt', 'desc']
class ProviderSerializer(ModelSerializer, MetaNameSerializer):
"""Provider Serializer"""
assigned_application_slug = ReadOnlyField(source="application.slug")
assigned_application_name = ReadOnlyField(source="application.name")
component = SerializerMethodField()
def get_component(self, obj: Provider) -> str: # pragma: no cover
"""Get object component so that we know how to edit the object"""
# pyright: reportGeneralTypeIssues=false
if obj.__class__ == Provider:
return ""
return obj.component
class Meta:
model = Provider
fields = [
"pk",
"name",
"authorization_flow",
"property_mappings",
"component",
"assigned_application_slug",
"assigned_application_name",
"verbose_name",
"verbose_name_plural",
"meta_model_name",
]
class QualificationSerializer(serializers.ModelSerializer):
mob = ReadOnlyField(source="mobile")
em = ReadOnlyField(source="email")
class Meta:
model = Student
fields = ['mob', 'em']
class ApplicationSerializer(ModelSerializer):
"""Application Serializer"""
launch_url = ReadOnlyField(source="get_launch_url")
provider_obj = ProviderSerializer(source="get_provider", required=False)
meta_icon = ReadOnlyField(source="get_meta_icon")
class Meta:
model = Application
fields = [
"pk",
"name",
"slug",
"provider",
"provider_obj",
"launch_url",
"meta_launch_url",
"meta_icon",
"meta_description",
"meta_publisher",
"policy_engine_mode",
]
extra_kwargs = {
"meta_icon": {
"read_only": True
},
}
class PlayerSerializer(serializers.ModelSerializer):
user = TeamUserSerializer()
no_of_matches = ReadOnlyField(source='get_no_of_matches', default=0)
player_avg_score = ReadOnlyField(source='get_player_avg_score', default=0)
class Meta:
model = Player
fields = ['id', 'height', 'user', 'no_of_matches', 'player_avg_score']
class FriendshipRelationListSerializer(ModelSerializer):
"""Сериализатор для обработки списка заявок в друзья."""
creator = ReadOnlyField(source='creator.id')
friend_object = ReadOnlyField(source='friend_object.id')
class Meta:
model = FriendshipRelation
fields = '__all__'
class EntitySerializer(serializers.HyperlinkedModelSerializer):
street_address = ReadOnlyField()
formatted_address = ReadOnlyField()
country_full = ReadOnlyField(source='get_country_display')
class Meta:
model = Entity
fields = '__all__'
class InviteToMeSerializer(ModelSerializer):
"""Сериализатор для обработки входящих приглашений."""
creator = ReadOnlyField(source='creator.id')
room = ReadOnlyField(source='room.slug')
invite_object = ReadOnlyField(source='invite_object.id')
class Meta:
model = RoomInvite
fields = '__all__'
class PlayerSerializer(serializers.HyperlinkedModelSerializer):
logger.info('Starting player serializer!')
team = TeamSerializer()
avg_score = ReadOnlyField(source='get_stats', default=0)
no_of_matches = ReadOnlyField(source='get_no_of_matches', default=0)
players_type = ReadOnlyField(source='get_player_type', default=0)
class Meta:
model = Player
fields = ['id', 'fullname', 'height', 'team', 'avg_score', 'no_of_matches', 'players_type']
class CommentsTaskSerializer(ModelSerializer):
created_at = ReadOnlyField()
fetched_at = ReadOnlyField()
finished_at = ReadOnlyField()
status = ReadOnlyField()
status_message = ReadOnlyField()
class Meta:
model = models.CommentsTask
fields = "__all__"
class EnsembleSerializer(HyperlinkedModelSerializer):
str = ReadOnlyField(source='__str__')
html = ReadOnlyField()
type = StringRelatedField()
front_url = HyperlinkedIdentityField(view_name='ensemble_detail',
lookup_field='slug')
class Meta(object):
model = Ensemble
fields = ('id', 'str', 'html', 'type', 'front_url', 'url')
class ProxyOutpostConfigSerializer(ModelSerializer):
"""Proxy provider serializer for outposts"""
assigned_application_slug = ReadOnlyField(source="application.slug")
assigned_application_name = ReadOnlyField(source="application.name")
oidc_configuration = SerializerMethodField()
token_validity = SerializerMethodField()
scopes_to_request = SerializerMethodField()
@extend_schema_field(OpenIDConnectConfigurationSerializer)
def get_oidc_configuration(self, obj: ProxyProvider):
"""Embed OpenID Connect provider information"""
return ProviderInfoView(
request=self.context["request"]._request).get_info(obj)
def get_token_validity(self, obj: ProxyProvider) -> Optional[float]:
"""Get token validity as second count"""
return timedelta_from_string(obj.token_validity).total_seconds()
def get_scopes_to_request(self, obj: ProxyProvider) -> list[str]:
"""Get all the scope names the outpost should request,
including custom-defined ones"""
scope_names = set(
ScopeMapping.objects.filter(provider__in=[obj]).values_list(
"scope_name", flat=True))
return list(scope_names)
class Meta:
model = ProxyProvider
fields = [
"pk",
"name",
"internal_host",
"external_host",
"internal_host_ssl_validation",
"client_id",
"client_secret",
"oidc_configuration",
"cookie_secret",
"certificate",
"skip_path_regex",
"basic_auth_enabled",
"basic_auth_password_attribute",
"basic_auth_user_attribute",
"mode",
"cookie_domain",
"token_validity",
"scopes_to_request",
"assigned_application_slug",
"assigned_application_name",
]
class IndividuSerializer(HyperlinkedModelSerializer):
str = ReadOnlyField(source='__str__')
html = ReadOnlyField()
naissance = AncrageSpatioTemporelSerializer()
deces = AncrageSpatioTemporelSerializer()
professions = PrimaryKeyRelatedField(many=True, read_only=True)
front_url = HyperlinkedIdentityField(view_name='individu_detail',
lookup_field='slug')
class Meta(object):
model = Individu
fields = ('id', 'str', 'html', 'nom', 'prenoms', 'naissance', 'deces',
'professions', 'parents', 'front_url', 'url')
class ChangesetSerializerToStaff(GeoFeatureModelSerializer):
"""Serializer with all the Changeset model fields, except the
'powerfull_editor'.
"""
check_user = ReadOnlyField(source='check_user.name', default=None)
reasons = BasicSuspicionReasonsSerializer(many=True, read_only=True)
tags = BasicTagSerializer(many=True, read_only=True)
features = ReadOnlyField(source='new_features', default=list)
class Meta:
model = Changeset
geo_field = 'bbox'
exclude = ('powerfull_editor', 'new_features')
class OfficeSerializer(ModelSerializer):
instance = HyperlinkedIdentityField(view_name="office-detail")
node_pos = ReadOnlyField()
parentId = PrimaryKeyRelatedField(source="parent",
queryset=Office.objects.all())
root = PrimaryKeyRelatedField(many=False, read_only=True)
height = ReadOnlyField()
class Meta:
model = Office
fields = [
"id", "node_pos", "name", "parentId", "root", "height", "instance"
]
class MemberSerializer(serializers.ModelSerializer):
current_member = ReadOnlyField()
current_associate_member = ReadOnlyField()
current_donating_member = ReadOnlyField()
current_merit_member = ReadOnlyField()
current_honorary_member = ReadOnlyField()
class Meta:
model = Member
exclude = (
"merit_history",
"associate_member",
"donating_member",
)
class SoldItemSerializer(HyperlinkedModelSerializer):
item = ItemSerializer(many=False)
net_value = ReadOnlyField()
vat_value = ReadOnlyField()
total_value = ReadOnlyField()
total_earnings = ReadOnlyField()
class Meta:
model = SoldItem
read_only = ['net_value', 'vat_value', 'total_value', 'total_earnings']
fields = [
'url', 'item', 'units', 'trial', 'net_value', 'vat_value',
'total_value', 'total_earnings'
]
class BookListSerializer(ModelSerializer):
game = ReadOnlyField(source='game.name')
game_id = ReadOnlyField(source='game.id')
tags = TagSerializer(many=True,
allow_null=True,
read_only=True,
source='game.tags')
class Meta:
model = Book
fields = [
'id', 'title', 'edited_at', 'cover', 'game', 'tags', 'game_id',
'rating', 'price'
]
read_only_fields = ['rating']
class MenuCardSerializer(DynamicFieldsModelSerializer):
dishes = DishSerializer(many=True)
dishes_num = ReadOnlyField()
class Meta:
model = MenuCard
fields = [
"id",
"name",
"description",
"dishes",
"dishes_num",
"created",
"modified",
]
def validate_dishes(self, data):
self._validate_dish_names_and_type(data)
return data
@staticmethod
def _validate_dish_names_and_type(data):
name_food_dish = [(dish.get("name"), dish.get("food_type"))
for dish in data]
if len(name_food_dish) != len(set(name_food_dish)):
raise ValidationError("List contains duplicated dish names")
def create(self, validated_data):
dishes = validated_data.pop("dishes")
menu_card = super().create(validated_data)
for dish in dishes:
Dish.objects.create(menu_card=menu_card, **dish)
return menu_card
class TeamSerializer(serializers.ModelSerializer):
coach = TeamUserSerializer()
team_avg_score = ReadOnlyField(source='get_avg_team_score')
class Meta:
model = Team
fields = ['id', 'name', 'coach', 'team_avg_score']
class TeamSerializer(serializers.HyperlinkedModelSerializer):
logger.info('Starting team serializer!')
avg_team_score = ReadOnlyField(source='get_avg_team_score', default=0)
class Meta:
model = Team
fields = ['id','name', 'address', 'mobile', 'created_at', 'avg_team_score']
class BlacklistSerializer(ModelSerializer):
date = DateTimeField(read_only=True)
added_by = ReadOnlyField(source='added_by.username')
class Meta:
model = BlacklistedUser
fields = ('uid', 'username', 'date', 'added_by')
class RedirectSerializer(serializers.ModelSerializer):
# TODO: This needs some work, prob a custom field for destination
source = ReadOnlyField(source='old_path')
destination = ReadOnlyField(source='link')
def to_representation(self, data):
serialized_data = super(RedirectSerializer,
self).to_representation(data)
if 'http' not in serialized_data['destination']:
serialized_data['destination'] = '/oneyou{}'.format(
serialized_data['destination'])
return serialized_data
class Meta:
model = apps.get_model('wagtailredirects', 'Redirect')
fields = ('source', 'destination', 'is_permanent')
class PublicBaseDetailSerializer(BaseLocationSerializer):
opening_hours = OpeningHoursSerializer(source="openinghours_set",
required=False)
images = ReadOnlyField(default=[])
class Meta(BaseLocationSerializer.Meta):
fields = BaseLocationSerializer.Meta.fields + [
"created",
"updated",
"latitude",
"longitude",
"telephone",
"website",
"email",
"comment",
"comment_english",
"comment_opening_hours",
"comment_public_transport",
"closed",
"opening_hours",
"tags",
"attributes",
"images",
]
read_only_fields = BaseLocationSerializer.Meta.read_only_fields + [
"created",
"updated",
"images",
]
class BaseLocationSerializer(ModelSerializer):
id = ReadOnlyField(source="id_string")
class Meta:
model = BaseLocation
fields = ["id", "name", "street", "postal_code", "city", "vegan"]
read_only_fields = ["id_string"]
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 MappingTeamSerializer(ModelSerializer):
owner = ReadOnlyField(source='created_by.username', default=None)
class Meta:
model = MappingTeam
fields = ('id', 'name', 'users', 'trusted', 'owner')
read_only_fields = ('trusted', 'owner')
