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']