class SimpleHyperlinkedModelSerializer(SimpleModelSerializer,
HyperlinkedModelSerializer): # pylint: disable=too-few-public-methods
'''
A REST framework `HyperlinkedModelSerializer` on dope, which automatically
initializes the Meta class of the serializer, based on the arguments
provided in the constructor.
'''
serializer_related_field = SimpleHyperlinkedRelatedField
id = ReadOnlyField()
def build_nested_field(self, field_name, relation_info, nested_depth):
"""
Create nested fields for forward and reverse relationships.
"""
class NestedSerializer(SimpleHyperlinkedModelSerializer): # pylint: disable=too-few-public-methods,missing-docstring
class Meta: # pylint: disable=too-few-public-methods,missing-docstring
model = relation_info.related_model
depth = nested_depth - 1
fields = '__all__'
field_class = NestedSerializer
field_kwargs = get_nested_relation_kwargs(relation_info)
return field_class, field_kwargs
class IngredientListSerializer(ModelSerializer):
# def get_absolute_url(self):
# return reverse("ingredients:detail", kwargs={"slug": self.slug})
# similar to above one
# typeofingredient = serializers.RelatedField(many=True)
typeofingredient = ReadOnlyField(source='typeofingredient.name',
default=None)
url = HyperlinkedIdentityField(
view_name='ingredients-api:detail', lookup_field='slug'
) #we can put this outside so that it can be used by all
# delete_url = HyperlinkedIdentityField(
# view_name='ingredients-api:delete',
# lookup_field = 'slug'
# )
#url_page = ingredient_detail_url_page
# image = SerializerMethodField()
# markdown = SerializerMethodField()
# user = SerializerMethodField()
# def get_typeofingredient(self, obj):
# if obj.typeofingredient:
# return obj.typeofingredient_name
# return -1
class Meta:
model = Ingredient
fields = '__all__'
class PlayerSerializer(HyperlinkedModelSerializer):
id = ReadOnlyField()
class Meta:
model = Player
exclude = ['replay']
class ThreadListSerializer(ModelSerializer):
blurb = ReadOnlyField()
poster = ProfileDetailSerializer(read_only=True)
class Meta:
image = SerializerMethodField()
model = Thread
fields = [
'id',
'bid',
'title',
'blurb',
'views',
'replyCount',
'imageCount',
'created',
'poster',
'board',
'image',
]
def get_image(self, obj):
try:
image = obj.image.url
except:
image = None
return image
class PostSerializer(BaseSerializer):
image = ReadOnlyField()
class Meta:
model = Post
fields = ['id', 'title', 'text', 'image']
extra_kwargs = {'post_related_user': {'read_only': True}}
class RestaurantCreateUpdateSerializer(ModelSerializer):
owner = ReadOnlyField(source='owner.username')
class Meta:
model = Restaurant
read_only = ('id',)
fields = ('owner','name','address','city','phone_number','owner_email','opening_status','website','features','timings',
'image','facebook_page','twitter_handle','other_details','is_parking','is_wifi',)
class PolicyTaskStatusSerializer(ModelSerializer):
hostname = ReadOnlyField(source="agent.hostname")
class Meta:
model = AutomatedTask
fields = "__all__"
class StateSerializer(ModelSerializer):
value = ReadOnlyField(source="name")
class Meta:
model = State
fields = ('value', 'id')
class CitySerializer(ModelSerializer):
value = ReadOnlyField(source="name")
class Meta:
model = City
fields = ('value', 'id')
class SearchStreetSerializer(ModelSerializer):
value = ReadOnlyField(source='full_street')
class Meta:
model = Street
fields = ('value', 'id')
class RegisterSerializer(ModelSerializer):
profile_id = ReadOnlyField(source="profile.id")
class Meta:
model = User
fields = [
'username',
'email',
'password',
'first_name',
'profile_id',
]
extra_kwargs = {'password': {'write_only': True}}
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
first_name = validated_data['first_name']
user = User.objects.create_user(username=username,
email=email,
first_name=first_name,
password=validated_data['password'])
return user
class CartLineSerializer(ModelSerializer):
product_name = ReadOnlyField(source='product.name')
product_slug = ReadOnlyField(source='product.slug')
price = ReadOnlyField(source='product.price')
discount_price = ReadOnlyField(source='product.discount_price')
class Meta:
model = CartLine
fields = (
'id',
'product_name',
'product_slug',
'price',
'discount_price',
'quantity',
)
class PopSerializer(ModelSerializer):
devices = StringRelatedField(many=True, read_only=True)
zone_name = ReadOnlyField(source='zone.name')
class Meta:
model = Pop
fields = ['name', 'zone_name', 'id', 'zone', 'devices']
class FileSerializer(serializers.ModelSerializer):
auth_username = ReadOnlyField(source='owner.username')
file = serializers.FileField(use_url = True)
class Meta:
model = File
fields = '__all__'
class TestSerializer(ModelSerializer):
questions_count = SerializerMethodField()
comments = SerializerMethodField()
questions = QuestionSerializer(many=True, read_only=True)
user = ReadOnlyField(source='user.username')
class Meta:
model = TestModel
fields = [
'id',
'user',
'title',
'description',
'questions_count',
'mark',
'is_public',
'comments',
'questions',
]
def get_questions(self, obj):
qs = QuestionModel.objects.filter(
test=obj.id) #filter(content_type = obj.__class__)
questions = QuestionSerializer(qs, many=True).data
return questions
def get_questions_count(self, obj):
qs = QuestionModel.objects.filter(test=obj.id)
return len(qs)
def get_comments(self, obj):
qs = CommentModel.objects.filter(object_id=obj.id)
return CommentDetailSerializer(qs, many=True).data
class CountrySerializer(ModelSerializer):
value = ReadOnlyField(source="name")
class Meta:
model = Country
fields = ('value', 'currency', 'id')
class ApplicationSerializer(ModelSerializer):
api_key = ReadOnlyField()
class Meta:
model = Application
fields = "__all__"
class CardSerializer(ModelSerializer):
user = ReadOnlyField(source='user.username')
# user = UserSerializer() -> 무한으로 list가 출력됨..!!!
class Meta:
model = Card
fields = ['id', 'user', 'date', 'content']
class SolicitudDeAuxilioSerializer(ModelSerializer):
generador = ReadOnlyField(source='generador.username')
class Meta:
model = SolicitudDeAuxilio
fields = ['id', 'fecha', 'nombre', 'sexo', 'cantidad_pacientes', 'ubicacion', 'ubicacion_especifica', 'latitud_gps', 'longitud_gps', 'contacto', 'motivo', 'observaciones', 'origen', 'generador']
extra_kwargs = { 'motivo': {'error_messages': {'required': 'Debe ingresar al menos un motivo'}} }
class ProfessorSerializer(serializers.HyperlinkedModelSerializer):
user_id = ReadOnlyField(source='user.id')
first_name = CharField(source='user.first_name')
email = CharField(source='user.email')
ativo = BooleanField(source='user.is_active')
class Meta:
model = Profile
depth = 1
fields = ('id', 'slug', 'ativo', 'data_nascimento', 'rg', 'cpf',
'first_name', 'email', 'endereco', 'user_id')
def get_full_name(self, obj):
request = self.context['request']
return request.user.get_full_name()
def update(self, instance, validated_data):
# First, update the User
user_data = validated_data.pop('user', {})
for attr, value in user_data.items():
setattr(instance.user, attr, value)
# Then, update UserProfile
for attr, value in validated_data.items():
print(validated_data)
setattr(instance, attr, value)
instance.save()
return instance
class BoardSerializer(ModelSerializer):
total_pins = ReadOnlyField()
pins = PinSerializer(many=True, required=False)
class Meta:
model = Board
fields = "__all__"
class CreatedModifiedByModelSerializerV2(ModelSerializer):
modified_on = ReadOnlyField()
created_on = ReadOnlyField()
modified_by_id = serializers.UUIDField(allow_null=True, required=False)
created_by_id = serializers.UUIDField(allow_null=True, required=False)
modified_by = serializers.CharField(read_only=True, required=False)
created_by = serializers.CharField(read_only=True, required=False)
def create(self, validated_data):
return super(CreatedModifiedByModelSerializerV2,
self).create(validated_data)
def update(self, instance, validated_data):
return super(CreatedModifiedByModelSerializerV2,
self).update(instance, validated_data)
class PostAdminSerializer(BaseSerializer):
image = ReadOnlyField()
class Meta:
model = Post
fields = '__all__'
extra_kwargs = {'post_related_user': {'read_only': True}}
class UsersSerializer(ModelSerializer):
password = CharField(write_only=True)
id = ReadOnlyField()
class Meta:
model = get_user_model()
fields = ('id', 'address', 'fio', 'password')
def create(self, validated_data):
'''создание пользователя'''
modifed_validated_data = {
'address': validated_data.get('address', None),
'username': validated_data.get('address', None),
'fio': validated_data.get('fio', None),
'password': validated_data.get('password', None)
}
try:
user = User.objects.create_user(**modifed_validated_data)
Basket.objects.create(user_id=user)
except Exception as e:
print(str(e))
raise ValidationError({'address': [str(e).split(':')[0], ]})
return user
def update(self, instance, validated_data):
'''обновление пользователя'''
user_addr = validated_data.get('address', instance.address)
instance.fio = validated_data.get('fio', instance.fio)
instance.address = user_addr
instance.username = user_addr
if validated_data.get('password', False):
instance.set_password(validated_data['password'])
instance.save()
return instance
class ProductSerializer(ModelSerializer):
space = ReadOnlyField(source='space.name')
class Meta:
model = Product
fields = ('uid', 'title', 'space', 'price', 'logo_url', 'react_good',
'react_bad', 'react_fake')
class EmployeeLeaveListSerializer(ModelSerializer):
# url = leave_detail_url
user = ReadOnlyField(source='emp_LeaveUser.username')
class Meta:
model = LeaveModel
fields = [
# 'url',
'id',
'user',
'emp_LeaveUser',
'emp_leavedate',
'emp_leavesanction',
]
extra_kwargs = {
'emp_LeaveUser': {
'read_only': True
},
'emp_leavedate': {
'read_only': True
},
'emp_LeaveUser': {
'read_only': True
}
}
class TimetableSerializer(ModelSerializer):
faculty_id = ReadOnlyField(source='get_faculty')
class Meta:
model = Timetable
fields = ('id', 'type_of_week', 'subgroup_id', 'faculty_id')
read_only_fields = ('id', 'type_of_week', 'subgroup_id', 'faculty_id')
class TweetResponseSerializer(ModelSerializer):
username = ReadOnlyField(source='user.username', read_only=True)
class Meta:
model = TweetResponse
fields = ('id', 'user', 'tweet', 'text', 'created_at', 'username')
class PolicyCheckStatusSerializer(ModelSerializer):
hostname = ReadOnlyField(source="agent.hostname")
class Meta:
model = Check
fields = "__all__"
class ReadOnlyOrderSerializer(Serializer):
id = IntegerField()
store = StoreSerializer()
user = ReadOnlyField(source="user_id")
date = DateTimeField()
paid_amount = FloatField()
status = CharField()
