class ProductSerializer(ModelSerializer): # Make related fields writeable. location = PrimaryKeyRelatedField(queryset=Location.objects.all(), required=False, allow_null=True) customer = PrimaryKeyRelatedField(queryset=Customer.objects.all()) class Meta: model = Product def validate_customer(self, value): if 'request' in self.context: user = self.context['request'].user if value.manager.pk == user.pk\ or (user.is_var_admin and user.var.pk == value.manager.var.pk)\ or (user.is_admin): return value raise ValidationError("Customer doesn't exist.") else: raise ValidationError( "Cannot set customer without a request in the context.") def validate(self, data): # Make sure the Location's Customer is the same as the Products's. location = data.get('location') if not location and self.instance: location = self.instance.location customer = data.get('customer') if not customer and self.instance: customer = self.instance.customer if location and location.customer.pk != customer.pk: raise ValidationError("`location` doesn't belong to `customer`.") return data def update(self, instance, validated_data): validated_data.pop('customer') # Don't allow changing the customer. return super(ProductSerializer, self).update(instance, validated_data)
class ProfileSerializer(ModelSerializer): username=PrimaryKeyRelatedField(queryset=User.objects.all()) class Meta: model=Profile fields=( 'id', 'username', 'bio', ) read_only_fields=['id']
class LessonSerializer(ModelSerializer): codes = CodeSerializer(many=True, read_only=True) attempts = AttemptSerializer(many=True, read_only=True, source='cur_user_attempts') next_lesson = PrimaryKeyRelatedField(many=False, read_only=True) class Meta: model = Lesson fields = ('id', 'title', 'topic', 'description', 'difficulty', 'codes', 'attempts', 'next_lesson') read_only_fields = fields
class TeamGroupPlayerSerializer(ModelSerializer): team_player = TeamPlayerSerializer(read_only=True) team_group_id = PrimaryKeyRelatedField(read_only=True) goals_scored = SerializerMethodField(read_only=True) class Meta: model = TeamGroupPlayer fields = ('id', 'goals_scored', 'points_amount', 'team_player', 'team_group_id') def get_goals_scored(self, instance): return instance.scored_goals.count()
class ProcessSerializer(HyperlinkedModelSerializer): processgroup = PrimaryKeyRelatedField(read_only=True) class Meta: model = Process fields = ( 'url', 'id', 'name', 'code', 'processgroup', )
class CustomerSerializer(ModelSerializer): manager = PrimaryKeyRelatedField(queryset=User.objects.all()) products = PrimaryKeyRelatedField(many=True, read_only=True) contracts = PrimaryKeyRelatedField(many=True, read_only=True) locations = PrimaryKeyRelatedField(many=True, read_only=True) class Meta: model = Customer def validate_manager(self, value): if 'request' in self.context: user = self.context['request'].user if value.pk == user.pk\ or (user.is_var_admin and user.var.pk == value.var.pk)\ or (user.is_admin): return value raise ValidationError("Manager doesn't exist.") else: raise ValidationError( "Cannot set manager without a request in the context.")
class ActivitySerializer(HyperlinkedModelSerializer): activitygroup = PrimaryKeyRelatedField(read_only=True) class Meta: model = Activity fields = ( 'url', 'id', 'name', 'nace', 'activitygroup', )
class RemoveAnswerSerializer(serializers.ModelSerializer): answer = PrimaryKeyRelatedField(queryset=models.Answer.objects.filter( document__isnull=False)) @transaction.atomic def update(self, instance, validated_data): instance.delete() return instance class Meta: fields = ("answer", ) model = models.Answer
class DirectorySerializer(ModelSerializer): file_ids = FileSerializer(many=True, read_only=True) shared_dirs = ShareSerializer(many=True, read_only=True) sub_directories = PrimaryKeyRelatedField(many=True, read_only=True) # directory_workflow = WorkFlowSerializers(many=True, read_only=True) class Meta: model = Directory # es_model = DirectoryIndex fields = '__all__'
class ReminderSerializer(ModelSerializer): """A class providing (de-)serialization of `Reminder` instances.""" author = PrimaryKeyRelatedField(queryset=User.objects.all()) class Meta: """Metadata defined for the Django REST Framework.""" model = Reminder fields = ( 'active', 'author', 'jump_url', 'channel_id', 'content', 'expiration', 'id', 'mentions' )
class BuilderFileSerializer(HyperlinkedModelSerializer): type = PrimaryKeyRelatedField(queryset=BuilderFileType.objects.all()) class Meta: model = BuilderFile fields = ['token', 'datafile', 'type'] def create(self, validated_data): return BuilderFile.objects.create(**validated_data) def validate(self, data): """ Validate via build """ try: errors = list() file_type = data.get('type') file = data.get('datafile') token = data.get('token') if token: content = [token] if file: content = file.read().decode('utf-8-sig').splitlines() if file and token: raise ValidationError( 'Not Allow To Provide Upload File And Single Token At Same Time' ) for i, string in enumerate(content): try: if file_type.id == 1: builder = LaborBuilder(string=string) elif file_type.id == 2: builder = SpecialtyBuilder(string=string) builder.build() builder.build(readonly=False) except Exception as e: errors.append({ 'string': string, 'index': i, 'error': e, }) if errors: raise ValidationError(errors) return data except Exception as e: raise ValidationError(e)
class Waste04Serializer(HyperlinkedModelSerializer): waste02 = PrimaryKeyRelatedField(read_only=True) class Meta: model = Waste04 fields = ( 'url', 'id', 'ewc_name', 'ewc_code', 'waste02', )
class ProductSerializer(HyperlinkedModelSerializer): currency = ChoiceField(choices=CURRENCY_CHOICES, initial="USD", required=False) description = CharField( initial="not set", required=False, style={'base_template': 'textarea.html'}, ) list_price = DecimalField(initial="0.00", required=False, allow_null=True, decimal_places=2, max_digits=32, help_text="list price of the element", validators=[MinValueValidator(0)]) vendor = PrimaryKeyRelatedField(many=False, queryset=Vendor.objects.all(), read_only=False, required=False) class Meta: model = Product fields = ( 'id', 'product_id', 'description', 'list_price', 'currency', 'tags', 'vendor', 'url', 'eox_update_time_stamp', 'end_of_sale_date', 'end_of_support_date', 'eol_ext_announcement_date', 'end_of_sw_maintenance_date', 'end_of_routine_failure_analysis', 'end_of_service_contract_renewal', 'end_of_new_service_attachment_date', 'end_of_sec_vuln_supp_date', 'eol_reference_number', 'eol_reference_url', ) extra_kwargs = { 'url': { 'lookup_field': 'id', 'view_name': 'productdb:products-detail' } } depth = 0
class DeletedMessageSerializer(ModelSerializer): """ A class providing (de-)serialization of `DeletedMessage` instances. The serializer generally requires a valid `deletion_context` to be given, which should be created beforehand. See the `DeletedMessage` model for more information. """ author = PrimaryKeyRelatedField(queryset=User.objects.all()) deletion_context = PrimaryKeyRelatedField( queryset=MessageDeletionContext.objects.all(), # This will be overridden in the `create` function # of the deletion context serializer. required=False) class Meta: """Metadata defined for the Django REST Framework.""" model = DeletedMessage fields = ('id', 'author', 'channel_id', 'content', 'embeds', 'deletion_context', 'attachments')
class VolunteerSerializer(serializers.ModelSerializer): interest_areas = PrimaryKeyRelatedField(read_only=True, many=True) class Meta: model = Volunteer fields = ('id', 'first_name', 'last_name', 'phone', 'email', 'state', 'gender', 'interest_areas', 'city', 'description', 'photo') read_only_fields = ('created_at', ) def to_representation(self, instance): representation = super(VolunteerSerializer, self).to_representation(instance) representation['interest_areas'] = VolunteeringAreaSerializer(instance.interest_areas.all(), many=True).data return representation
class InscriptionSerializer(ModelSerializer): cours = PrimaryKeyRelatedField(many=True, read_only=False, queryset=Cours.objects.all(), required=False) paiements = EmbeddedPaiementSerializer(many=True, required=False) periode = PeriodeSerializer() class Meta: model = Inscription fields = ('droit_image', 'photo', 'fiche_adhesion', 'certificat_medical', 'cours', 'paiements', 'somme_totale', 'periode')
class AssignmentSerializer(serializers.ModelSerializer): programming_classes = PrimaryKeyRelatedField( many=True, required=False, queryset=ProgrammingClass.objects.all()) class Meta: model = Assignment fields = '__all__' extra_kwargs = { 'programming_classes': { 'required': False, 'allow_empty': True } }
class NegativeRWSerializer(ModelSerializer): film = SlugRelatedField(slug_field='id_owner', queryset=Film.objects.all()) lens = SlugRelatedField(slug_field='id_owner', queryset=Lens.objects.all(), required=False) filter = PrimaryKeyRelatedField(queryset=Filter.objects.all(), required=False) teleconverter = SlugRelatedField(slug_field='id_owner', queryset=Teleconverter.objects.all(), required=False) mount_adapter = PrimaryKeyRelatedField(queryset=MountAdapter.objects.all(), required=False) exposure_program = PrimaryKeyRelatedField( queryset=ExposureProgram.objects.all(), required=False) metering_mode = PrimaryKeyRelatedField(queryset=MeteringMode.objects.all(), required=False) shutter_speed = PrimaryKeyRelatedField(queryset=ShutterSpeed.objects.all(), required=False) class Meta: model = Negative fields = '__all__'
class GameSerializer(ModelSerializer): """game serializer""" designer_name = StringRelatedField(source="designer", many=True, read_only=True) artist_name = StringRelatedField(source="artist", many=True, read_only=True) game_type_name = StringRelatedField(source="game_type", many=True, read_only=True) category_name = StringRelatedField(source="category", many=True, read_only=True) mechanic_name = StringRelatedField(source="mechanic", many=True, read_only=True) contained_in = PrimaryKeyRelatedField(many=True, read_only=True) implemented_by = PrimaryKeyRelatedField(many=True, read_only=True) alt_name = ListField(child=CharField(), required=False) image_url = ListField(child=URLField(), required=False) video_url = ListField(child=URLField(), required=False) external_link = ListField(child=URLField(), required=False) freebase_id = ListField(child=CharField(), required=False) wikidata_id = ListField(child=CharField(), required=False) wikipedia_id = ListField(child=CharField(), required=False) dbpedia_id = ListField(child=CharField(), required=False) luding_id = ListField(child=IntegerField(min_value=1), required=False) spielen_id = ListField(child=CharField(), required=False) bga_id = ListField(child=CharField(), required=False) class Meta: """meta""" model = Game fields = "__all__"
class UserSerializer(ModelSerializer): id = fields.CharField(required=False) email = fields.EmailField(required=False) username = fields.CharField(required=False) first_name = fields.CharField(required=False, allow_blank=True, allow_null=True) last_name = fields.CharField(required=False, allow_blank=True, allow_null=True) last_login = fields.DateTimeField(required=False) date_joined = fields.DateTimeField(required=False) is_active = fields.BooleanField(required=False, default=True) is_staff = fields.BooleanField(required=False, default=True) is_superuser = fields.BooleanField(required=False, default=True) groups_ids = PrimaryKeyRelatedField(required=False, many=True, read_only=False, queryset=Group.objects.all(), source='groups') permissions_ids = PrimaryKeyRelatedField( required=False, many=True, read_only=False, queryset=Permission.objects.filter( Q(content_type__app_label='QuanLyNhaSach') | Q(content_type__app_label='auth')), source='user_permissions') class Meta: model = User fields = ('id', 'username', 'email', 'first_name', 'last_name', 'last_login', 'date_joined', 'is_active', 'groups_ids', 'permissions_ids', 'is_staff', 'is_superuser') databases_always_serialize = ('id', 'username', 'email', 'first_name', 'last_name', 'last_login', 'date_joined', 'is_active', 'groups_ids', 'permissions_ids', 'is_staff', 'is_superuser')
class GroupSerializer(ModelSerializer): id = fields.CharField(required=False) name = fields.CharField(required=True) permissions_ids = PrimaryKeyRelatedField(many=True, read_only=False, queryset=Permission.objects.filter( Q(content_type__app_label='QuanLyNhaSach') | Q(content_type__app_label='auth')), source='permissions') class Meta: model = Group fields = ( 'id', 'name', 'permissions_ids') databases_always_serialize = ( 'id', 'name', 'permissions_ids')
class DeviceSerializer(serializers.ModelSerializer): """Serializer to map the Model instance into JSON format.""" device_model_id = PrimaryKeyRelatedField( queryset=DeviceModel.objects.all(), source='device_model', label="Device") class Meta: """Meta class to map serializer's fields with the model fields.""" model = Device fields = ('id', 'device_model_id', 'capacity', 'color', 'os_version') read_only_fields = ('created_at', 'updated_at')
class RemoveDefaultAnswerSerializer(serializers.ModelSerializer): question = PrimaryKeyRelatedField(queryset=models.Question.objects) @transaction.atomic def update(self, instance, validated_data): instance.default_answer.delete() return instance class Meta: fields = [ "question", ] model = models.Question
class ProfileSerializer(ModelSerializer): field = PrimaryKeyRelatedField(queryset=Field.objects.all(), default=None) class Meta: model = Profile fields = '__all__' validators = [ UniqueTogetherValidator( queryset=Profile.objects.all(), fields=('investigation', 'field', 'livestock', 'count_type', 'value'), ) ]
class EventSerializer(ModelSerializer): id = CharField(read_only=True) start = UnixEpochDateField() locations = PrimaryKeyRelatedField( many=True, pk_field=CharField(), queryset=LocationModel.objects.all().filter(deleted=False)) duration = DurationInSecondsField() category = ChoiceField(choices=EventModel.CATEGORIES) class Meta: model = EventModel fields = ('id', 'name', 'info', 'start', 'duration', 'locations', 'category', 'approved')
class UserSerializer(BulkSerializerMixin, ModelSerializer): """A class providing (de-)serialization of `User` instances.""" roles = PrimaryKeyRelatedField(many=True, queryset=Role.objects.all(), required=False) class Meta: """Metadata defined for the Django REST Framework.""" model = User fields = ('id', 'avatar_hash', 'name', 'discriminator', 'roles', 'in_guild') depth = 1
class LessonViewSet(ModelViewSet): """ API endpoint for viewing lessons """ queryset = Lesson.objects.all().order_by('id') serializer_class = LessonSerializer creator = PrimaryKeyRelatedField( # set it to read_only as we're handling the writing part ourselves read_only=True, default=CurrentUserDefault()) def perform_create(self, serializer): serializer.save(creator=self.request.user)
class SpecialJudgeField(ModelSerializer): code = CharField(write_only=True, allow_null=True, max_length=_INPUT_MAX, default="", style={'base_template': 'textarea.html'}) environment = PrimaryKeyRelatedField( queryset=Environment.objects.all(), many=False, write_only=True) class Meta: model = SpecialJudge fields = ('environment', 'code')
class DishSerializer(DynamicFieldsModelSerializer): menu_card_id = PrimaryKeyRelatedField(queryset=MenuCard.objects.all(), required=False) menu_card = SerializerMethodField() photos = DishPhotoSerializer(read_only=True, many=True) class Meta: model = Dish fields = "__all__" @staticmethod def get_menu_card(obj): if obj.menu_card: return obj.menu_card.name
class CloseOrderSerializer(ModelSerializer): order = PrimaryKeyRelatedField(read_only=True) class Meta: model = CloseOrder fields = "__all__" def create(self, validated_data): order_id = self.context["request"].data.get("order") order = Order.objects.get(pk=order_id) if order.final.exists(): raise ValueError("This order already has a Close Data") container = CloseOrder.objects.create(order=order, **validated_data) return container