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
