class CouponListRetrieveSerializer(DynamicFieldsModelSerializer):
user = SlugRelatedField(slug_field='name', read_only=True)
coupon = SlugRelatedField(slug_field='name', read_only=True)
class Meta:
model = Coupon
fields = '__all__'
class VehicleSaveSerializer(
ModelSerializer, EnumSupportSerializerMixin
):
model_year = SlugRelatedField(
slug_field='name',
queryset=ModelYear.objects.all()
)
make = SlugRelatedField(
slug_field='name',
queryset=Make.objects.all()
)
vehicle_class_code = SlugRelatedField(
slug_field='vehicle_class_code',
queryset=VehicleClass.objects.all()
)
vehicle_fuel_type = SlugRelatedField(
slug_field='vehicle_fuel_code',
queryset=FuelType.objects.all()
)
validation_status = EnumField(
VehicleDefinitionStatuses,
read_only=True
)
class Meta:
model = Vehicle
fields = (
'id', 'make', 'model_name', 'model_year', 'range',
'validation_status', 'vehicle_class_code', 'vehicle_fuel_type'
)
read_only_fields = ('validation_status', 'id',)
class CreditTransferContentSaveSerializer(ModelSerializer):
"""
Credit Transfer Content save serializer
"""
credit_class = SlugRelatedField(
slug_field='credit_class',
queryset=CreditClass.objects.all()
)
model_year = SlugRelatedField(
slug_field='name',
queryset=ModelYear.objects.all()
)
weight_class = SlugRelatedField(
slug_field='weight_class_code',
queryset=WeightClass.objects.all()
)
def create(self, validated_data):
credit_transfer = self.context.get('credit_transfer')
credit_transfer_content = CreditTransferContent.objects.create(
**validated_data,
credit_transfer=credit_transfer
)
return credit_transfer_content
class Meta:
model = CreditTransferContent
fields = (
'create_user', 'credit_class', 'credit_value', 'dollar_value',
'model_year', 'update_user', 'weight_class',
)
class OperationSerializer(RalphAPISerializer):
type = SlugRelatedField(
many=False,
read_only=False,
slug_field='name',
queryset=OperationType.objects.all()
)
assignee = SlugRelatedField(
many=False,
read_only=False,
slug_field='username',
queryset=RalphUser.objects.all()
)
reporter = SlugRelatedField(
many=False,
read_only=False,
slug_field='username',
queryset=RalphUser.objects.all()
)
status = SlugRelatedField(
many=False,
read_only=False,
slug_field='name',
queryset=OperationStatus.objects.all()
)
class Meta:
model = Operation
depth = 1
class MusicSerializer(HyperlinkedModelSerializer):
album = SlugRelatedField(queryset=Album.objects.all(), slug_field='title')
artist = SlugRelatedField(queryset=Artist.objects.all(), slug_field='name')
class Meta:
model = Music
fields = ('url', 'pk', 'title', 'length', 'album', 'artist')
class EquipmentInstanceDailyRiskScoreSerializer(ModelSerializer):
"""EquipmentInstanceDailyRiskScoreSerializer."""
equipment_unique_type_group = \
SlugRelatedField(
read_only=True,
slug_field='name',
many=False)
equipment_instance = \
SlugRelatedField(
read_only=True,
slug_field='name',
many=False)
class Meta:
"""Metadata."""
model = EquipmentInstanceDailyRiskScore
fields = \
'id', \
'equipment_unique_type_group', \
'equipment_instance', \
'risk_score_name', \
'date', \
'risk_score_value'
class SubmissionInstanceSerializer(ModelSerializer):
problem_id = PrimaryKeyRelatedField(source='problem',
many=False,
allow_null=False,
read_only=True)
environment = SlugRelatedField(many=False,
read_only=True,
slug_field='name')
compile_info = SlugRelatedField(many=False,
read_only=True,
slug_field='info')
test_data_status = SlugRelatedField(many=False,
read_only=True,
slug_field='status')
code = SlugRelatedField(many=False, read_only=True, slug_field='code')
class Meta:
model = Submission
exclude = ('problem', 'judge', 'client')
read_only_fields = ('time', 'memory', 'length', 'user', 'contest',
'status', 'finished', 'submit_time',
'update_time', 'ip')
def update(self, instance, validated_data):
ret = super().update(instance, validated_data)
ret.compile_info.info = ''
ret.compile_info.save()
status = {}
for test_data in instance.problem.test_data.all():
status[test_data.id] = {'time': -1, 'memory': -1, 'status': ''}
instance.test_data_status.status = status
instance.test_data_status.save()
return ret
class EquipmentSystemSerializer(ModelSerializer):
"""EquipmentSystemSerializer."""
equipment_facility = \
SlugRelatedField(
queryset=EquipmentFacility.objects.all(), read_only=False,
slug_field='name',
many=False,
required=False)
equipment_instances = \
SlugRelatedField(
queryset=EquipmentInstance.objects.all(), read_only=False,
slug_field='name',
many=True,
required=False)
class Meta:
"""Metadata."""
model = EquipmentSystem
fields = (
'id',
'equipment_facility',
'name',
'date',
'equipment_instances',
)
class SubmissionSerializer(I18nAwareModelSerializer):
submission_type = SlugRelatedField(slug_field='name', read_only=True)
track = SlugRelatedField(slug_field='name', read_only=True)
slot = SlotSerializer(TalkSlot.objects.filter(is_visible=True), read_only=True)
duration = SerializerMethodField()
speakers = SerializerMethodField()
answers = SerializerMethodField()
@property
def is_orga(self):
request = self.context.get('request')
if request:
return request.user.has_perm('orga.view_submissions', request.event)
return False
@staticmethod
def get_duration(obj):
return obj.export_duration
def get_answers(self, obj):
if self.is_orga:
return AnswerSerializer(
Answer.objects.filter(submission=obj), many=True
).data
return []
def get_speakers(self, obj):
request = self.context.get('request')
has_slots = (
obj.slots.filter(is_visible=True)
and obj.state == SubmissionStates.CONFIRMED
)
has_permission = request and request.user.has_perm(
'orga.view_speakers', request.event
)
if has_slots or has_permission:
return SubmitterSerializer(obj.speakers.all(), many=True).data
return []
class Meta:
model = Submission
fields = (
'code',
'speakers',
'title',
'submission_type',
'track',
'state',
'abstract',
'description',
'duration',
'slot_count',
'do_not_record',
'is_featured',
'content_locale',
'slot',
'image',
'answers',
)
class PlayerScoreSerializer(ModelSerializer):
player = SlugRelatedField(queryset=Player.objects.all(), slug_field='name')
game = SlugRelatedField(queryset=Game.objects.all(), slug_field='name')
class Meta:
model = PlayerScore
fields = ('url', 'pk', 'score', 'score', 'score_date', 'player',
'game')
class EventSerializer(ModelSerializer):
project = ProjectSerializer(read_only=True)
actor = UserSerializer()
patch = PatchSerializer(read_only=True)
series = SeriesSerializer(read_only=True)
cover = CoverLetterSerializer(read_only=True)
previous_state = SlugRelatedField(slug_field='slug', read_only=True)
current_state = SlugRelatedField(slug_field='slug', read_only=True)
previous_delegate = UserSerializer()
current_delegate = UserSerializer()
created_check = SerializerMethodField()
created_check = CheckSerializer()
previous_relation = PatchRelationSerializer(read_only=True)
current_relation = PatchRelationSerializer(read_only=True)
_category_map = {
Event.CATEGORY_COVER_CREATED: ['cover'],
Event.CATEGORY_PATCH_CREATED: ['patch'],
Event.CATEGORY_PATCH_COMPLETED: ['patch', 'series'],
Event.CATEGORY_PATCH_STATE_CHANGED: ['patch', 'previous_state',
'current_state'],
Event.CATEGORY_PATCH_DELEGATED: ['patch', 'previous_delegate',
'current_delegate'],
Event.CATEGORY_PATCH_RELATION_CHANGED: ['patch', 'previous_relation',
'current_relation'],
Event.CATEGORY_CHECK_CREATED: ['patch', 'created_check'],
Event.CATEGORY_SERIES_CREATED: ['series'],
Event.CATEGORY_SERIES_COMPLETED: ['series'],
}
def to_representation(self, instance):
data = super(EventSerializer, self).to_representation(instance)
payload = OrderedDict()
kept_fields = self._category_map[instance.category] + [
'id', 'category', 'project', 'date', 'actor']
for field in [x for x in data]:
if field not in kept_fields:
del data[field]
elif field in self._category_map[instance.category]:
field_name = 'check' if field == 'created_check' else field
payload[field_name] = data.pop(field)
data['payload'] = payload
return data
class Meta:
model = Event
fields = ('id', 'category', 'project', 'date', 'actor', 'patch',
'series', 'cover', 'previous_state', 'current_state',
'previous_delegate', 'current_delegate', 'created_check',
'previous_relation', 'current_relation',)
read_only_fields = fields
versioned_fields = {
'1.2': ('actor', ),
}
class PostSerializer(ModelSerializer):
category = SlugRelatedField(slug_field='name', read_only=True)
tag = SlugRelatedField(slug_field='name', many=True, read_only=True)
class Meta:
model = Post
fields = ('post_id', 'post_uuid', 'title', 'create_time',
'update_time', 'edit_time', 'status', 'is_reprint', 'is_top',
'read_count', 'greats', 'category', 'tag')
class OrderRWSerializer(ModelSerializer):
negative = SlugRelatedField(slug_field='slug',
queryset=Negative.objects.all())
print = SlugRelatedField(slug_field='id_owner',
queryset=Print.objects.all())
class Meta:
model = Order
fields = '__all__'
class EquipmentInstanceAlertPeriodSerializer(ModelSerializer):
"""EquipmentInstanceAlertPeriodSerializer."""
equipment_unique_type_group = \
SlugRelatedField(
read_only=True,
slug_field='name',
many=False)
equipment_instance = \
SlugRelatedField(
read_only=True,
slug_field='name',
many=False)
diagnosis_status = \
SlugRelatedField(
queryset=AlertDiagnosisStatus.objects.all(), read_only=False,
slug_field='name',
many=False,
required=False)
equipment_instance_alarm_periods = \
EquipmentInstanceAlarmPeriodRelatedField(
read_only=True,
many=True)
equipment_instance_problem_diagnoses = \
EquipmentInstanceProblemDiagnosisRelatedField(
read_only=True,
many=True)
class Meta:
"""Metadata."""
model = EquipmentInstanceAlertPeriod
fields = \
'id', \
'equipment_unique_type_group', \
'equipment_instance', \
'risk_score_name', \
'threshold', \
'from_date', \
'to_date', \
'duration', \
'cumulative_excess_risk_score', \
'approx_average_risk_score', \
'last_risk_score', \
'ongoing', \
'info', \
'diagnosis_status', \
'has_associated_equipment_instance_alarm_periods', \
'equipment_instance_alarm_periods', \
'has_associated_equipment_instance_problem_diagnoses', \
'equipment_instance_problem_diagnoses'
class CostListRetrieveSerializer(DynamicFieldsModelSerializer):
single_price = FloatField()
price = FloatField()
buy_time = DateTimeField(format="%Y-%m-%d %H:%M:%S")
unit = SlugRelatedField(slug_field='name', read_only=True)
costtype = SlugRelatedField(slug_field='name', read_only=True)
class Meta:
model = Cost
exclude = ['_price']
class PlantCountSerializer(ObservationGroupSerializer):
count_method = SlugRelatedField(
queryset=CountMethod.objects.all(), slug_field='code', required=False)
count_accuracy = SlugRelatedField(
queryset=CountAccuracy.objects.all(), slug_field='code', required=False)
class Meta:
model = PlantCount
fields = "__all__"
class EquipmentDataFieldSerializer(WritableNestedModelSerializer):
"""EquipmentDataFieldSerializer."""
equipment_general_type = \
SlugRelatedField(
queryset=EquipmentGeneralType.objects.all(), read_only=False,
slug_field='name',
many=False,
required=True)
equipment_data_field_type = \
SlugRelatedField(
queryset=EquipmentDataFieldType.objects.all(), read_only=False,
slug_field='name',
many=False,
required=True)
data_type = \
SlugRelatedField(
queryset=LogicalDataType.objects.all(), read_only=False,
slug_field='name',
many=False,
required=False)
numeric_measurement_unit = \
SlugRelatedField(
queryset=NumericMeasurementUnit.objects.all(), read_only=False,
slug_field='name',
many=False,
required=False)
equipment_unique_types = \
EquipmentUniqueTypeRelatedField(
queryset=EquipmentUniqueType.objects.all(), read_only=False,
many=True,
required=False)
class Meta:
"""Metadata."""
model = EquipmentDataField
fields = (
'id',
'equipment_general_type',
'name',
'equipment_data_field_type',
'logical_data_type',
'numeric_measurement_unit',
'lower_numeric_null',
'upper_numeric_null',
'min_val',
'max_val',
'equipment_unique_types',
)
class AnswerSerializer(ModelSerializer):
question = QuestionSerializer(Question.objects.all(), read_only=True)
submission = SlugRelatedField(queryset=Submission.objects.all(),
slug_field='code')
person = SlugRelatedField(queryset=User.objects.all(), slug_field='code')
options = AnswerOptionSerializer(many=True)
class Meta:
model = Answer
fields = ('id', 'question', 'answer', 'answer_file', 'submission',
'person', 'options')
class ScanRWSerializer(ModelSerializer):
negative = SlugRelatedField(slug_field='slug',
queryset=Negative.objects.all(),
required=False)
print = SlugRelatedField(slug_field='id_owner',
queryset=Print.objects.all(),
required=False)
class Meta:
model = Scan
fields = '__all__'
class PhysicalSampleSerializer(ObservationGroupSerializer):
sample_type = SlugRelatedField(
queryset=SampleType.objects.all(), slug_field="code", required=False, allow_null=True)
sample_destination = SlugRelatedField(
queryset=SampleDestination.objects.all(), slug_field="code", required=False, allow_null=True)
permit_type = SlugRelatedField(
queryset=PermitType.objects.all(), slug_field='code', required=False, allow_null=True)
class Meta:
model = PhysicalSample
fields = "__all__"
class OrderListRetrieveSerializer(DynamicFieldsModelSerializer):
revenue = FloatField()
member = SlugRelatedField(slug_field='name', read_only=True)
product = SlugRelatedField(slug_field='name', read_only=True)
sale_time = DateTimeField(format="%Y-%m-%d %H:%M:%S")
class Meta:
model = Order
exclude = [
'id',
]
class DistanceSerializer(ModelSerializer):
city1 = SlugRelatedField(queryset = City.objects.all(), slug_field='name')
city2 = SlugRelatedField(queryset = City.objects.all(), slug_field = 'name')
across = SlugRelatedField(queryset = City.objects.all(), many = True, slug_field='name')
filter_backends = (filters.DjangoFilterBackend,)
filterset_fields = ('city1', 'city2')
class Meta:
model = Distance
fields = ('url', 'city1', 'city2', 'across', 'road', 'price', 'distance')
read_only_fields = ('url', 'price', 'across')
class CitySerializer(ModelSerializer):
color = SlugRelatedField(
read_only=True,
slug_field='hex_code',
)
connections = SlugRelatedField(
read_only=True,
slug_field='name',
many=True,
)
class Meta:
model = City
fields = "__all__"
class UserSerializer(ModelSerializer):
agentUsername = SlugRelatedField(slug_field='agentUsername',
source='UserExtend',
read_only=True)
phi = SlugRelatedField(slug_field='phi',
source='UserExtend',
read_only=True)
class Meta:
model = User
fields = ('email', 'first_name', 'last_name', 'city', 'country_code',
'agentUsername', 'phi')
read_only_fields = ('email', 'agentUsername', 'phi')
class AktualneWypozyczeniaSerializer(ModelSerializer):
czytelnik = SlugRelatedField(queryset=Czytelnik.objects.all(),
slug_field="nazwisko")
ksiazka = SlugRelatedField(
queryset=Ksiazka.objects.all().exclude(czy_wypozyczona=True),
slug_field="tytul")
class Meta:
model = AktualneWypozyczenia
fields = [
'url', "idWypozyczenia", "data_wypozyczenia", "ksiazka",
"ksiazka_id", "czytelnik", 'kod_dostepu'
]
class AppointmentRequestSerializer(ModelSerializer):
creator = SlugRelatedField(
slug_field='username',
queryset=User.objects.all(),
)
staff = SlugRelatedField(
slug_field='username',
queryset=User.objects.filter(groups__name='admin'),
required=False,
)
class Meta:
model = AppointmentRequest
fields = '__all__'
class AnswerWriteSerializer(ModelSerializer):
submission = SlugRelatedField(
queryset=Submission.objects.none(),
slug_field="code",
required=False,
style={
"input_type": "text",
"base_template": "input.html"
},
)
person = SlugRelatedField(
queryset=User.objects.all(),
slug_field="code",
required=False,
style={
"input_type": "text",
"base_template": "input.html"
},
)
options = AnswerOptionSerializer(many=True, required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
request = self.context.get("request")
if not request:
return
self.fields["question"].queryset = request.event.questions.all()
self.fields["submission"].queryset = request.event.submissions.all()
self.fields["review"].queryset = request.event.reviews.all()
self.fields["review"].style = {
"input_type": "number",
"base_template": "input.html",
}
self.fields["question"].style = {
"input_type": "number",
"base_template": "input.html",
}
class Meta:
model = Answer
fields = (
"id",
"question",
"answer",
"answer_file",
"submission",
"review",
"person",
"options",
)
class SubmissionSerializer(I18nAwareModelSerializer):
submission_type = SlugRelatedField(slug_field="name", read_only=True)
track = SlugRelatedField(slug_field="name", read_only=True)
slot = SlotSerializer(TalkSlot.objects.none().filter(is_visible=True),
read_only=True)
duration = SerializerMethodField()
speakers = SerializerMethodField()
resources = ResourceSerializer(Resource.objects.none(),
read_only=True,
many=True)
@staticmethod
def get_duration(obj):
return obj.export_duration
def get_speakers(self, obj):
request = self.context.get("request")
has_slots = (obj.slots.filter(is_visible=True)
and obj.state == SubmissionStates.CONFIRMED)
has_permission = request and request.user.has_perm(
"orga.view_speakers", request.event)
if has_slots or has_permission:
return SubmitterSerializer(obj.speakers.all(),
many=True,
context={
"request": request
}).data
return []
class Meta:
model = Submission
fields = [
"code",
"speakers",
"title",
"submission_type",
"track",
"state",
"abstract",
"description",
"duration",
"slot_count",
"do_not_record",
"is_featured",
"content_locale",
"slot",
"image",
"resources",
]
class HistoriaWypozyczenSerializer(ModelSerializer):
czytelnik = SlugRelatedField(queryset=Czytelnik.objects.all(),
slug_field="nazwisko")
ksiazka = SlugRelatedField(queryset=Ksiazka.objects.all(),
slug_field="tytul")
class Meta:
model = HistoriaWypozyczen
fields = [
"idZwrot",
"data_wypozyczenia",
"data_zwrotu",
"ksiazka",
"czytelnik",
]
class DetailDatasetSerializer(BaseDatasetSerializer):
data = DataField(source='data')
policy_domains = SlugRelatedField(many=True,
slug_field='domain',
source='domains')
spatials = SlugRelatedField(required=False,
many=True,
slug_field='spatial',
source='dataset_spatials')
class Meta:
exclude = ('time_resolution', 'time_start', 'time_end', 'resource_url',
'resource_id', 'resource_issued', 'resource_publisher')
fields = ()
model = Dataset
