class UserSerializer(Serializer):
email = fields.EmailField()
lastname = fields.CharField()
firstname = fields.CharField()
is_active = fields.BooleanField(default=False)
is_superuser = fields.BooleanField(default=False)
is_staff = fields.BooleanField(default=True)
class PersonSerializer(DataclassSerializer):
email = fields.EmailField()
favorite_pet = PetSerializer(allow_null=True)
class Meta:
dataclass = Person
fields = (serializers.ALL_FIELDS, 'age')
extra_kwargs = {
'id': {
'format': 'hex'
},
'phone': {
'child_kwargs': {
'max_length': 15
}
},
'pets': {
'child_kwargs': {
'extra_kwargs': {
'weight': {
'max_digits': 4,
'decimal_places': 1
}
}
}
},
}
class RecoveryPwdSerializer(serializers.ModelSerializer):
"""model recovery password serializer"""
email = fields.EmailField(validators=[EmailValidator()])
class Meta:
model = User
fields = ("email",)
def create(self, validate_data):
"""send email to recovery password"""
user = get_object_or_404(User, email=validate_data.get("email"))
uid = encode_user_id(user.id)
token = make_user_token(user)
context_page = RECOVERY_PASSWORD
email_context = {
"fullname": f'{validate_data["user.first_name"]}',
"domain": URL_SEND_EMAIL + context_page,
"uid": uid,
"token": token,
}
tmp_name = "emails/recovery_password_email.html"
send_email_module.delay(
subject="Cotizate - Recuperar contraseña",
to=[validate_data["email"]],
body="",
template_name=tmp_name,
context=email_context,
)
return validate_data
def test_options_mapping(self, assert_dict_equals):
"""
Confirm that new serializers will catch and correctly manage
field options for its specified model, for non-embedded models
"""
class TestSerializer(DjongoModelSerializer):
class Meta:
model = OptionsModel
fields = '__all__'
expected_dict = {
# Primary keys should be made read-only, with the db column being
# ignored entirely
"db_column_id":
rmd_fields.ObjectIdField(read_only=True),
# Nullable and blank values should have required=False appended.
# The prior requires a unique validator as well, the text requires
# templates
"null_char":
("CharField(allow_null=True, "
"required=False, "
"validators=[<django.core.validators.MaxLengthValidator object>])"
),
"blank_char":
drf_fields.CharField(allow_blank=True,
required=False,
style={'base_template': 'textarea.html'}),
# Fields with choices should be coerced into that form of field
"choice_char":
"ChoiceField(choices=['Foo', 'Bar', 'Baz'], "
"validators=[<django.core.validators.MaxLengthValidator object>])",
# Defaults are handled by Django, not DRF, so the argument should
# be stripped implicitly (though it still is in use during save!)
# This will set required=False, however
"default_email":
drf_fields.EmailField(max_length=254, required=False),
# Read only fields should be marked as such
"read_only_int":
drf_fields.IntegerField(read_only=True),
# Errors, by default, should be distinct between DRF and Djongo;
# Therefore, it should be stripped unless explicitly set in the
# serializer by the user
"custom_error":
drf_fields.IntegerField(max_value=2147483647,
min_value=-2147483648),
# Help text should be conserved
"help_char":
("CharField(help_text='Super helpful text', "
"validators=[<django.core.validators.MaxLengthValidator object>])"
),
# Fields designated as unique should have a validator stating
# such added
"unique_int":
("IntegerField(max_value=2147483647, "
"min_value=-2147483648, "
"validators=[<UniqueValidator(queryset=OptionsModel.objects.all())>])"
),
}
assert_dict_equals(TestSerializer().get_fields(), expected_dict)
class PersonSerializer(DataclassSerializer):
email = fields.EmailField()
class Meta:
dataclass = fixtures.Person
fields = (serializers.ALL_FIELDS, 'age')
read_only_fields = ('birth_date', )
class SignupSerializer(PasswordSerializer):
email = fields.EmailField(label='Email')
username = fields.CharField(label='Username')
def validate_username(self, value):
'Validate that the username is unique.'
if User.objects.filter(username__iexact=value):
raise ValidationError('Username is already in use')
return value
def validate_email(self, value):
'Validate that the e-mail address is unique.'
if User.objects.filter(email__iexact=value):
raise ValidationError('Email is already in use')
return value
def create(self, validated_data):
return User.objects.create_user(
email=validated_data.get('email'),
password=validated_data.get('password1'),
username=validated_data.get('username')
)
class PasswordRecoverySerializer(serializers.Serializer):
"""serializer to recovery password"""
email = fields.EmailField(validators=[
EmailValidator(),
])
def create(self, validated_data):
"""send email to recovery password"""
user = get_object_or_404(User, email=validated_data.get('email'))
email_context = {
'name': '{}'.format(user.name),
'domain': f'{settings.URL_PRODUCTION}/#/recovery-password',
'uid': encode_user_id(user.id),
'token': make_user_token(user),
}
send_email_message(
subject='Cotizate - Password Recovery',
to=[
validated_data['email'],
],
body='',
template_name='emails/profile/recovery-password.html',
context=email_context,
)
return validated_data
class PersonSerializer(DataclassSerializer):
full_name = fields.CharField(source='name')
email = fields.EmailField()
favorite_pet = PetSerializer(allow_null=True)
slug = fields.SlugField(source='name', read_only=True)
class Meta:
dataclass = Person
fields = ('id', 'full_name', 'email', 'phone', 'length', 'pets',
'birth_date', 'favorite_pet', 'movie_ratings', 'slug', 'age')
extra_kwargs = {
'id': {
'format': 'hex'
},
'phone': {
'child_kwargs': {
'max_length': 15
}
},
'pets': {
'child_kwargs': {
'extra_kwargs': {
'weight': {
'max_digits': 4,
'decimal_places': 1
}
}
}
},
}
class UserSerializer(serializers.ModelSerializer):
username = fields.CharField()
email = fields.EmailField()
password = fields.CharField(write_only=True)
def create(self, validated_data):
user = User.objects.create(username=validated_data['username'],
email=validated_data['email'])
user.set_password(validated_data['password'])
user.save()
return user
def validate_password(self, value): # pylint: disable=no-self-use
try:
validate_password(value)
except ValidationError as exc:
raise serializers.ValidationError(str(exc))
return value
def validate_email(self, value): # pylint: disable=no-self-use
if User.objects.filter(email=value).count() > 0:
raise serializers.ValidationError('This email already exists!')
return value
def validate_username(self, value): # pylint: disable=no-self-use
if User.objects.filter(username=value).count() > 0:
raise serializers.ValidationError('This username already exists!')
return value
class Meta:
model = User
fields = ('username', 'email', 'password')
def test_basic_mapping(self, assert_dict_equals):
"""
Confirm that the serializer can still handle models w/
standard Django fields
"""
class TestSerializer(DjongoModelSerializer):
class Meta:
model = GenericModel
fields = '__all__'
expected_dict = {
'id':
drf_fields.IntegerField(label='ID', read_only=True),
'big_int':
drf_fields.IntegerField(max_value=9223372036854775807,
min_value=-9223372036854775808),
'bool':
drf_fields.BooleanField(),
'char':
drf_fields.CharField(max_length=20),
'comma_int':
("CharField(validators=[<django.core.validators.RegexValidator "
"object>, <django.core.validators.MaxLengthValidator object>])"),
'date':
drf_fields.DateField(),
'date_time':
drf_fields.DateTimeField(),
'decimal':
drf_fields.DecimalField(decimal_places=5, max_digits=10),
'email':
drf_fields.EmailField(max_length=254),
'float':
drf_fields.FloatField(),
'integer':
drf_fields.IntegerField(max_value=2147483647,
min_value=-2147483648),
'null_bool':
drf_fields.NullBooleanField(required=False),
'pos_int':
drf_fields.IntegerField(max_value=2147483647, min_value=0),
'pos_small_int':
drf_fields.IntegerField(max_value=32767, min_value=0),
'slug':
drf_fields.SlugField(allow_unicode=False, max_length=50),
'small_int':
drf_fields.IntegerField(max_value=32767, min_value=-32768),
'text':
"CharField(style={'base_template': 'textarea.html'})",
'time':
drf_fields.TimeField(),
'url':
drf_fields.URLField(max_length=200),
'ip':
drf_fields.IPAddressField(),
'uuid':
"ModelField(model_field=<django.db.models.fields.UUIDField: uuid>)",
}
assert_dict_equals(TestSerializer().get_fields(), expected_dict)
class EmployeeSerializer(serializers.DocumentSerializer):
designation = DesignationSerializer(required=False)
name = fields.CharField(required=True)
username = fields.CharField(required=False)
email = fields.EmailField(required=False)
emp_id = fields.IntegerField(required=False)
file = field.FileField(required=False)
class Meta:
model = Employee
fields = '__all__'
class BaseAuthSerializer(Serializer):
auth_cloud_client_handler = None
auth_fail_error_class = None
email = fields.EmailField(required=True)
password = fields.CharField(required=True, write_only=True)
token = fields.CharField(read_only=True)
def create(self, validated_data):
assert self.auth_cloud_client_handler is not None
email = validated_data['email']
password = validated_data['password']
try:
auth_cloud_clientt = get_auth_cloud_client()
cloud_handler = getattr(auth_cloud_clientt, self.auth_cloud_client_handler)
user = cloud_handler(email, password)
except HTTPError as err:
logger.error(err)
if self.auth_fail_error_class is None:
raise err
raise self.auth_fail_error_class()
cloud_user = user
user = self.create_or_get_django_user_from_cloud_user(cloud_user)
self._test_if_valid_model(user)
user.last_login = datetime.utcnow()
user.save()
token = self.create_and_get_cloud_token(cloud_user, user)
self._test_if_valid_token(token)
return {'email': email, 'token': token.key}
def _test_if_valid_model(self, user):
user_model = apps.get_model(*settings.AUTH_USER_MODEL.split('.', 1))
assert isinstance(user, user_model)
assert user_model is not None
def _test_if_valid_token(self, token):
assert isinstance(token, CloudGeneratedToken)
assert token is not None
def create_and_get_cloud_token(self, cloud_user, django_user):
# TODO: Add refresh token login (token expires in 1 hour)
raise NotImplementedError()
def create_or_get_django_user_from_cloud_user(self, user):
raise NotImplementedError()
class CustomerSerializer(ModelSerializer):
id = fields.CharField(required=False)
name = fields.CharField(required=True)
point = fields.IntegerField(read_only=True)
phone = fields.CharField(required=False, max_length=10)
email = fields.EmailField(required=False)
address = fields.CharField(required=False)
type = CustomerTypeSerializer(read_only=True)
class Meta:
model = Customer
fields = '__all__'
class UserManagerSerializer(serializers.Serializer): # pylint: disable=abstract-method
""" Serializer for User manager reports """
email = fields.EmailField(source='manager_email')
id = fields.IntegerField(source='user_manager.id', required=False)
def create(self, validated_data):
user = validated_data.get('user')
manager_user = validated_data.get('manager_user')
unregistered_manager_email = validated_data.get(
'unregistered_manager_email')
return create_user_manager_role(user, manager_user,
unregistered_manager_email)
class RequestEmailSerializer(serializers.Serializer):
email = fields.EmailField(label='Email')
def validate(self, data):
try:
user = m.User.objects.get(email__iexact=data.get('email'))
if not user.is_active:
raise serializers.ValidationError(c.RESET_NOT_FOUND)
data['user'] = user
except m.User.DoesNotExist:
raise serializers.ValidationError(c.RESET_NOT_FOUND)
return data
class ManagerReportsSerializer(serializers.Serializer): # pylint: disable=abstract-method
""" Serializer for User manager reports """
id = fields.IntegerField(source='user.id', required=True)
email = fields.EmailField(source='user.email', required=False)
username = fields.CharField(source='user.username', required=False)
def create(self, validated_data):
"""
Create UserManagerRole object.
"""
user = validated_data.get('user')
manager_user = validated_data.get('manager_user')
unregistered_manager_email = validated_data.get('unregistered_manager_email')
return create_user_manager_role(user, manager_user, unregistered_manager_email)
class NewsletterSerializer(serializers.Serializer):
NEWSLETTER_CHOICES_API = {
# string passed to the API : actual string passed to basket.
'about:apps': 'mozilla-and-you,marketplace-desktop',
'marketplace': 'marketplace'
}
email = fields.EmailField()
newsletter = fields.ChoiceField(required=False,
default='marketplace',
choices=NEWSLETTER_CHOICES_API.items())
def transform_newsletter(self, obj, value):
# Transform from the string the API receives to the one we need to pass
# to basket.
default = self.fields['newsletter'].default
return self.NEWSLETTER_CHOICES_API.get(value, default)
class SignupSerializer(serializers.Serializer):
email = fields.EmailField(label='Email')
password = fields.CharField(label='Password')
first_name = fields.CharField(label='first_name')
last_name = fields.CharField(label='last_name')
service_from = fields.CharField(label='service_from', required=False)
company = fields.IntegerField(required=False)
activation_key = fields.CharField(required=False)
def validate_email(self, value):
try:
user = m.User.objects.get(email__iexact=value)
if user.is_verified:
raise serializers.ValidationError(c.SIGNUP_EMAIL_EXISTS)
except m.User.DoesNotExist:
pass
if scim.email_exists(value):
raise serializers.ValidationError(c.SIGNUP_EMAIL_EXISTS_GLUU)
return value
def create(self, validated_data):
try:
user = m.User.objects.get(email__iexact=validated_data['email'])
user.is_verified = False
user.set_password(validated_data['password'])
user.save()
except m.User.DoesNotExist:
user = m.User.objects.create_user(
email=validated_data['email'],
password=validated_data['password'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
service_from=validated_data.get('service_from', ''),
is_verified=False)
scim_user = scim.create_user(user, validated_data['password'])
user.idp_uuid = scim_user['id']
user.save()
return user
class LoginSerializer(Serializer):
username = fields.EmailField()
password = PasswordField()
@classmethod
def get_token(cls, user):
return RefreshToken.for_user(user)
def validate(self, attrs: dict):
params = {"email": attrs["username"], "password": attrs["password"]}
params["request"] = self.context["request"]
user = authenticate(**params)
if not user:
raise AuthenticationFailed("Invalid email or password")
refresh = self.get_token(user)
data = {}
# data['refresh'] = str(refresh)
data["access_token"] = str(refresh.access_token)
return data
class NewsletterSerializer(serializers.Serializer):
NEWSLETTER_CHOICES_API = {
# string passed to the API : actual string passed to basket.
'about:apps': 'mozilla-and-you,marketplace-desktop',
'marketplace-firefoxos': 'marketplace',
'marketplace-desktop': 'mozilla-and-you',
'marketplace-android': 'mozilla-and-you'
}
email = fields.EmailField()
newsletter = fields.ChoiceField(default='marketplace-firefoxos',
required=False,
choices=NEWSLETTER_CHOICES_API.items())
lang = fields.CharField()
def to_representation(self, obj):
"""Transform from the string the API receives to the one we need to
pass to basket."""
data = super(NewsletterSerializer, self).to_representation(obj)
default = self.fields['newsletter'].default
data['newsletter'] = self.NEWSLETTER_CHOICES_API.get(
obj['newsletter'], default)
return data
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 AuthenticationMixin(Serializer):
email = fields.EmailField(required=True)
username = fields.CharField(required=False)
password = fields.CharField(required=True)
def get_user(self):
if not hasattr(self, '_errors'):
raise ValueError('To retrieve the user call is_valid')
if self.errors:
raise ValueError('The serializer is not valid')
return get_object_or_404(USER_MODEL, email=self.validated_data['email'])
def save(self, request, **kwargs):
validated_data = {**self.validated_data, **kwargs}
if self.instance is not None:
self.instance = self.update(request, self.instance, validated_data)
else:
self.instance = self.create(request, validated_data)
if self.instance is None:
raise serializers.ValidationError({'signup': 'Could not create account'})
return self.instance
class CartSerializer(serializers.ModelSerializer):
items = SubclassListSerializer(child=LineItemMetadataSerializer())
new_item_url = fields.SerializerMethodField()
subtotal = fields.DecimalField(
max_digits=7, decimal_places=2, source="get_subtotal"
)
delivery_addresses = fields.SerializerMethodField()
new_address_url = fields.SerializerMethodField()
payment_methods = fields.SerializerMethodField()
new_payment_method_url = fields.SerializerMethodField()
adjustments = SubclassListSerializer(child=AdjustmentSerializer())
new_adjustment_url = fields.SerializerMethodField()
grand_total = fields.DecimalField(
max_digits=7, decimal_places=2, source="get_grand_total"
)
is_complete = fields.SerializerMethodField()
incomplete_reasons = fields.SerializerMethodField()
is_authenticated = fields.SerializerMethodField()
checkout_url = fields.SerializerMethodField()
generated_at = fields.SerializerMethodField()
email = fields.EmailField()
compatible_version = fields.SerializerMethodField()
incompatible_version = fields.SerializerMethodField()
def get_new_item_url(self, _):
return reverse("lorikeet:add-to-cart")
def get_new_address_url(self, _):
return reverse("lorikeet:new-address")
def get_delivery_addresses(self, cart):
selected = cart.delivery_address_subclass
the_set = []
if cart.user:
the_set = cart.user.delivery_addresses.filter(
active=True
).select_subclasses()
if selected is not None and selected not in the_set:
the_set = chain(the_set, [selected])
return DeliveryAddressSerializer(
instance=the_set, many=True, context={"cart": cart}
).data
def get_new_payment_method_url(self, _):
return reverse("lorikeet:new-payment-method")
def get_payment_methods(self, cart):
the_set = []
selected = cart.payment_method_subclass
if cart.user:
the_set = cart.user.paymentmethod_set.filter(
active=True
).select_subclasses()
if selected is not None and selected not in the_set:
the_set = chain(the_set, [selected])
return PaymentMethodSerializer(
instance=the_set, many=True, context={"cart": cart}
).data
def get_new_adjustment_url(self, _):
return reverse("lorikeet:new-adjustment")
def get_generated_at(self, cart):
return time()
def get_is_complete(self, cart):
return cart.is_complete()
def get_incomplete_reasons(self, cart):
return cart.errors.to_json()
def get_is_authenticated(self, cart):
return cart.user_id is not None
def get_checkout_url(self, _):
return reverse("lorikeet:checkout")
def get_compatible_version(self, _):
return 2
def get_incompatible_version(self, _):
return 1
class Meta:
model = models.Cart
fields = (
"items",
"new_item_url",
"delivery_addresses",
"new_address_url",
"payment_methods",
"new_payment_method_url",
"grand_total",
"generated_at",
"is_complete",
"incomplete_reasons",
"checkout_url",
"is_authenticated",
"email",
"adjustments",
"new_adjustment_url",
"subtotal",
"compatible_version",
"incompatible_version",
)
class RegisterSerializer(Serializer):
first_name = fields.CharField(max_length=150)
last_name = fields.CharField(max_length=150)
email = fields.EmailField()
password = PasswordField(min_length=8, max_length=150)
class ForgotPasswordSerializer(Serializer):
email = fields.EmailField()
class NewsletterSerializer(serializers.Serializer):
email = fields.EmailField()
class MemberRemoveSerializer(serializers.Serializer):
email = fields.EmailField(validators=[validators.invite_email_validator])
class Meta:
fields = ['email']
class OrganizationInviteSerializer(serializers.Serializer):
email = fields.EmailField(validators=[validators.invite_email_validator])
class Meta:
fields = ['email']
