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