class UserSerializer(serializers.ModelSerializer): # todo needs serious refactoring since UserGetSerializer is more active than UserSerializer email = EmailField(label='Email Address') email2 = EmailField(label='Confirm Email') class Meta: model = User # todo refine user fields for signup fields = ( 'id', 'first_name', 'last_name', 'email', 'email2', 'phone', 'password', 'is_blocked', 'createdAt', 'image', 'dob') read_only = ['id', 'email2'] extra_kwargs = {"password": {"write_only": True}} def validate_email(self, value): # user can only register one email address. # verify that user inserted correct email address # todo check if email exists by sending welcome message data = self.get_initial() email1 = data.get("email2") email2 = value if email1 != email2: raise ValidationError("Emails must match.") user_qs = User.objects.filter(email=email2) if user_qs.exists(): raise ValidationError("This user has already registered.") return value def validate_phone(self, value): # user can only register one phone number user = User.objects.filter(phone=value) if user.exists(): raise ValidationError("This user has already registered with the phone number") return value def validate(self, data): return data def create(self, validated_data): user = User( first_name=validated_data['first_name'], last_name=validated_data['last_name'], # username is a combination of first and last name username=validated_data['first_name'] + validated_data['last_name'], email=validated_data['email'], # email2 is redundant. however it prevents # 500 response when user is successfully created email2=validated_data['email2'], phone=validated_data['phone'], is_blocked=validated_data['is_blocked'], image=validated_data['image'], dob=validated_data['dob'] ) user.set_password(validated_data['password']) user.save() return user
class ContactSerializer(serializers.Serializer): """Serializer for contact message.""" VOLUNTEER = 'volunteer' ORGANIZATION = 'organization' APPLICANT_CHOICES = (VOLUNTEER, ORGANIZATION) applicant_type = ChoiceField(APPLICANT_CHOICES, required=True) applicant_email = EmailField(required=True, max_length=150) applicant_name = CharField(required=True, min_length=3, max_length=150) administrator_email = EmailField( required=True, validators=[validate_admin_email], ) message = CharField(required=True, min_length=10, max_length=2000) phone_no = CharField(max_length=20)
class AdminLoginSerializer(serializers.ModelSerializer): email = EmailField(label='Email', write_only=True) znap_id = IntegerField(read_only=True) class Meta: model = Admin fields = [ 'id', 'znap_id', 'email', 'password', ] extra_kwargs = {"password": {"write_only": True}} def validate(self, data): admin_obj = None email = data.get("email", None) password = data['password'] admin = Admin.objects.filter(email=email) admin = admin.exclude(email__isnull=True).exclude(email__iexact='') if admin.exists() and admin.count() == 1: admin_obj = admin.first() data['id'] = admin_obj.id data['znap_id'] = admin_obj.znap_id else: raise serializers.ValidationError("This email is not valid") if admin_obj: if (password != admin_obj.password): raise serializers.ValidationError("Incorrect password") return data
class UserSerializer(serializers.ModelSerializer): username = CharField(min_length=6, max_length=20) email = EmailField() class Meta: model = User fields = ('id', 'username', 'email',)
class UserAdminUpdateSerializer(UnknownFieldRaisesExceptionSerializerMixin, ModelSerializer): """ Serializes a request body for updating a given user. Do not use for returning user data as the password will be returned also. """ # Max length set to match django user models first_name fields max length name = CharField(source="first_name", max_length=30, required=False) username = EmailField(required=False) class Meta: model = User fields = ( "username", "name", "is_active", "is_staff", "password", ) extra_kwargs = { **_USER_ADMIN_SERIALIZER_API_DOC_KWARGS, "password": { "required": False }, }
class UserCreateSerializer(serializers.HyperlinkedModelSerializer): first_name = CharField() last_name = CharField() email = EmailField(label='Email') class Meta: model = User fields = ['first_name', 'last_name', 'email', 'password'] extra_kwargs = {"password" : {"write_only": True}} def validate(self, data): email = data['email'] user_qs = User.objects.filter(email=email) if user_qs.exists(): raise serializers.ValidationError("This user has already registered") return data def create(self, validated_data): first_name = validated_data['first_name'] last_name = validated_data['last_name'] email = validated_data['email'] password = validated_data['password'] user_obj = User( username = email, first_name = first_name, last_name = last_name, email = email, ) user_obj.set_password(password) user_obj.save() return validated_data
class LoginSerializer(serializers.ModelSerializer): email = EmailField(label='Email Address', required=True, allow_blank=True) class Meta: model = UserSignUp fields = ( 'email', 'password', ) extra_kwargs = {"password": {"write_only": True}} def validate(self, data): user_obj = None email = data.get("email", None) password = data.get("password", None) if not email: raise ValidationError("email is required to login") user = UserSignUp.objects.filter(email=email, password=password) if user.exists() and user.count() == 1: user_obj = user.first() else: raise ValidationError("Incorrect credientials, please try again") return data
class TutorSerializer(serializers.ModelSerializer): name = CharField(allow_blank=True, max_length=254, required=False) email = EmailField(allow_blank=True, max_length=254, required=False) class Meta: model = Tutor fields = ('id', 'name', 'room', 'school', 'email')
class CertificateSerializer(serializers.HyperlinkedModelSerializer): #user = UserSerializer(read_only=True) user = CharField(source='user.uid', read_only=True) subject_email = EmailField(source='email', read_only=True) class Meta: model = Certificate fields = ('pk', 'name', 'revoked', 'subject_email', 'user')
class UserRegisterSerializer(ModelSerializer): email = EmailField(required=True, max_length=128, help_text=_('email address')) class Meta: model = user_model fields = ('username', 'first_name', 'last_name', 'email', 'password')
class StartupSerializer(Serializer): id = IntegerField(read_only=True) name = CharField(max_length=31) slug = SlugField(max_length=31) description = CharField() founded_date = DateField() contact = EmailField() website = URLField(max_length=255) tags = TagSerializer(many=True)
class SignupSerializer(serializers.ModelSerializer): class Meta: model = User fields = ('username', 'password', 'email', 'token', 'stuid', 'stuname') # read_only_fields = ('token', ) password = CharField(min_length=6, max_length=100, label='密码', required=True) username = CharField(min_length=3, max_length=100, label='用户名', required=True) stuid = CharField(max_length=10, label='学号', required=True) stuname = CharField(max_length=200, label='姓名', required=True) email = EmailField(label='邮箱', required=True) token = CharField(read_only=True) def validate(self, data): email = data.get('email') username = data.get('username') stuid = data.get('stuid') users = User.objects.all() for user in users: if user.email == email: raise serializers.ValidationError( '邮箱已经被注册了', code='email_not_unique', ) if user.username == username: raise serializers.ValidationError( '用户名已经被注册了', code='username_not_unique', ) if user.stuid == stuid: raise serializers.ValidationError( '这个学号已经被注册了', code='username_not_unique', ) return data def create(self, validated_data): user = super().create(validated_data) user.set_password(validated_data['password']) # 用已经通过数据合法性唯一性校验的用户数据生成token user.save() jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER payload = jwt_payload_handler(user) token = jwt_encode_handler(payload) user.token = token return user
class OrganizationContactSerializer(serializers.Serializer): """Serializer for contact message""" name = CharField(required=True, min_length=2, max_length=150, trim_whitespace=True) email = EmailField(required=True) phone_no = CharField(required=True, min_length=9, max_length=15, trim_whitespace=True) message = CharField(required=True, min_length=2, max_length=500, trim_whitespace=True)
class ResetRequestSerializer(Serializer): """POST""" email = EmailField(write_only=True) def update(self, user, _validated_data): user.password_reset_code = randint(100000, 999999) user.password_reset_request_time = datetime.now() user.save() return user
class InvitationSerializer(WritableNestedModelSerializer): email = EmailField(validators=[ UniqueValidator(queryset=User.objects.all()), UniqueValidator(queryset=Invitation.objects.all()) ]) author = AuthorNameSerializer(required=True, allow_null=False) class Meta: model = Invitation fields = ('email', 'author')
class ContactSerializer(serializers.Serializer): name = CharField(max_length=150) email = EmailField() message = CharField() if settings.DRF_RECAPTCHA_ENABLED: recaptcha = ReCaptchaV2Field() def validate(self, data): data.pop("recaptcha", None) return data
class UserSerializer(HalNestedFieldsModelSerializer): isSuperAdmin = BooleanField(source="is_superuser", read_only=True) isSuperReader = BooleanField(source="is_staff", read_only=True) email = EmailField(required=True) class Meta: model = get_user_model() fields = ('id', 'email', 'password', 'first_name', 'last_name', 'isSuperAdmin', 'isSuperReader') extra_kwargs = {'password': {'write_only': True}} read_only_fields = ('id', )
class EmailSerializer(serializers.ModelSerializer): class Meta: model = Email fields = '__all__' email = EmailField() def validate_email(self, value): if Email.objects.filter(email=value).exists(): raise ConflictException('Email already exists', 'email', status.HTTP_409_CONFLICT) return value
class AddressSerializer(serializers.Serializer): name = CharField(required=False) address = EmailField() def to_representation(self, obj): return addr_db_to_rest(obj) def create(self, validated_data): try: return [validated_data["name"], validated_data["address"]] except Exception: return [validated_data["address"], validated_data["address"]]
class UserAlterSerializerBase(UserSerializerBase): password = CharField(required=False, blank=True, widget=widgets.PasswordInput) email = EmailField(required=False) # FIXME: help_text class Meta: model = User fields = UserRoLightSerializer.Meta.fields + \ ['email_md5', 'date_joined', 'is_active', 'email', 'password',] read_only_fields = ( 'email_md5', 'uuid', 'date_joined', 'is_active', ) # FIXME: move to to_native()? @property def data(self): data = super(UserAlterSerializerBase, self).data.copy() del data['password'] return data def validate_email(self, attrs, source): value = attrs[source] if not self.object or value != self.object.email: if value and User.objects.filter(email__iexact=value).count(): raise serializers.ValidationError("Email not available.") return attrs def validate_password(self, attrs, source): attrs[source] = make_password(attrs[source]) if self.object and attrs[source] == UNUSABLE_PASSWORD: attrs[source] = self.object.password return attrs def validate_name(self, attrs, source): attrs[source] = blanks_prune(attrs[source]) return attrs
class UserCreateSerializer(serializers.ModelSerializer): #id = serializers.IntegerField(read_only=False) email = EmailField(label='Email address') #email2 = EmailField(label='Confirm Email') class Meta: model = User fields = [ 'username', 'email', 'password', ] extra_kwargs = {'password': {'write_only': True}} """def validate(self, data): email = data['email'] qs_email = User.objects.filter(email=email) if qs_email.exists(): raise ValidationError("Email already used and registered") return data""" """def email_validation(self, value): data = self.get_initial() email = data.get("email2") email2 = value if email != email2: raise ValidationError("Unmatched email") qs_email = User.objects.filter(email=email) if qs_email.exists(): raise ValidationError("Email already used and registered") return value def email_validation2(self, value): data = self.get_initial() email = data.get("email") email2 = value if email != email2: raise ValidationError("Unmatched email") return value""" def create(self, validated_data): """user = ptaraUsers.objects.create( username=validated_data['username'], email = validated_data['email'], )""" username = validated_data['username'] email = validated_data['email'] password = validated_data['password'] user_obj = User(username=username, email=email) user_obj.set_password(validated_data['password']) user_obj.save() return validated_data
class CreateUpdateCompanySerializer(ObjectPermissionsAssignmentMixin, serializers.ModelSerializer): email = EmailField( validators=[UniqueValidator(queryset=User.objects.all())], required=False) password = CharField(required=False) def get_permissions_map(self, created): current_user = get_object_or_none( User, email=self.validated_data.get('email')) return default_perm_map(self.Meta.model.__name__, current_user) class Meta: model = Company fields = ( 'email', 'password', 'ref_first_name', 'ref_last_name', 'ref_phone_number', 'company_name', 'company_symbol', 'website', 'address', ) def create(self, validated_data): email = validated_data.pop('email') password = validated_data.pop('password') user = User.objects.create_company_user( email=email, password=password, ) company = Company.objects.create(user=user, **validated_data) return company def update(self, instance, validated_data, **kwargs): instance.ref_first_name = validated_data.get('ref_first_name', instance.ref_first_name) instance.ref_last_name = validated_data.get('ref_last_name', instance.ref_last_name) instance.ref_phone_number = validated_data.get( 'ref_phone_number', instance.ref_phone_number) instance.company_name = validated_data.get('company_name', instance.company_name) instance.company_symbol = validated_data.get('company_symbol', instance.company_symbol) instance.address = validated_data.get('address', instance.address) instance.website = validated_data.get('website', instance.website) instance.save() return instance
class CustomRegisterSerializer(RegisterSerializer): email = EmailField(required=True) password1 = CharField(write_only=True) password2 = CharField(write_only=True) def get_cleaned_data(self): super(CustomRegisterSerializer, self).get_cleaned_data() return { 'password1': self.validated_data.get('password1', ''), 'password2': self.validated_data.get('password1', ''), 'email': self.validated_data.get('email', ''), }
class UserLoginSerializer(serializers.ModelSerializer): token = CharField(allow_blank=True, read_only=True) username = CharField(allow_blank=True, required=False) email = EmailField(label='Email Address', allow_blank=True, required=False) phone = CharField(label='Phone Number', allow_blank=True, required=False) class Meta: model = User fields = [ 'username', 'email', 'phone', 'password', 'token', ] extra_kwargs = {"password": {"write_only": True}} def validate(self, data): user_object = None username = data.get('username', None) email = data.get('email', None) phone = data.get('phone', None) password = data['password'] # User logs in with username, email or phone. Plus password if username or email or phone: # Q allows robust filtering, # distinct returns only one object incase there are duplicates user = User.objects.filter( Q(username=username) | Q(email=email) | Q(phone=phone) ).distinct() if user.exists() and user.count() == 1: user_object = user.first() if user_object: if not user_object.check_password(password): raise ValidationError("Incorrect credentials. Please try again") else: raise ValidationError("Login failure. Invalid username, email or phone number.") data['token'] = create_token(user_object) print(user_object.image) data['image'] = user_object.image data['username'] = user_object.username data['first_name'] = user_object.first_name data['last_name'] = user_object.last_name return data else: raise ValidationError("A username, email or phone number is required to login")
class UserSerializer(WritableNestedModelSerializer): author = AuthorSerializer(required=False, allow_null=True) password = CharField(write_only=True, required=False) email = EmailField(write_only=True, required=False) class Meta: model = User fields = ('email', 'username', 'first_name', 'last_name', 'password', 'author') def create(self, validated_data): user = User(email=validated_data["email"], username=validated_data["username"]) user.set_password(validated_data["password"]) user.save() return user
class UserLoginSerializer(serializers.ModelSerializer): token = CharField(allow_blank=True, read_only=True) username = CharField() email = EmailField() class Meta: model = get_user_model() fields = ( 'username', 'email', 'password', 'token', ) extra_kwargs = {'password': {'write_only': True}} def validate(self, data): return data
class PasswordResetSerializer(serializers.Serializer): email = EmailField() def validate_email(self, value): user = models.User.objects.filter(email=value).first() self.object = user if not user: raise serializers.ValidationError('Email not found') if not user.is_active: raise serializers.ValidationError('User is inactive') if not user.email_is_verified: raise serializers.ValidationError('Email is not verified') return value
class CommitSerializer(serializers.ModelSerializer): _id = ObjectIdField() modifiedFiles = serializers.SerializerMethodField() user = CharField(max_length=128) hashID = CharField(max_length=40) email = EmailField() date = DateTimeField() message = CharField(max_length=510) class Meta: model = Commit exclude = ('_id', ) def get_modifiedFiles(self, obj): resources_serializer = ModifiedFilesSerializer(obj.modifiedFiles, many=True) return resources_serializer.data
class ProfileSerializer(ModelSerializer): id = UUIDField(source="pk") email = EmailField(source="user.email") first_name = CharField(source="user.first_name", max_length=30) last_name = CharField(source="user.last_name", max_length=150) class Meta: model = Profile fields = [ "id", "first_name", "last_name", "email", "phone_number", "street_address", "date_of_birth", "city", "postal_code", "contact_language", ] @transaction.atomic def create(self, validated_data): _logger.info("Creating a new profile") user = get_user_model().objects.create(**validated_data.pop("user")) profile = Profile.objects.create(user=user, **validated_data) _logger.info(f"Profile {profile.pk} created") return profile @transaction.atomic def update(self, instance, validated_data): _logger.info(f"Updating profile {instance.pk}") user = instance.user user_data = validated_data.pop("user", {}) for attr, value in user_data.items(): setattr(user, attr, value) user.save() for attr, value in validated_data.items(): setattr(instance, attr, value) instance.save() _logger.info(f"Profile {instance.pk} updated") return instance class CreateResponseSerializer(Serializer): profile_id = CharField() password = CharField()
class UserSerializer(ModelSerializer): email = EmailField(label='Email') password2 = CharField(label='Confirm Password', style={'input_type': 'password'}, write_only=True) class Meta: model = User fields = ('id', 'first_name', 'last_name', 'username', 'email', 'password', 'password2') extra_kwargs = { "password": { "write_only": True, "style": { 'input_type': 'password' } } } def validate(self, data): password1 = data.get('password') password2 = data.get('password2') if password1 != password2: raise ValidationError('Password Not Matched!') email = data['email'] user_qs = User.objects.filter(email=email) if user_qs.exists(): raise ValidationError('This user is already registered!') return data def create(self, validated_data): first_name = validated_data['first_name'] last_name = validated_data['last_name'] username = validated_data['username'] email = validated_data['email'] password = validated_data['password'] password2 = validated_data['password2'] user_obj = User( first_name=first_name, last_name=last_name, username=username, email=email, ) user_obj.set_password(password and password2) user_obj.save() return validated_data