class UniversityRetrieveSerializer(serializers.ModelSerializer):
grade = serializers.ReadOnlyField(source='get_grade')
professors_count = serializers.ReadOnlyField(source='count')
departments = serializers.SerializerMethodField()
extra_info = serializers.SerializerMethodField()
emblem = serializers.ImageField(use_url=False)
def get_departments(self, university):
request = self.context.get('request', None)
department_slug = request.GET.get('department')
queryset = Department.objects.all()
context = {'request': request, 'university': university}
if department_slug:
department = get_object_or_404(queryset, slug=department_slug)
serializer = DepartmentRetrieveSerializer(instance=department,
context=context)
else:
serializer = DepartmentSerializer(instance=queryset,
many=True,
context=context)
return serializer.data
def get_extra_info(self, university):
extra_info = {}
request = self.context.get('request', None)
context = {'request': request}
professors = Professor.objects.filter(
university=university, score__gt=0).select_related('university')
comments = Comment.objects.filter(
professor__in=professors).select_related('created_by').exclude(
body__exact='').order_by('-created_at', '-id')[:5]
hi_professors = professors.order_by('-score')[:5]
low_professors = professors.order_by('score')[:5]
extra_info = {
'hi_professors':
ProfessorListSerializer(instance=hi_professors,
context=context,
many=True).data,
'low_professors':
ProfessorListSerializer(instance=low_professors,
context=context,
many=True).data,
'recent_comments':
CommentSerializer(instance=comments, many=True).data
}
return extra_info
class Meta:
model = University
fields = (
'id',
'name',
'slug',
'city',
'emblem',
'grade',
'professors_count',
'extra_info',
'departments',
)
lookup_field = 'slug'
extra_kwargs = {'url': {'lookup_field': 'slug'}}
class MovieSerializer(serializers.ModelSerializer): image = serializers.ImageField(max_length=None,use_url=True) class Meta: model = Moviedata fields = ['id','name','duration','rating','typ','image']
class PictureSerializer(serializers.ModelSerializer):
thumbnail = serializers.ImageField(read_only=True)
class Meta:
model = Pictures
fields = ['profile', 'thumbnail']
class UserProfileSerializer(PublicUserProfileSerializer):
picture_upload = serializers.ImageField(use_url=True, write_only=True)
class Meta(PublicUserProfileSerializer.Meta):
fields = PublicUserProfileSerializer.Meta.fields + (
'display_name', 'email', 'deleted', 'last_login', 'picture_upload',
'last_login_ip', 'read_dev_agreement', 'is_verified',
)
writeable_fields = (
'biography', 'display_name', 'homepage', 'location', 'occupation',
'picture_upload', 'username',
)
read_only_fields = tuple(set(fields) - set(writeable_fields))
def validate_biography(self, value):
if has_links(clean_nl(unicode(value))):
# There's some links, we don't want them.
raise serializers.ValidationError(
ugettext(u'No links are allowed.'))
return value
def validate_display_name(self, value):
if DeniedName.blocked(value):
raise serializers.ValidationError(
ugettext(u'This display name cannot be used.'))
return value
def validate_username(self, value):
# All-digits usernames are disallowed since they can be confused for
# user IDs in URLs.
if value.isdigit():
raise serializers.ValidationError(
ugettext(u'Usernames cannot contain only digits.'))
slug_validator(
value, lower=False,
message=ugettext(u'Enter a valid username consisting of letters, '
u'numbers, underscores or hyphens.'))
if DeniedName.blocked(value):
raise serializers.ValidationError(
ugettext(u'This username cannot be used.'))
# Bug 858452. Remove this check when collation of the username
# column is changed to case insensitive.
if (UserProfile.objects.exclude(id=self.instance.id)
.filter(username__iexact=value).exists()):
raise serializers.ValidationError(
ugettext(u'This username is already in use.'))
return value
def validate_picture_upload(self, value):
if value.content_type not in ('image/png', 'image/jpeg'):
raise serializers.ValidationError(
ugettext(u'Images must be either PNG or JPG.'))
if value.size > settings.MAX_PHOTO_UPLOAD_SIZE:
raise serializers.ValidationError(
ugettext(u'Please use images smaller than %dMB.' %
(settings.MAX_PHOTO_UPLOAD_SIZE / 1024 / 1024 - 1)))
return value
def update(self, instance, validated_data):
instance = super(UserProfileSerializer, self).update(
instance, validated_data)
photo = validated_data.get('picture_upload')
if photo:
tmp_destination = instance.picture_path + '__unconverted'
with default_storage.open(tmp_destination, 'wb') as temp_file:
for chunk in photo.chunks():
temp_file.write(chunk)
instance.update(picture_type=photo.content_type)
resize_photo.delay(tmp_destination, instance.picture_path,
set_modified_on=[instance])
return instance
class CreatePostSerializer(serializers.ModelSerializer):
filename = serializers.ListField(child=serializers.ImageField(
allow_empty_file=False))
class Meta:
model = AccountPost
fields = [
'account', 'caption', 'recommendation_name', 'recommendation_type',
'recommendation_phone_iso_code', 'recommendation_phone_dial_code',
'recommendation_phone_number', 'url', 'url_action_text',
'location_name', 'latitude', 'longitude', 'filename', 'post_type'
]
def create(self, validated_data):
account = self.validated_data['account']
caption = self.validated_data['caption']
recommendation_name = self.validated_data.get('recommendation_name',
None)
recommendation_type = self.validated_data.get('recommendation_type',
None)
recommendation_phone_iso_code = self.validated_data.get(
'recommendation_phone_iso_code', None)
recommendation_phone_dial_code = self.validated_data.get(
'recommendation_phone_dial_code', None)
recommendation_phone_number = self.validated_data.get(
'recommendation_phone_number', None)
post_type = self.validated_data.get('post_type', None)
url = self.validated_data.get('url', None)
url_action_text = self.validated_data.get('url_action_text', None)
location_name = self.validated_data.get('location_name', None)
latitude = self.validated_data.get('latitude', None)
longitude = self.validated_data.get('longitude', None)
filename = validated_data.pop('filename')
# validate filename
if len(filename) > 10:
raise serializers.ValidationError(
{'filename': ['exceeded the number of upload files']})
# save post
windowshoppi_post = AccountPost.objects.create(
account=account,
caption=caption,
recommendation_name=recommendation_name,
recommendation_type=recommendation_type,
recommendation_phone_iso_code=recommendation_phone_iso_code,
recommendation_phone_dial_code=recommendation_phone_dial_code,
recommendation_phone_number=recommendation_phone_number,
url=url,
url_action_text=url_action_text,
location_name=location_name,
latitude=latitude,
longitude=longitude,
post_type=post_type)
try:
for image in filename:
PostImage.objects.create(post=windowshoppi_post,
filename=image)
# check if url is saved
if windowshoppi_post.url:
# verify url
verify_url(windowshoppi_post.id)
return {'id': windowshoppi_post.id}
except:
# make uploaded post inactive if error happen on uploading image(s)
windowshoppi_post.active = False
windowshoppi_post.error_happened_on_uploading_image = True
windowshoppi_post.save()
return 'error_occurred'
class TempAppImagesSerializer(ModelSerializer):
app_images = serializers.ImageField(max_length=None, use_url='app_images')
class Meta:
model = TempAppImgs
fields = ['id', 'app', 'app_images']
class MiniSliderOfferEngravingSerializer(serializers.ModelSerializer):
image_thumbnail = serializers.ImageField()
class Meta:
model = MiniSliderOfferEngraving
fields = ('id','title', 'image', 'image_thumbnail')
class CommunityPostImageSerializer(serializers.ModelSerializer):
image = serializers.ImageField(read_only=True)
class Meta:
model = PostImage
fields = ('image', 'width', 'height')
class ProfileSerializer(serializers.ModelSerializer):
email = serializers.CharField(source='user.email', read_only=True)
skills = serializers.PrimaryKeyRelatedField(many=True, read_only=False, queryset=Skill.objects.all())
#skills = SkillSerializer(many = True,required= False, read_only=True)
#values = ValueSerializer(many = True,required = False)
#following = UserCompactSerializer(many=True, required = False, read_only = True)
following_count = serializers.SerializerMethodField()
followers = UserCompactSerializer(many = True, required=False)
followers_count = serializers.SerializerMethodField()
avatar = serializers.ImageField(source='user.avatar.avatar', read_only = True)
me_following = serializers.SerializerMethodField()
def get_following_count(self, profile):
return profile.following.filter(profile__deactivated_at__isnull=True).count()
def get_followers_count(self, profile):
return User.objects.filter(profile__following__id__contains=profile.user.id).count()
def get_me_following(self, profile):
if(self.context.get('request').user.profile.following.filter(id=profile.id).exists()):
return True
else:
return False
""" def update(self, instance, validated_data):
skills_data = []
values_data = []
askills_data = []
print("@@@@@@@@@@@@@",validated_data.keys())
if('skills' in validated_data.keys()):
skills_data = validated_data.pop('skills')
print("***************",skills_data)
if('values' in validated_data.keys()):
values_data = validated_data.pop('values')
print("################",values_data)
instance = super().update(instance, validated_data)
if(len(skills_data)>0):
instance.skills.set([])
for skill_data in skills_data:
nskills = Skill.objects.filter(id=skill_data.id)
if(nskills.exists()):
nskill = nskills.first()
instance.skills.add(nskill)
if(len(askills_data)>0):
instance.askills.set([])
for askill_data in askills_data:
naskills = Skill.objects.filter(id=askill_data.id)
if(naskills.exists()):
naskill = naskills.first()
instance.askills.add(naskill)
if(len(values_data)>0):
instance.values.set([])
for value_data in values_data:
nvalues = Value.objects.filter(id=value_data.id)
if(nvalues.exists()):
nvalue = nvalues.first()
instance.values.add(nvalue)
return instance """
""" def update(self, instance, validated_data):
skills = validated_data.pop('skills', [])
instance = super().update(instance, validated_data)
for skill_data in skills:
skill = Skill.objects.get(title=skill_data.get('title'))
instance.skills.add(skill)
values = validated_data.pop('values', [])
instance = super().update(instance, validated_data)
for value_data in values:
value = Value.objects.get(title=value_data.get('title'))
instance.values.add(value)
return instance """
class Meta:
model = Profile
fields = ['askills','me_following','id','firstname','lastname','email','gender','birthdate','bio','phone','city','languages','skills','values','q1','q2','q3','pic','highested','designation','tandcversion','avatar','completed_at','followers', 'following', 'followers_count', 'following_count','institution','state', 'company']
class UploadSerializer(serializers.Serializer):
upload = serializers.ImageField(required=True)
class RegisterGuideSerializer(serializers.Serializer):
name = serializers.CharField(allow_null=True)
age = serializers.IntegerField(allow_null=True)
language = serializers.CharField(allow_null=True)
photo = serializers.ImageField(allow_null=True)
about = serializers.CharField(allow_null=True)
mail = serializers.EmailField(allow_null=True)
phone = serializers.CharField()
guide_format = serializers.CharField()
def create(self, validated_data):
this_password = str(random.randint(100000000, 999999999))
user = User.objects.create_user(username=validated_data['phone'],
email=validated_data['mail'],
password=this_password)
register_data = UserRegisterData.objects.create(
user=user,
code=str(random.randint(100000, 999999)),
status='code',
user_password=this_password)
tourist_info = TouristInfo.objects.create(
user=user,
reminder=False,
news=False,
notifications=False,
guide=True,
name=validated_data['name'],
photo=None,
mail=validated_data['mail'],
phone=validated_data['phone'],
admin_status='new')
guide_info = GuideInfo.objects.create(
user=user,
name=validated_data['name'],
age=validated_data['age'],
language=validated_data['language'],
guide_format=validated_data['guide_format'],
photo=validated_data['photo'],
about=validated_data['about'],
mail=validated_data['mail'],
phone=validated_data['phone'],
admin_status='new',
reminder=False,
news=False,
notifications=False)
photo = None
try:
photo = guide_info.photo.path
except:
photo = None
print(photo)
if photo != None:
open_file = open(str(photo), "rb")
django_open = File(open_file)
#узнать формат фото
photo_format = ''
for i in range(1, len(photo)):
if photo[len(photo) - i] == '.':
break
else:
photo_format = photo[len(photo) - i] + photo_format
tourist_info.photo.save('hz.' + photo_format,
django_open,
save=True)
tourist_info.save()
return register_data
def update(self, instance, validated_data):
instance.name = validated_data['name']
instance.age = validated_data['age']
instance.language = validated_data['language']
instance.photo = validated_data['photo']
instance.about = validated_data['about']
instance.guide_format = validated_data['guide_format']
instance.save()
return instance
class ImagePostSerializer(serializers.Serializer):
file = serializers.ImageField(max_length=None, allow_empty_file=False)
tags = serializers.CharField(max_length=200,
allow_blank=True,
required=False)
class ImageUploadSerializer(serializers.ModelSerializer):
image = serializers.ImageField(use_url=True)
class Meta:
model = ImageUpload
fields = ('url', 'pk', 'title', 'image')
class UserDetailsSerializer(serializers.ModelSerializer):
posts = PostSerializer(many=True, read_only=True)
email_status = serializers.SerializerMethodField()
avatar_url = serializers.SerializerMethodField()
profile = ProfileSerializer()
avatar = serializers.ImageField(write_only=True, required=False)
class Meta:
model = UserModel
fields = ('username', 'email', 'email_status', 'profile', 'avatar',
'avatar_url', 'posts')
def get_email_status(self, obj):
email_address = EmailAddress.objects.get(user=obj)
return email_address.verified
def get_avatar_url(self, obj, size=settings.AVATAR_DEFAULT_SIZE):
for provider_path in settings.AVATAR_PROVIDERS:
provider = import_string(provider_path)
avatar_url = provider.get_avatar_url(obj, size)
if avatar_url:
return self.context['request'].build_absolute_uri(avatar_url)
def validate_name(self, name):
pattern = "^[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي]+[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي]+[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي]*$"
compiler = re.compile(pattern)
if not compiler.match(name):
raise serializers.ValidationError(
_("Make sure it contains only letters and spaces."))
return name
def validate_avatar(self, avatar):
if settings.AVATAR_ALLOWED_FILE_EXTS:
root, ext = os.path.splitext(avatar.name.lower())
if ext not in settings.AVATAR_ALLOWED_FILE_EXTS:
valid_exts = ", ".join(settings.AVATAR_ALLOWED_FILE_EXTS)
error = _("%(ext)s is an invalid file extension. "
"Authorized extensions are : %(valid_exts_list)s")
raise serializers.ValidationError(error % {
'ext': ext,
'valid_exts_list': valid_exts
})
if avatar.size > settings.AVATAR_MAX_SIZE:
error = _("Your file is too big: %(size)s, "
"the maximum allowed size is: %(max_valid_size)s")
raise serializers.ValidationError(
error % {
'size': filesizeformat(avatar.size),
'max_valid_size': filesizeformat(settings.AVATAR_MAX_SIZE)
})
def validate_email(self, email):
email = get_adapter().clean_email(email)
if email and email_address_exists(
email, exclude_user=self.context.get('request').user):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address."))
return email
def update(self, instance, validated_data):
request = self.context.get('request')
profile = validated_data.get('profile', None)
instance.username = validated_data.get('username', instance.username)
instance.first_name = validated_data.get('first_name',
instance.first_name)
if profile:
bio = profile.get("bio")
location = profile.get("location")
birth_date = profile.get("birth_date")
first_name = profile.get("first_name")
last_name = profile.get("last_name")
if bio and bio != instance.profile.bio:
instance.profile.bio = bio
if location and location != instance.profile.location:
instance.profile.location = location
if birth_date and birth_date != instance.profile.birth_date:
instance.profile.birth_date = birth_date
if first_name and first_name != instance.profile.first_name:
instance.profile.first_name = first_name
if last_name and last_name != instance.profile.last_name:
instance.profile.last_name = last_name
email = validated_data.get('email', None)
if email and email != instance.email:
adapter = get_adapter()
adapter.send_mail('account/email/email_change', instance.email, {})
email_address = EmailAddress.objects.get(user=instance,
verified=True)
email_address.change(request, email, True)
instance.email = email
if 'avatar' in request.FILES:
avatar = Avatar(user=instance, primary=True)
image_file = request.FILES['avatar']
avatar.avatar.save(image_file.name, image_file)
avatar.save()
avatar_updated.send(sender=Avatar, user=instance, avatar=avatar)
instance.save()
# sync_sso(instance)
return instance
class ProductSerializer(serializers.ModelSerializer):
is_on_sale = serializers.BooleanField(read_only=True)
current_price = serializers.FloatField(read_only=True)
description = serializers.CharField(min_length=2, max_length=200)
cart_items = serializers.SerializerMethodField()
#price = serializers.FloatField(min_value=1.00, max_value=100000)
price = serializers.DecimalField(
min_value=1.00,
max_value=100000,
max_digits=None,
decimal_places=2,
)
sale_start = serializers.DateTimeField(
required=False,
input_formats=['%I:%M %p %d %B %Y'],
format=None,
allow_null=True,
help_text='Accepted format is "12:01 PM 16 April 2019"',
style={
'input_type': 'text',
'placeholder': '12:01 AM 28 July 2019'
},
)
sale_end = serializers.DateTimeField(
required=False,
input_formats=['%I:%M %p %d %B %Y'],
format=None,
allow_null=True,
help_text='Accepted format is "12:01 PM 16 April 2019"',
style={
'input_type': 'text',
'placeholder': '12:01 AM 28 July 2019'
},
)
photo = serializers.ImageField(default=None)
warranty = serializers.FileField(write_only=True, default=None)
class Meta:
model = Product
fields = (
'id',
'name',
'description',
'price',
'sale_start',
'sale_end',
'is_on_sale',
'current_price',
'cart_items',
'photo',
'warranty',
)
def get_cart_items(self, instance):
items = ShoppingCartItem.objects.filter(product=instance)
return CartItemSerializer(items, many=True).data
# def to_representation(self, instance):
# data = super().to_representation(instance)
# data['is_on_sale'] = instance.is_on_sale()
# data['current_price'] = instance.current_price()
# return data
def update(self, instance, validated_data):
if validated_data.get('warranty', None):
instance.description += '\n\nWarranty Information:\n'
instance.description += b'; '.join(
validated_data['warranty'].readlines()).decode()
return super().update(instance, validated_data)
def create(self, validated_data):
validated_data.pop('warranty')
return Product.objects.create(**validated_data)
class SignalCreateSerializer(serializers.ModelSerializer):
location = _NestedLocationModelSerializer()
reporter = _NestedReporterModelSerializer()
status = _NestedStatusModelSerializer()
category = _NestedCategoryModelSerializer(source='category_assignment')
priority = _NestedPriorityModelSerializer(required=False, read_only=True)
image = serializers.ImageField(source='image_crop', read_only=True)
incident_date_start = serializers.DateTimeField()
class Meta(object):
model = Signal
fields = (
'id',
'signal_id',
'source',
'image',
'text',
'text_extra',
'status',
'location',
'category',
'reporter',
'priority',
'created_at',
'updated_at',
'incident_date_start',
'incident_date_end',
'operational_date',
'extra_properties',
)
read_only_fields = (
'id',
'signal_id',
'created_at',
'updated_at',
)
extra_kwargs = {
'id': {
'label': 'ID'
},
'signal_id': {
'label': 'SIGNAL_ID'
},
# Because we want to disable V0 on short term we use the V1 validator for now
'extra_properties': {
'validators': [
ExtraPropertiesValidator(filename=os.path.join(
os.path.dirname(__file__), '..', 'v1', 'json_schema',
'extra_properties.json'))
]
}, # noqa
}
def create(self, validated_data):
status_data = validated_data.pop('status')
location_data = validated_data.pop('location')
reporter_data = validated_data.pop('reporter')
category_assignment_data = validated_data.pop('category_assignment')
image = validated_data.pop('image', None)
signal = Signal.actions.create_initial(validated_data, location_data,
status_data,
category_assignment_data,
reporter_data)
if image:
Signal.actions.add_image(image, signal)
return signal
def validate(self, data):
image = self.initial_data.get('image', False)
if image:
if image.size > 8388608: # 8MB = 8*1024*1024
raise ValidationError("Maximum photo size is 8Mb.")
if image:
data['image'] = image
return data
class CardImageSerializer(serializers.ModelSerializer):
img_file = serializers.ImageField(use_url=True)
class Meta:
model = CardImage
fields = ('id', 'info', 'img_url', 'img_file')
class AccountSerializer(serializers.ModelSerializer):
email = serializers.EmailField(write_only=True,
validators=[validators.UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(write_only=True, required=False)
confirm_password = serializers.CharField(write_only=True, required=False)
major = serializers.CharField(required=True)
image = serializers.ImageField(default='Images/None/No-img.jpg', required=False)
class Meta:
model = User
fields = ('id', 'email', 'username', 'major', 'bio', 'image', 'date_joined', 'updated_at',
'first_name', 'last_name', 'full_name', 'password',
'confirm_password',)
read_only_fields = ('date_joined', 'updated_at', 'full_name')
def validate(self, attrs):
if 'password' in attrs:
if attrs['password'] != attrs['confirm_password']:
raise serializers.ValidationError("Password is not matched with a confirm password")
return attrs
def to_representation(self, obj):
returnObj = super(AccountSerializer,self).to_representation(obj)
followers_count = len(followers(obj))
following_count = len(following(obj))
total_posts = len(Post.objects.filter(author=obj.id))
new_obj = {}
# if isinstance(self.context['request'].user, User):
if self.context['request'].user.id == obj.id:
new_obj["email"] = obj.email
new_obj.update({
"following": following_count,
"followers": followers_count,
'total_posts': total_posts,
"am_I_following": is_following(self.context['request'].user, obj)
})
returnObj.update(new_obj)
return returnObj
def update(self, instance, validated_data):
# instance.email = validated_data.get('email', instance.email)
# instance.username = validated_data.get('username', instance.username)
instance.first_name = validated_data.get('first_name', instance.first_name)
instance.last_name = validated_data.get('last_name', instance.last_name)
instance.major = validated_data.get('major', instance.major)
instance.bio = validated_data.get('bio', instance.bio)
instance.image = validated_data.get('image', instance.image)
instance.save()
if self.checkPassword(validated_data):
instance.set_password(validated_data.get('password'))
instance.save()
return instance
def checkPassword(self, validated_data):
password = validated_data.get('password', None)
confirm_password = validated_data.get('confirm_password', None)
if password and confirm_password and password == confirm_password:
return True
return False
class ProfileSerializer(serializers.ModelSerializer):
picture = serializers.ImageField()
class Meta:
model = models.Profile
fields = '__all__'
from rest_framework import serializers
from .models import Task
from django.contrib.auth import get_user_model
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
class TaskSerializer(serializers.ModelSerializer):
<<<<<<< HEAD
image = serializers.ImageField(
max_length=None, use_url=True, default='images/none/none.jpg')
doc = serializers.FileField(
max_length=None, use_url=True, default='docs/none/none.txt')
=======
image = serializers.ImageField(max_length=None, use_url=True, default='images/none/none.jpg')
doc = serializers.FileField(max_length=None, use_url=True, default='docs/none/none.txt')
>>>>>>> 01f0b9a05d2c9013f894ed51652932ce36af0dda
class Meta:
model = Task
fields = ('id', 'task_name', 'task_desc',
'completed', 'date_created', 'image', 'doc')
class UserSerializer(serializers.ModelSerializer):
# password = serializers.CharField(write_only=True)
# # override Create method
# def create(self, validated_data):
# user = get_user_model().objects.create(
# username = validated_data['username']
class MiniSliderOfferIndividualSerializer(serializers.ModelSerializer):
image_thumbnail = serializers.ImageField()
class Meta:
model = MiniSliderOfferIndividual
fields = ('id','title', 'image', 'image_thumbnail')
class ImgSerializer(serializers.ModelSerializer):
img = serializers.ImageField(max_length=None, use_url=True)
class Meta:
model= Image
fields= '__all__'
class PostSerializer(serializers.Serializer):
#this is serializer for post and use Serializer
id = serializers.IntegerField(read_only=True)
title = serializers.CharField(max_length=250)
slug = serializers.SlugField(read_only=True, required=False)
text = serializers.CharField(required=False)
created_date = serializers.DateTimeField(read_only=True)
update_date = serializers.DateTimeField(read_only=True)
published_date = serializers.DateTimeField(required=False)
draft = serializers.BooleanField(required=False)
image_title = serializers.ImageField(read_only=True)
#read_only is somting like we did not give that
#in model need have default for this or null=True
category = serializers.PrimaryKeyRelatedField(
queryset=Category.objects.all(), required=False)
#category and author for relations need defin another way
# allow_discussion = serializers.BooleanField()
#we can use PostSetting hear
# author = UserSerializer(read_only=True)
#get full data of auther instead of just author_id
author = serializers.PrimaryKeyRelatedField(
queryset=User.objects.all(),
required=False) #hear we just get author_id
def validate_slug(self, slug):
#slug can be all objects in uper
try:
q = Post.objects.get(slug=slug)
raise serializers.ValidationError('slug must be uniqe')
except Post.DoesNotExist:
return slug
def create(self, validated_data):
#in form we do this:
#form = PostForm(request.POST)
#if form.is_valid:
# title = form.cleaned_data['title']
# ....
# ....
# post = Post.objects.create(title=form.cleaned_data['title'], slug=form.cleaned_data['slug'],.....)
# return render('base/post_detail.html', {post:post})
#hear we can do esear
return Post.objects.create(**validated_data)
#**validated_data is a func that get object PostSerializer one by one
# like (title=validated_data['title'], slug=validated_data['slug'], ....).
# "**" is python metod for get the all feild on top.
# PostSetting.objects.create(
# post=post,
# allow_discussion=validated_data['allow_discussion']
# )#chang PostSertting
def update(self, instance, validated_data):
#for update the data
#instanse that the object we want update
#validated_data is uper object
instance.title = validated_data.get('title', instance.title)
#means if exist get it [the first purameter in prantesis] or not put the default[the second parameter in pratisis]
# instance.slug = validated_data.get('slug', instance.slug)
# instance.text = validated_data.get('text', instance.text)
# instance.created_date = validated_data.get('created_date', instance.created_date)
instance.published_date = validated_data.get('published_date',
instance.published_date)
instance.draft = validated_data.get('draft', instance.draft)
# instance.image_title = validated_data.get('image_title', instance.image_title)
instance.save() #for save the uper fields
return instance #return the instance
class UserCreateSerializer(serializers.ModelSerializer):
email = serializers.EmailField(
required=True,
error_messages={'required': _('Campo Obrigatório')},
validators=[
validators.UniqueValidator(queryset=UserModel.objects.all())
])
name = serializers.CharField(
required=True, error_messages={'required': _('Campo Obrigatório')})
cpf = serializers.CharField(
required=False,
validators=[
BRCPFValidator(),
validators.UniqueValidator(queryset=UserModel.objects.all())
])
emailConfirm = serializers.BooleanField(source='email_confirm',
default=False)
shareEmail = serializers.BooleanField(source='share_email',
required=False,
default=False)
sharePhone = serializers.BooleanField(source='share_phone',
required=False,
default=False)
phoneNumber = serializers.CharField(
source='phone_number',
required=True,
error_messages={'required': _('Campo Obrigatório')})
password1 = serializers.CharField(
source='password',
label=_("Password"),
write_only=True,
error_messages={'required': _('Campo Obrigatório')},
style={'input_type': 'password'},
trim_whitespace=False)
typeUser = serializers.ChoiceField(
source='type_user',
required=True,
error_messages={'required': _('Campo Obrigatório')},
choices=UserModel.TYPE_USER_CHOICES)
uf = serializers.CharField(
max_length=100,
required=True,
error_messages={'required': _('Campo Obrigatório')})
city = serializers.CharField(
max_length=150,
required=True,
error_messages={'required': _('Campo Obrigatório')})
image = serializers.ImageField(required=False)
class Meta:
model = UserModel
fields = ('email', 'name', 'cpf', 'emailConfirm', 'shareEmail',
'sharePhone', 'phoneNumber', 'password1', 'typeUser', 'uf',
'city', 'image')
def create(self, validated_data):
password = validated_data.pop('password')
user = UserModel.objects.create(**validated_data)
user.set_password(password)
user.verify_email()
if user.type_user == UserModel.RECEIVER:
user.is_active = False
user.save()
return user
def update(self, instance, validated_data):
if 'password' in validated_data:
password = validated_data.pop('password')
user = super(UserCreateSerializer,
self).update(instance, validated_data)
user.set_password(password)
return user
else:
return super(UserCreateSerializer,
self).update(instance, validated_data)
def validate_phoneNumber(self, value):
number = re.sub(r'\D', '', value)
if len(number) > 11 or len(number) < 10:
raise exceptions.ValidationError(_('Número Inválido'))
return number
class QuestionsSerializer(serializers.HyperlinkedModelSerializer):
Image = serializers.ImageField(use_url=True)
class Meta:
model = Questions
fields = ['url', 'id', 'Text', 'Image', 'Tags']
def _make_badge_progress_response(self, course_key,
block_event_badge_config,
block_event_assertion):
"""
"""
return {
"course_id":
CourseKeyField(source='course_key').to_representation(course_key),
"block_id":
UsageKeyField(source='usage_key').to_representation(
block_event_badge_config.usage_key),
"block_display_name":
self.course_section_mapping.get(
UsageKeyField(source='usage_key').to_representation(
block_event_badge_config.usage_key),
'').get('display_name', ''),
"block_order":
self.course_section_mapping.get(
UsageKeyField(source='usage_key').to_representation(
block_event_badge_config.usage_key),
'').get('block_order', ''),
"event_type":
block_event_badge_config.event_type,
"badge_class": {
"slug":
block_event_badge_config.badge_class.slug,
"issuing_component":
block_event_badge_config.badge_class.issuing_component,
"display_name":
block_event_badge_config.badge_class.display_name,
"course_id":
CourseKeyField(source='course_key').to_representation(
block_event_badge_config.badge_class.course_id),
"description":
block_event_badge_config.badge_class.description,
"criteria":
block_event_badge_config.badge_class.criteria,
"image":
branding_api.get_base_url(self.request.is_secure()) +
serializers.ImageField(source='image').to_representation(
block_event_badge_config.badge_class.image),
},
"assertion": {
"issuedOn": (block_event_assertion.data.get('issuedOn', '') if
hasattr(block_event_assertion, 'data') else ""),
"expires": (block_event_assertion.data.get('expires', '')
if hasattr(block_event_assertion, 'data') else ""),
"revoked":
(block_event_assertion.data.get('revoked', False) if hasattr(
block_event_assertion, 'data') else False),
"image_url": (block_event_assertion.image_url
if block_event_assertion else ""),
"assertion_url": (block_event_assertion.assertion_url
if block_event_assertion else ""),
"entityId": (block_event_assertion.data.get('entityId', '') if
hasattr(block_event_assertion, 'data') else ""),
"recipient": {
"plaintextIdentity": (block_event_assertion.user.email
if block_event_assertion else ""),
},
"issuer": (block_event_assertion.assertion_issuer()
if block_event_assertion else {
"entityType": "",
"entityId": "",
"openBadgeId": "",
"name": "",
"image": "",
"email": "",
"description": "",
"url": "",
}),
},
}
class EarnerBadgeSerializer(serializers.Serializer):
recipient_id = serializers.CharField(required=False)
id = serializers.IntegerField(required=False)
assertion = serializers.DictField(required=False, write_only=True)
url = serializers.URLField(required=False, write_only=True)
image = serializers.ImageField(required=False, write_only=True)
json = V1InstanceSerializer(read_only=True)
errors = serializers.ListField(read_only=True)
def to_representation(self, obj):
if self.context.get('format', 'v1') == 'plain':
self.fields.json = serializers.DictField(read_only=True)
return super(EarnerBadgeSerializer, self).to_representation(obj)
def validate(self, data):
# Remove empty DictField
if data.get('assertion') == {}:
data.pop('assertion', None)
instance_input_fields = set(('url', 'image', 'assertion'))
valid_inputs = {
key: data.get(key)
for key in instance_input_fields.intersection(data.keys())
}
if len(valid_inputs.keys()) != 1:
raise serializers.ValidationError(
"Only one instance input field allowed. Recieved " +
json.dumps(valid_inputs.keys()))
return data
def create(self, validated_data):
user = self.context.get('request').user
image = None
if validated_data.get('url') is not None:
url = validated_data.get('url')
elif validated_data.get('image') is not None:
image = validated_data.get('image')
image.open()
url = get_instance_url_from_image(image)
elif validated_data.get('assertion') is not None:
url = get_instance_url_from_assertion(
validated_data.get('assertion'))
try:
rbi = RemoteBadgeInstance(url)
except DjangoValidationError as e:
raise e
abi = AnalyzedBadgeInstance(
rbi,
recipient_ids=[id.email for id in user.emailaddress_set.all()])
if len(
[x for x in abi.non_component_errors if x[0] == 'error.recipient'
]) != 0:
raise serializers.ValidationError(RECIPIENT_ERROR)
if not abi.is_valid():
raise serializers.ValidationError(abi.all_errors())
else:
instance_kwargs = {'recipient_user': user}
if image is not None:
instance_kwargs['image'] = image
new_instance = StoredBadgeInstance.from_analyzed_instance(
abi, **instance_kwargs)
return new_instance
class ProductSerializer(serializers.HyperlinkedModelSerializer):
image = serializers.ImageField(max_length=None, allow_empty_file=False, allow_null=True, required=False)
class Meta:
model = Product
fields = ('id', 'name', 'description', 'price', 'image', 'category')
class ProductSerializer(serializers.Serializer):
id = serializers.IntegerField()
image = serializers.ImageField()
price = serializers.DecimalField(max_digits=10, decimal_places=3)
properties = serializers.JSONField()
category = ProductCategorySerializer()
class ImageSerializer(serializers.Serializer):
validate_image = FileValidator(max_size=1024 * 100)
image = serializers.ImageField(validators=[validate_image])