class UserRegisterSerializer(_Serializer): from rest_framework import serializers as _se from rest_framework import validators as _val email = _se.EmailField( required=True, allow_null=False, allow_blank=False, min_length=6, max_length=256, validators=[_val.UniqueValidator(queryset=_User.objects.all())]) phone = _se.IntegerField( required=True, allow_null=False, validators=[_val.UniqueValidator(queryset=_User.objects.all())]) password = _se.CharField( min_length=6, write_only=True, ) first_name = _se.CharField( min_length=2, max_length=256, ) last_name = _se.CharField( min_length=2, max_length=256, ) username = _se.CharField( min_length=4, max_length=256, ) from django.db import transaction as _ts @_ts.atomic def create(self, validated_data): from django.conf import settings user = _User.objects.create(**validated_data) user.set_password(validated_data['password']) if settings.DEBUG: user.activate() else: user.save() if not settings.DEBUG: user.mail_activation() return user class Meta: model = _User fields = ('email', 'phone', 'password', 'first_name', 'last_name', 'username')
class register_Serializer(serializers.Serializer): email = serializers.EmailField( validators=[validators.UniqueValidator(queryset=User.objects.all())]) username = serializers.CharField( min_length=2, max_length=100, validators=[validators.UniqueValidator(queryset=User.objects.all())]) password = serializers.CharField(min_length=8, max_length=255) password_confirmation = serializers.CharField(min_length=8, max_length=255) first_name = serializers.CharField(min_length=2, max_length=100) last_name = serializers.CharField(min_length=2, max_length=100) def validate(self, data): passwd = data['password'] paswwd_conf = data['password_confirmation'] if passwd != paswwd_conf: raise serializers.ValidationError('keys does not equals') password_validation.validate_password(passwd) return data def create(self, data): data.pop('password_confirmation') user = User.objects.create_user(**data, is_active=True) Profile.objects.create(user=user) return user
class CreateUserSerializer(serializers.HyperlinkedModelSerializer): email = serializers.EmailField( required=True, validators=[ validators.UniqueValidator(queryset=models.User.objects.all()) ]) username = serializers.CharField(validators=[ validators.UniqueValidator(queryset=models.User.objects.all()) ]) password = serializers.CharField(min_length=8, style={"input_type": "password"}, write_only=True, label="Password") def create(self, validated_data): user = models.User.objects.create_user(validated_data['username'], validated_data['email'], validated_data['password']) if user: send_mail('Welcome to the Moovie App!', 'Welcome to the movie app %s' % user.username, '*****@*****.**', [user.email], fail_silently=False) return user class Meta: model = models.User fields = ['id', 'username', 'email', 'password'] extra_kwargs = {"password": {"write_only": True}}
class ManagerUserSerializer(serializers.ModelSerializer): password = serializers.CharField(min_length=6, required=False) username = serializers.CharField( validators=[validators.UniqueValidator(models.User.objects.all())]) email = serializers.EmailField( validators=[validators.UniqueValidator(models.User.objects.all())]) class Meta: model = models.User fields = ('id', 'name', 'email', 'username', 'password', 'is_superuser', 'is_manager', 'is_staff') read_only_fields = ('is_superuser', 'is_manager', 'is_staff') def create(self, validated_data): new_password = self.validated_data.pop('password') user = super(ManagerUserSerializer, self).create(validated_data) if new_password: user.set_password(new_password) user.save() return user def update(self, instance, validated_data): new_password = self.validated_data.pop('password', None) user = super(ManagerUserSerializer, self).update(instance, validated_data) if new_password: user.set_password(new_password) user.save() return user
class SignupSerializer(serializers.Serializer): username = serializers.CharField( required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())]) email = serializers.EmailField( required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())]) password = serializers.CharField(min_length=8, required=True) password_confirmation = serializers.CharField(min_length=8, required=True)
class UserRegisterSerializer(serializers.Serializer): username = serializers.CharField( min_length=5, max_length=username_max, validators=[validators.UniqueValidator(queryset=auth.models.User.objects.all())] ) email = serializers.EmailField( max_length=email_max, validators=[validators.UniqueValidator(queryset=auth.models.User.objects.all())] ) password = serializers.CharField(min_length=6, max_length=password_max)
class CustomUserSerializer(serializers.ModelSerializer): email = serializers.CharField(validators=[ validators.UniqueValidator(message='This email already exists', queryset=CustomUser.objects.all()) ]) username = serializers.CharField(validators=[ validators.UniqueValidator(message='This username already exists', queryset=CustomUser.objects.all()) ]) password = serializers.CharField(write_only=True) role = serializers.CharField(required=True) class Meta: model = CustomUser fields = ('id', 'email', 'password', 'username', 'role', 'is_active')
class AddUserSerializer(serializers.ModelSerializer): username = serializers.CharField( required=True, validators=[ validators.UniqueValidator(queryset=CustomUserAkun.objects.all()) ]) role = serializers.CharField(required=False) password = serializers.CharField(write_only=True, required=True, validators=[validate_password]) password2 = serializers.CharField(write_only=True, required=True) email = serializers.EmailField(required=True) class Meta: model = CustomUserAkun fields = ('username', 'email', 'role', 'password', 'password2') def validate(self, attrs): if attrs['password'] is not None: if attrs['password'] != attrs['password2']: raise serializers.ValidationError( {"password": "******"}) return attrs def create(self, validated_data): user = CustomUserAkun.objects.create( username=validated_data['username'], role=validated_data['role'], email=validated_data['email']) user.set_password(validated_data['password']) user.save() return user
class CreateUserSerializer(serializers.ModelSerializer): password = serializers.CharField( style={'input_type': 'password'}, write_only=True ) username = fields.CharField( max_length=150, required=True, validators=[ validators.UniqueValidator(queryset=User.objects.all()), UsernameValidator() ] ) def validate(self, attrs): user = User(**attrs) password = attrs.get('password') try: validate_password(password, user) except ValidationError as e: raise serializers.ValidationError({'password': list(e.messages)}) return attrs def create(self, validated_data): try: return User.objects.create_user(**validated_data) except Exception as e: self.fail('cannot create user: {}'.format(e)) class Meta: model = User fields = ('id', 'username', 'email', 'first_name', 'last_name', 'password')
class Pipeline(serializers.ModelSerializer): uuid = serializers.UUIDField( read_only=True ) name = serializers.CharField( min_length=2, max_length=255, required=True, allow_null=False, allow_blank=False, validators=[ validators.UniqueValidator( queryset=PipelineModel.objects.all(), message='errorPipelineNameExists' ) ], error_messages={ 'invalid': 'errorPipelineNameRequired', 'blank': 'errorPipelineNameRequired', 'required': 'errorPipelineNameRequired', 'null': 'errorPipelineNameRequired', 'max_length': 'errorPipelineNameTooLong', 'min_length': 'errorPipelineNameTooShort', } ) class Meta(object): model = PipelineModel fields = [ 'uuid', 'name' ]
class LinkSerializer(serializers.HyperlinkedModelSerializer): url_field_name = "selflink" class Meta: model = models.Link fields = ["selflink", "short", "owner", "target"] extra_kwargs = {"selflink": {"lookup_field": "short"}} short = serializers.CharField( min_length=6, max_length=32, default=serializers.CreateOnlyDefault(models.link_default_short), validators=[validators.UniqueValidator(queryset=models.Link.objects.all())], ) owner = serializers.SlugRelatedField(read_only=True, slug_field="username") target = serializers.URLField(max_length=200, required=True) def save(self, **kwargs): # set the current user as default owner for all operations but allow explicit overwriting with # keyword arguments to `save(owner=…)` kwargs.setdefault("owner", self.context["request"].user) return super().save(**kwargs) def validate_short(self, value): """ Check that short is not changed on update operations :param value: The new value :return: The new value in validated form """ is_update = self.instance is not None if is_update and value != self.instance.short: raise serializers.ValidationError("field cannot be changed once created") return value
class UserSerializer(serializers.ModelSerializer): name = serializers.CharField(validators=[ validators.UniqueValidator(queryset=User.objects.all(), message='そのユーザは既にいます') ]) class Meta: model = User fields = ('id', 'name', 'file', 'belongs') extra_kwargs = { 'gravatar': { 'read_only': True }, 'password': { 'write_only': True }, } def validate_belongs(self, values): request = self.context['request'] for value in values: group = Group.objects.filter(id=value.id).first() if group and group.owner_id != request.user.id: raise serializers.ValidationError('このグループにユーザを追加する権限がありません') return values
class GenreSerializer(serializers.ModelSerializer): slug = serializers.SlugField(validators=[validators.UniqueValidator( queryset=Genre.objects.all())]) class Meta: model = Genre exclude = ('id',)
class CustomUserSerializer(serializers.ModelSerializer): """ We use this serializer for user registration. Most of the fields have `required=False`, but can be configured as needed. This serializer is used in `accounts.viewsets.CustomUserModelViewSet`. """ email = serializers.CharField(write_only=True, validators=[ validators.UniqueValidator( message='This email already exists', queryset=CustomUser.objects.all()) ]) password = serializers.CharField(write_only=True) birth_date = serializers.CharField(required=False) bio = serializers.CharField(required=False) gender = serializers.CharField(required=False) last_name = serializers.CharField(required=False) first_name = serializers.CharField(required=False) birth_date = serializers.CharField(required=False) class Meta: model = CustomUser fields = ('first_name', 'last_name', 'email', 'password', 'bio', 'gender', 'birth_date')
class CategorySerializer(serializers.ModelSerializer): slug = serializers.SlugField(validators=[validators.UniqueValidator( queryset=Category.objects.all())]) class Meta: model = Category exclude = ('id',)
class storageNestedWriteSerializer(storageSerializer): id = serializers.UUIDField( read_only=False, validators=[ validators.UniqueValidator(queryset=IOQueue.objects.all()) ]) storagemedium = serializers.CharField(validators=[]) class Meta: model = storage fields = storageSerializer.Meta.fields def create(self, validated_data): #print 'validated_data: %s' % repr(validated_data) storagemedium_data = eval(validated_data.pop('storagemedium')) Target_obj = StorageTargets.objects.get( id=storagemedium_data.pop('storagetarget')) storagemedium_data['storagetarget'] = Target_obj storageMedium_obj, created = storageMedium.objects.update_or_create( id=storagemedium_data['id'], defaults=storagemedium_data) ArchiveObject_obj = ArchiveObject.objects.get( ObjectUUID=validated_data.pop('archiveobject')) validated_data['archiveobject'] = ArchiveObject_obj storage_obj = storage.objects.create(storagemedium=storageMedium_obj, **validated_data) return storage_obj
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if 'id' in self.fields: self.fields['id'].validators.append( validators.UniqueValidator( queryset=self.Meta.model.objects.all()))
class UserSignupSerializer(serializers.ModelSerializer): id = rest.HashidSerializerCharField(source_field="restauth.User.id", read_only=True) email = serializers.EmailField( validators=[validators.UniqueValidator(queryset=dj_auth.get_user_model().objects.all())], ) profile = UserProfileSerializer(required=False) class Meta: model = dj_auth.get_user_model() fields = ("id", "email", "password", "jwt_token", "profile") read_only_fields = ("jwt_token",) extra_kwargs = {"password": {"write_only": True}} def validate_password(self, password): password_validation.validate_password(password) return password def create(self, validated_data): user = dj_auth.get_user_model().objects.create_user(validated_data["email"], validated_data["password"],) models.UserProfile.objects.create(user=user, **validated_data.pop("profile", {})) activation_token = tokens.account_activation_token.make_token(user) utils.user_notification_impl("account_activation", user=user, token=activation_token) return user
class SCIMMemberSerializer(serializers.ModelSerializer): id = SCIMIdField('user', read_only=True) resource_schemas = ["urn:ietf:params:scim:schemas:core:2.0:User"] resource_type = 'User' detail_view_name = 'scim-user-detail' userName = serializers.CharField(source='remote_id', required=False) externalId = serializers.CharField(source='scim_external_id') name = NameSerializer() emails = EmailsField( source='email', allow_blank=False, validators=[validators.UniqueValidator(queryset=Member.objects.all())]) active = serializers.BooleanField(source='is_active') groups = serializers.SerializerMethodField(read_only=True) schemas = SchemaSerializer(read_only=False) meta = MetaSerializer(required=False) def create(self, validated_data): validated_data['welcome_email_is_sent'] = True instance = super(SCIMMemberSerializer, self).create(validated_data) return instance def get_groups(self, obj): return UserGroupSerializer(obj.groups.exclude(name='Authenticated'), many=True, read_only=True).data class Meta(object): model = Member fields = ('id', 'externalId', 'userName', 'name', 'emails', 'active', 'groups', 'schemas', 'meta')
class CategoryListSerializer(serializers.ModelSerializer): products = ProductListSerializer( many=True, required=False, ) reference = serializers.CharField( validators=[ validators.UniqueValidator( queryset=models.Category.objects.all(), message=_("A referência já está sendo utilizada") ) ], label=_("Referência") ) class Meta: model = models.Category fields = [ 'pk', 'name', 'reference', 'description', 'amount', 'minimum', 'registration', 'products' ] read_only_fields = [ 'pk', 'amount', 'registration', ]
class Meta: model = User fields = ('username', 'email', 'password') extra_kwargs = { 'username': { 'validators': [validators.UniqueValidator(queryset=User.objects.all())] }, 'email': { 'validators': [validators.UniqueValidator(queryset=User.objects.all())] }, 'password': { 'write_only': True } }
class RegisterSerializer(serializers.ModelSerializer): username = serializers.CharField( required=True, max_length=30, min_length=5, validators=[ AuthenticationValidator.text_validator, validators.UniqueValidator(queryset=User.objects.all()), ], style={"placeholder": "Username"}, ) email = serializers.EmailField( required=True, style={ "input_type": "email", "placeholder": "Email" }, ) password = serializers.CharField( required=True, max_length=30, min_length=5, validators=[ AuthenticationValidator.text_validator, ], style={ "input_type": "password", "placeholder": "Password" }, ) class Meta: model = User fields = ["username", "email", "password"]
class UserSerializer(EnhancedModelSerializer): first_name = serializers.CharField(required=True, allow_blank=False, allow_null=False) last_name = serializers.CharField(required=True, allow_blank=False, allow_null=False) full_name = serializers.CharField(read_only=True) email = serializers.EmailField( required=True, allow_blank=False, allow_null=False, validators=[validators.UniqueValidator(queryset=User.objects.all())]) username = serializers.EmailField(read_only=True) is_active = serializers.BooleanField(default=True, read_only=True) is_admin = serializers.BooleanField(default=False, read_only=True) is_staff = serializers.BooleanField(default=False, read_only=True) is_superuser = serializers.BooleanField(default=False, read_only=True) last_login = serializers.DateTimeField(read_only=True) date_joined = serializers.DateTimeField(read_only=True) created_at = serializers.DateTimeField(read_only=True) updated_at = serializers.DateTimeField(read_only=True) timezone = serializers.CharField() profile_image = Base64ImageField(required=False) class Meta: model = User nested_fields = ('id', 'first_name', 'last_name', 'email', 'username', 'is_active', 'is_admin', 'is_superuser', 'is_staff', 'full_name', 'profile_image') fields = nested_fields + ('created_at', 'updated_at', 'last_login', 'date_joined', 'timezone')
class UserRegistrationSerializer(serializers.ModelSerializer): first_name = serializers.CharField(required=True, allow_blank=False, allow_null=False) last_name = serializers.CharField(required=True, allow_blank=False, allow_null=False) email = serializers.EmailField( required=True, allow_blank=False, allow_null=False, validators=[validators.UniqueValidator(queryset=User.objects.all())]) password = serializers.CharField(required=True, allow_blank=False, allow_null=False, style={'input_type': 'password'}) class Meta: model = User fields = ('first_name', 'last_name', 'email', 'password') def validate(self, attrs): attrs.update(is_admin=False, is_staff=False, is_superuser=False, is_active=True, username=attrs['email']) return attrs
class UserSerializer(serializers.ModelSerializer): password = serializers.CharField(write_only=True) email = CustomEmailSerializer(validators=[validators.UniqueValidator(queryset=User.objects.all())]) profile = ProfileSerializer(many=False) cars_count = serializers.IntegerField(default=0, read_only=True) def create(self, validated_data): profile = validated_data.pop("profile") password = validated_data.pop("password") user = User.objects.create(**validated_data) user.set_password(password) user.save() profile = Profile.objects.create(user=user, **profile) profile.save() return user def update(self, validated_data): email = validated_data["email"] profile_data = validated_data["profile"] user = User.objects.get(email=email) profile = user.profile profile.first_name = profile_data.get("first_name", profile.first_name) profile.last_name = profile_data.get("last_name", profile.last_name) profile.mobile = profile_data.get("mobile", profile.mobile) class Meta: model = User fields = ("id", "password", "email", "profile", "cars_count")
class NewUserRegistrationSerializer(CurrentUserSerializer): email = serializers.EmailField( required=True, validators=[User.email_validator], ) username = serializers.CharField( required=True, max_length=32, read_only=False, validators=[ User.username_validator, validators.UniqueValidator( queryset=User.objects.all(), message="This username is taken.", ), ], ) password = serializers.CharField( required=True, write_only=True, validators=[validate_password], ) invite_key = serializers.UUIDField( required=True, write_only=True, validators=[invite_key_validator], ) token = serializers.SerializerMethodField() class Meta(CurrentUserSerializer.Meta): fields = CurrentUserSerializer.Meta.fields + ( 'invite_key', 'password', 'token', ) @staticmethod def get_token(user): return AuthToken.objects.create(user=user) def create(self, validated_data): invite_key = validated_data['invite_key'] invite = Invite.objects.get(key=invite_key) if invite_key else None with transaction.atomic(): if invite: invite.delete() user = User.objects.create_user( username=validated_data['username'], email=validated_data['email'], password=validated_data['password'], invited_by=invite.offered_by if invite else None, ) return user
class UserSerializer(serializers.ModelSerializer): email = serializers.EmailField(required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())]) username = serializers.CharField(required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())]) password = serializers.CharField(required=True, min_length=8) first_name = serializers.CharField(required=False, max_length=100) last_name = serializers.CharField(required=False, max_length=100) def create(self, validated_data): user = User.objects.create_user(validated_data['username'], email=validated_data['email'], password=validated_data['password'], first_name=validated_data['first_name'], last_name=validated_data['last_name']) return user class Meta: model = User fields = ('id', 'first_name', 'last_name', 'username', 'password', 'email')
class UserSerializer(serializers.ModelSerializer): email = serializers.EmailField( validators=[validators.UniqueValidator(queryset=User.objects.all())]) class Meta: model = User fields = ("id", "username", "email", "first_name", "last_name", "role") read_only_fields = ("username", "role")
class BusDriverSerializer(serializers.Serializer): id = serializers.CharField(required=False) driver_name = serializers.CharField() email = serializers.EmailField(validators=[ validators.UniqueValidator(queryset=Users.objects.all(), message="このメールアドレスは既に使用されています.") ]) password = serializers.CharField()
class GenreSerializer(serializers.ModelSerializer): name = serializers.CharField() slug = serializers.SlugField( validators=[validators.UniqueValidator(queryset=Genre.objects.all())]) class Meta: fields = ('name', 'slug') lookup_field = 'slug' model = Genre