class AnimalOwnerSerializer(serializers.ModelSerializer):
profile_image_base = Base64ImageField(source='profile_image',
required=False,
represent_in_base64=True)
profile_id_image_base = Base64ImageField(source='profile_id_image',
required=False,
represent_in_base64=True)
class Meta:
model = AnimalOwner
fields = (
'owner_status',
'first_name',
'last_name',
'email',
'phone_number',
'city',
'state',
'zip_code',
'origin_country',
'address',
'comment',
'profile_image_base',
'profile_id_image_base',
'registration_date',
)
class PublisherSerializer(serializers.ModelSerializer):
image = Base64ImageField()
trading_doc = Base64ImageField()
class Meta:
model = Publisher
fields = "__all__"
class TourSerializer(serializers.ModelSerializer):
"""採集行モデル用シリアライザ"""
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
start_date = serializers.DateField(required=False)
end_date = serializers.DateField(required=False)
specimens = serializers.SerializerMethodField()
collect_points = serializers.SerializerMethodField()
image1 = Base64ImageField(required=False)
image2 = Base64ImageField(required=False)
image3 = Base64ImageField(required=False)
image4 = Base64ImageField(required=False)
image5 = Base64ImageField(required=False)
def get_specimens(self, obj):
specimens_data = SpecimenForTourSerializer(Specimen.objects.all().filter(
tour=Tour.objects.get(id=obj.id)), many=True).data
return specimens_data
def get_collect_points(self, obj):
collect_points_data = CollectPointSerializer(
CollectPoint.objects.all().filter(
tour=Tour.objects.get(id=obj.id)), many=True).data
return collect_points_data
class Meta:
model = Tour
fields = ['id', 'created_at', 'user', 'title',
'start_date', 'end_date', 'track', 'note',
'image1', 'image2', 'image3', 'image4', 'image5',
'specimens', 'collect_points']
read_only_fields = ('created_at', 'id', 'user')
class AccountRequestSerializer(serializers.Serializer):
ACCOUNT_CHOICES = (
('S', 'Saving'),
('C', 'Current'),
)
GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
)
fullName = serializers.CharField(required=True);
fatherName = serializers.CharField(required=True);
motherName = serializers.CharField(required=True);
dob = serializers.DateField(required=True);
gender = serializers.ChoiceField(choices=GENDER_CHOICES,required=True);
email = serializers.EmailField(required=True);
phoneNumber = serializers.CharField(max_length=16,validators=[RegexValidator(regex=r'^\+?1?\d{9,15}$', message="Phone number must be entered in the format '+9999999'. Upto 15 digits are allowed.")])
panNumber = serializers.CharField(max_length=10, required=True);
accountType = serializers.ChoiceField(choices=ACCOUNT_CHOICES,required=True);
startingAmount = serializers.IntegerField(required=True);
addressProof = Base64ImageField(required=True);
idProof = Base64ImageField(required=True);
panCard = Base64ImageField(required=True);
def create(self, validated_data):
print (validated_data)
return AccountRequest.objects.create(**validated_data)
class UserCreateProfileSerializer(serializers.ModelSerializer):
pic = Base64ImageField(required=False)
pic_id = Base64ImageField(required=False)
class Meta:
model = Profile
fields = ('pic', 'pic_id', 'phone')
class AnimalListSerializer(serializers.ModelSerializer):
image = Base64ImageField(source='photo',
required=False,
represent_in_base64=True)
image_id = Base64ImageField(source='photo_id',
required=False,
represent_in_base64=True)
def get_age(self, obj):
return obj.age if obj.age else relativedelta(datetime.datetime.now(),
obj.date_of_birth).years
def validate_date_of_birth(self, val):
if val > datetime.datetime.now().date():
raise ValidationError(_('Date of birth can\'t be in future.'))
return val
class Meta:
model = Animal
fields = (
'id',
'name',
'date_of_birth',
'age',
'life_stage',
'gender',
'species',
'breed',
'species_details',
'origin_country',
'pregnant',
'personality',
'personality_description',
'energy_level',
'cats_friendly',
'dogs_friendly',
'animals_friendly',
'humans_friendly',
'kids_friendly',
'bites',
'for_adoption',
'for_foster',
'accommodation',
'tag_id',
'chip_producer',
'chip_id',
'join_date',
'joined_reason',
'entry_date',
'leave_reason',
'leave_date',
'history',
'image',
'image_id',
'adoption_date',
'fostering_date',
'sheltering_background',
)
class CommonImgUploadSerializer(serializers.ModelSerializer):
"""学生审课"""
chart = serializers.PrimaryKeyRelatedField(
queryset=ShoppingChart.objects.all())
order = serializers.PrimaryKeyRelatedField(queryset=Order.objects.filter(
status='CONFIRMED'))
course = serializers.PrimaryKeyRelatedField(queryset=Course.objects.all())
confirm_img = Base64ImageField(required=False)
# confirm_img = serializers.ImageField()
switch_img = Base64ImageField(required=False)
class Meta:
model = UserCourse
fields = [
'id', 'chart', 'course', 'order', 'confirm_img', 'confirm_remark',
'switch_img', 'switch_remark'
]
def validate(self, attrs):
if self.context.get(
'api_key'
) == 'student_confirm_course' and not attrs.get('confirm_img'):
raise serializers.ValidationError('审课图片为必传参数')
if self.context.get(
'api_key'
) == 'course_credit_switch' and not attrs.get('switch_img'):
raise serializers.ValidationError('学分转换证明图片为必传参数')
chart = attrs['chart']
attrs['project'] = chart.project
print(attrs, '\r\n', '*********************审课*******************')
user_course = UserCourse.objects.filter(
user=self.context['request'].user,
project=chart.project,
order=attrs['order'],
course=attrs['course']).first()
if not user_course:
raise serializers.ValidationError('未找到用户所选课程，请检查传入参数')
if self.context.get('api_key') == 'student_confirm_course':
if user_course.status == 'PASS':
raise serializers.ValidationError('审课已通过, 不能再次上传')
if self.context.get('api_key') == 'course_credit_switch':
if user_course.status != 'PASS':
raise serializers.ValidationError('审课尚未完成, 不能上传学分转换图片')
if user_course.credit_switch_status == 'SWITCHED':
raise serializers.ValidationError(
'已上传学分转换图片，状态为: %s' %
dict(UserCourse.CREDIT_SWITCH_STATUS).get(
user_course.credit_switch_status))
if user_course.credit_switch_status == 'PRE_POSTED':
raise serializers.ValidationError('成绩单尚未寄出')
return attrs
class FeaturedSerializer(serializers.ModelSerializer):
image = Base64ImageField(use_url=False, required=True)
thumbnail = Base64ImageField(use_url=False, required=False)
max_width = serializers.IntegerField()
max_height = serializers.IntegerField()
class Meta:
model = ImageModel
exclude = ('ts', )
class IssueSaveSerializer(serializers.ModelSerializer):
image = Base64ImageField(represent_in_base64=True)
thumbnail = Base64ImageField(represent_in_base64=True)
class Meta:
model = Issue
fields = ('pk', 'description', 'issueType', 'date_time_posted',
'latitude', 'longitude', 'resolved', 'posterName',
'posterPhone', 'posterEmail', 'notes', 'image', 'thumbnail')
class AttendanceSerializers(serializers.ModelSerializer):
EmployeeName = serializers.StringRelatedField(read_only=True,
source="Employee")
LocationName = serializers.StringRelatedField(source="Location")
ImageIn = Base64ImageField(required=False)
ImageOut = Base64ImageField(required=False)
class Meta:
model = Attendance
fields = "__all__"
class StaffSerializers(serializers.ModelSerializer):
PositionName = serializers.StringRelatedField(source="Position")
Image = Base64ImageField(required=False)
class Meta:
model = Staff
fields = "__all__"
class RecipeSerializer(WritableNestedModelSerializer):
keywords = KeywordSerializer(many=True, required=False)
steps = StepSerializer(many=True)
image = Base64ImageField(required=False)
class Meta:
model = Recipe
validators = []
fields = [
'id',
'name',
'slug',
'image',
'description',
'servings',
'servings_text',
'created_by',
'created_time',
'updated_time',
'working_time',
'waiting_time',
'keywords',
'steps',
]
class UserSerializer(serializers.ModelSerializer):
avatar = Base64ImageField(required=False)
class Meta:
model = User
fields = ('id', 'username', 'password', 'email', 'avatar')
extra_kwargs = {
'password': {
'write_only': True
},
'id': {
'read_only': True
}
}
def create(self, validated_data):
user = User.objects.create_user(
username=validated_data['username'],
email=validated_data['email'],
)
user.set_password(validated_data['password'])
user.save()
return user
def validate_avatar(self, value):
if value.size > settings.MAX_AVATAR_SIZE:
raise ValidationError(
f'File size can not exceed {settings.MAX_AVATAR_SIZE} bytes')
return value
class NoticiasSerializer(serializers.ModelSerializer):
imagen = Base64ImageField()
class Meta:
model = Noticias
fields = '__all__'
class QuejaSerializer(serializers.ModelSerializer):
foto = Base64ImageField()
class Meta:
model = Queja
fields = ('descripcion', 'fecha_creacion', 'foto', 'address',
'geolocation', 'user')
class FlightSerializerBarebones(serializers.ModelSerializer):
taxonomy = SpeciesSerializer(source='species')
owner = serializers.CharField(source="owner.username")
validated = serializers.BooleanField(source="isValidated", read_only=True)
ownerRole = serializers.ReadOnlyField(source='owner.flightuser.status')
lastUpdated = serializers.ReadOnlyField(source='getLastUpdated')
image = Base64ImageField(required=False, write_only=True)
class Meta:
model = Flight
fields = ('flightID', 'taxonomy', 'owner', 'ownerRole', 'latitude',
'longitude', 'radius', 'dateOfFlight', 'dateRecorded',
'image', 'confidence', 'size', 'lastUpdated', 'validated')
extra_kwargs = {
'radius': {
'write_only': True
},
'dateRecorded': {
'write_only': True
},
'comments': {
'write_only': True
},
'image': {
'write_only': True
},
'confidence': {
'write_only': True
},
'size': {
'write_only': True
},
}
class profile2Serializer(serializers.ModelSerializer):
avatar = Base64ImageField()
class Meta:
model = Profile
fields = '__all__'
class CompraSerializer(serializers.ModelSerializer):
#paquete = PaqueteSerializer(many=False, read_only=True)
uri = Base64ImageField(required=False)
class Meta:
model = Compra
fields = ('id', 'usuario', 'paquete', 'uri')
class ReplaySerializer(ModelSerializer):
image_details = Base64ImageField(required=False)
class Meta:
model = Replay
fields = '__all__'
class ImagemProdutoSerializer(serializers.ModelSerializer):
imagem = Base64ImageField()
class Meta:
model = ImagemProduto
fields = ['id', 'imagem', 'produto', 'capa']
read_only_fields = ['id']
def create(self, validated_data):
imagem = validated_data.pop('imagem')
produto = validated_data.pop('produto')
capa = validated_data.pop('capa')
imagem_produto = ImagemProduto.objects.create(
imagem=imagem, produto=produto)
if capa:
produto.imagens.update(capa=False)
imagem_produto.capa = True
imagem_produto.save()
return imagem_produto
def update(self, instance, validated_data):
instance.imagem = validated_data.get('imagem', instance.imagem)
instance.produto = validated_data.get('produto', instance.produto)
instance.capa = validated_data.get('capa', instance.capa)
if instance.capa:
produto.imagens.update(capa=False)
instance.capa = True
instance.save()
return instance
class UsuarioSerializer(serializers.ModelSerializer):
username = serializers.CharField(write_only=True,source="user.username")
password = serializers.CharField(write_only=True,source="user.password")
nombre = serializers.CharField(required=False)
apellido = serializers.CharField(required=False)
correo = serializers.CharField(required=False)
fecha_nacimiento = serializers.CharField(required=False)
descripcionEstudiante=serializers.CharField(required=False)
foto = serializers.CharField(required=False)
formacion=serializers.CharField(required=False)
perfil = serializers.PrimaryKeyRelatedField(queryset=Perfil.objects.all())
foto = Base64ImageField()
# category_name = serializers.RelatedField(source='category',read_only = True)
class Meta:
model=User
fields=('id', 'username', 'password', 'nombre', 'apellido','correo', 'fecha_nacimiento', 'descripcionEstudiante', 'formacion', 'foto', 'perfil')
def create(self, validated_data, instance = None):
user_data=validated_data.pop('user')
user=User.objects.create(**user_data)
user.set_password(user_data['password'])
user.save()
Usuario.objects.update_or_create(user = user, **validated_data)
usuario=Usuario.objects.get(user = user)
return usuario
class UserSerializer(serializers.ModelSerializer):
avatar = Base64ImageField(required=False)
class Meta:
model = User
fields = ('id', 'username', 'email', 'phone_number', 'avatar',
'auth_token')
class ProductSerializer(rest.TransformDatesMixin, serializers.ModelSerializer):
show_name = serializers.SerializerMethodField()
price_purchase = MoneyField(max_digits=10, decimal_places=2)
price_selling = MoneyField(max_digits=10, decimal_places=2)
price_selling_alt = MoneyField(max_digits=10, decimal_places=2)
price_purchase_ex = MoneyField(max_digits=10, decimal_places=2)
price_selling_ex = MoneyField(max_digits=10, decimal_places=2)
price_selling_alt_ex = MoneyField(max_digits=10, decimal_places=2)
image = Base64ImageField(required=False)
def get_show_name(self, obj):
if hasattr(obj, 'show_name'):
return obj.show_name()
return ''
class Meta:
model = models.Product
fields = ('id', 'identifier', 'show_name', 'name', 'name_short',
'unit', 'supplier', 'product_type', 'modified',
'price_purchase', 'price_selling', 'price_selling_alt',
'price_purchase_ex', 'price_selling_ex',
'price_selling_alt_ex', 'image')
class UserTestResultsSerializer(serializers.ModelSerializer):
image = Base64ImageField()
id = serializers.ReadOnlyField()
class Meta:
model = UserTestResults
fields = ('id', 'image', 'status', 'classifierResult', 'user')
class EmployeeSerializers(serializers.ModelSerializer):
DepartmentName = serializers.StringRelatedField(source="Department")
Image = Base64ImageField(required=False)
class Meta:
model = Employee
fields = "__all__"
class FlightSerializerFull(serializers.ModelSerializer):
genus = serializers.CharField(source='species.genus.name')
species = serializers.CharField(source='species.name')
comments = CommentSerializer(many=True, read_only=True)
reported_by = serializers.ReadOnlyField(source="owner.username")
user_professional = serializers.BooleanField(
source="owner.flightuser.professional", read_only=True)
user_flagged = serializers.BooleanField(source="owner.flightuser.flagged",
read_only=True)
validated = serializers.BooleanField(source="isValidated", read_only=True)
validated_by = serializers.ReadOnlyField(source="validatedBy.username",
allow_null=True)
validated_at = serializers.ReadOnlyField(source="validatedAt",
allow_null=True)
image = Base64ImageField(required=False)
weather = WeatherSerializer()
confidence_level = serializers.CharField(source="get_confidence_string")
flight_size = serializers.CharField(source="get_size_string")
class Meta:
model = Flight
fields = ('flightID', 'genus', 'species', 'confidence_level',
'dateOfFlight', 'latitude', 'longitude', 'flight_size',
'reported_by', 'user_professional', 'user_flagged',
'dateRecorded', 'validated', 'validated_by', 'validated_at',
'weather', 'comments', 'image')
# class FlightSerializerAllNested(serializers)
class ClienteSerializer(UpdateNestedMixin, serializers.ModelSerializer):
user = UserSerializer()
enderecos = EnderecoSerializer(many=True)
foto = Base64ImageField(allow_null=True, required=False)
data_nascimento = serializers.DateField(format="%d/%m/%Y")
class Meta:
model = Cliente
fields = [
'user', 'foto', 'id', 'nome', 'sobrenome', 'cpf', 'rg',
'data_nascimento', 'sexo', 'enderecos', 'carrinho'
]
read_only_fields = ['id']
def create(self, validated_data):
foto = validated_data.get('foto', None)
try:
del validated_data['foto']
except KeyError:
pass
usuario_data = validated_data.pop('user')
if not usuario_data['email']:
raise serializers.ValidationError('O campo email é obrigatório')
enderecos_data = validated_data.pop('enderecos')
user = User.objects.create_user(**usuario_data)
cliente = Cliente.objects.create(user=user,
foto=foto,
**validated_data)
for endereco_data in enderecos_data:
endereco, _ = Endereco.objects.get_or_create(**endereco_data)
cliente.enderecos.add(endereco)
cliente.save()
return cliente
class AnswerImageIOSSerializer(serializers.ModelSerializer):
image = Base64ImageField(required=False)
class Meta:
model = Assessment_answer_image
fields = ('id', 'question', 'company_assessment', 'transaction_type',
'image', 'item_no', 'is_active')
class ProductsImagesSerializers(serializers.ModelSerializer):
size = serializers.SerializerMethodField(read_only=True)
name = serializers.SerializerMethodField(read_only=True)
mime_type = serializers.SerializerMethodField(read_only=True)
image = Base64ImageField()
class Meta:
model = ProductsImages
fields = "__all__"
def create(self, validated_data):
image = validated_data.pop('image')
product = validated_data.pop('product')
return ProductsImages.objects.create(image=image, product=product)
def get_size(self, obj):
file_size = ''
if obj.image and hasattr(obj.image, 'size'):
file_size = obj.image.size
return file_size
def get_name(self, obj):
file_name = ''
if obj.image and hasattr(obj.image, 'name'):
file_name = obj.image.name
return file_name
def get_mime_type(self, obj):
mime_type = ''
if obj.image and hasattr(obj.image, 'name'):
mime_type = obj.image.name.split('.')[-1]
return mime_type
class SurveyItemSerializer(serializers.ModelSerializer):
image = Base64ImageField(required=False, use_url=False)
surveyitemvote_set = SurveyItemVoteSerializer(many=True, read_only=True)
class Meta:
model = survey_models.SurveyItem
exclude = list()
