Django rest framework 无法使用自定义用户模型Django Rest框架登录

我只是用Django for Django Rest框架创建了一个

自定义用户模型

， 我创建

泛型.ListAPIView

以获取用户列表并创建新用户 然后我用

views.APIView

创建登录视图，并用验证覆盖post（）。但是当我点击

“POST”

，它返回的

“用户已经存在”

。为什么登录方法在我使用django rest auth时也尝试创建帐户

提前谢谢

这是密码

型号.py

class AccountManager(BaseUserManager):
    def create_user(self, email, first_name=None, last_name=None, password=None, is_active=True, is_staff=False, is_admin=False, is_superuser=False):
        if not email:
            raise ValueError("User must have an email address")
        if not password:
            raise ValueError("User must have a password")
        if not first_name:
            raise ValueError("User must have a first name")
        user = self.model(
                email=self.normalize_email(email)
            )
        user.set_password(password)
        user.first_name = first_name
        user.last_name = last_name
        user.staff = is_staff
        user.admin = is_admin
        user.active = is_active
        user.superuser = is_superuser
        user.save(using=self._db)
        return user

    def create_superuser(self, email, first_name=None, last_name=None, password=None):
        user = self.create_user(
                email=email,
                first_name = first_name,
                last_name = last_name,
                password=password,
                is_superuser=True,
                is_staff=True,
                is_admin=True,

            )
        return user

class Account(AbstractBaseUser):
    email       =models.EmailField(max_length=255, unique=True)
    first_name  = models.CharField(max_length=255,default='')
    last_name   = models.CharField(max_length=255, default='')
    active      = models.BooleanField(default=True)
    staff       = models.BooleanField(default=False)
    admin       = models.BooleanField(default=False)
    superuser   = models.BooleanField(default=False)
    created_data = models.DateTimeField(auto_now_add=True)
    last_login = models.DateTimeField(auto_now=True)

    #USERNAME_FIELD and password are required by default
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']

    objects = AccountManager()

    def __str__(self):
        return self.email

    def get_full_name(self):
        return (self.first_name + self.last_name)

    def get_short_name(self):
        return self.first_name

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_admin(self):
        return self.admin

    @property
    def is_staff(self):
        return self.staff

    @property
    def is_superuser(self):
        return self.superuser

class AccountRegistrationSerializer(serializers.ModelSerializer):
    # password = serializers.CharField(style={'input_type':'password'}, write_only=True)
    password2 = serializers.CharField(style={'input_type':'password'}, write_only=True)
    class Meta:
        model = Account
        extra_kwargs = {
                    'password': {'write_only': True}
        }
        fields = ['email', 'first_name', 'last_name','password', 'password2',]

    def create(self, validated_data):
        account = Account(
            email=self.validated_data['email'],
            first_name=self.validated_data['first_name'],
            last_name=self.validated_data['last_name']
            )
        password = self.validated_data['password']
        password2 = self.validated_data['password2']

        if password != password2:
            raise serializer.ValidationError({'password':'Passwords must match'})
        account.set_password(password)
        account.save()
        return account

class AccountLoginSerializer(serializers.ModelSerializer):

    class Meta:
        model = Account
        extra_kwargs = {
            'password': {
                'write_only': True
            },
            'first_name': {
                'read_only': True
            },
            'last_name': {
                'read_only': True
            },

        }
        fields = ['email', 'first_name', 'last_name', 'password']

    def validate(self, data):
        return data

class AccountLoginView(APIView):
    permission_classes = [AllowAny,]
    serializer_class = AccountLoginSerializer
    def post(self, request, *args, **kwargs):
        data = request.data
        serializer = AccountLoginSerializer(data=data)
        if serializer.is_valid(raise_exception=True):
            new_data = serializer.data
            return Response(new_data, status=HTTP_200_OK)
        return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)

序列化程序.py

class AccountManager(BaseUserManager):
    def create_user(self, email, first_name=None, last_name=None, password=None, is_active=True, is_staff=False, is_admin=False, is_superuser=False):
        if not email:
            raise ValueError("User must have an email address")
        if not password:
            raise ValueError("User must have a password")
        if not first_name:
            raise ValueError("User must have a first name")
        user = self.model(
                email=self.normalize_email(email)
            )
        user.set_password(password)
        user.first_name = first_name
        user.last_name = last_name
        user.staff = is_staff
        user.admin = is_admin
        user.active = is_active
        user.superuser = is_superuser
        user.save(using=self._db)
        return user

    def create_superuser(self, email, first_name=None, last_name=None, password=None):
        user = self.create_user(
                email=email,
                first_name = first_name,
                last_name = last_name,
                password=password,
                is_superuser=True,
                is_staff=True,
                is_admin=True,

            )
        return user

class Account(AbstractBaseUser):
    email       =models.EmailField(max_length=255, unique=True)
    first_name  = models.CharField(max_length=255,default='')
    last_name   = models.CharField(max_length=255, default='')
    active      = models.BooleanField(default=True)
    staff       = models.BooleanField(default=False)
    admin       = models.BooleanField(default=False)
    superuser   = models.BooleanField(default=False)
    created_data = models.DateTimeField(auto_now_add=True)
    last_login = models.DateTimeField(auto_now=True)

    #USERNAME_FIELD and password are required by default
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']

    objects = AccountManager()

    def __str__(self):
        return self.email

    def get_full_name(self):
        return (self.first_name + self.last_name)

    def get_short_name(self):
        return self.first_name

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_admin(self):
        return self.admin

    @property
    def is_staff(self):
        return self.staff

    @property
    def is_superuser(self):
        return self.superuser

class AccountRegistrationSerializer(serializers.ModelSerializer):
    # password = serializers.CharField(style={'input_type':'password'}, write_only=True)
    password2 = serializers.CharField(style={'input_type':'password'}, write_only=True)
    class Meta:
        model = Account
        extra_kwargs = {
                    'password': {'write_only': True}
        }
        fields = ['email', 'first_name', 'last_name','password', 'password2',]

    def create(self, validated_data):
        account = Account(
            email=self.validated_data['email'],
            first_name=self.validated_data['first_name'],
            last_name=self.validated_data['last_name']
            )
        password = self.validated_data['password']
        password2 = self.validated_data['password2']

        if password != password2:
            raise serializer.ValidationError({'password':'Passwords must match'})
        account.set_password(password)
        account.save()
        return account

class AccountLoginSerializer(serializers.ModelSerializer):

    class Meta:
        model = Account
        extra_kwargs = {
            'password': {
                'write_only': True
            },
            'first_name': {
                'read_only': True
            },
            'last_name': {
                'read_only': True
            },

        }
        fields = ['email', 'first_name', 'last_name', 'password']

    def validate(self, data):
        return data

class AccountLoginView(APIView):
    permission_classes = [AllowAny,]
    serializer_class = AccountLoginSerializer
    def post(self, request, *args, **kwargs):
        data = request.data
        serializer = AccountLoginSerializer(data=data)
        if serializer.is_valid(raise_exception=True):
            new_data = serializer.data
            return Response(new_data, status=HTTP_200_OK)
        return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)

视图.py

class AccountManager(BaseUserManager):
    def create_user(self, email, first_name=None, last_name=None, password=None, is_active=True, is_staff=False, is_admin=False, is_superuser=False):
        if not email:
            raise ValueError("User must have an email address")
        if not password:
            raise ValueError("User must have a password")
        if not first_name:
            raise ValueError("User must have a first name")
        user = self.model(
                email=self.normalize_email(email)
            )
        user.set_password(password)
        user.first_name = first_name
        user.last_name = last_name
        user.staff = is_staff
        user.admin = is_admin
        user.active = is_active
        user.superuser = is_superuser
        user.save(using=self._db)
        return user

    def create_superuser(self, email, first_name=None, last_name=None, password=None):
        user = self.create_user(
                email=email,
                first_name = first_name,
                last_name = last_name,
                password=password,
                is_superuser=True,
                is_staff=True,
                is_admin=True,

            )
        return user

class Account(AbstractBaseUser):
    email       =models.EmailField(max_length=255, unique=True)
    first_name  = models.CharField(max_length=255,default='')
    last_name   = models.CharField(max_length=255, default='')
    active      = models.BooleanField(default=True)
    staff       = models.BooleanField(default=False)
    admin       = models.BooleanField(default=False)
    superuser   = models.BooleanField(default=False)
    created_data = models.DateTimeField(auto_now_add=True)
    last_login = models.DateTimeField(auto_now=True)

    #USERNAME_FIELD and password are required by default
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']

    objects = AccountManager()

    def __str__(self):
        return self.email

    def get_full_name(self):
        return (self.first_name + self.last_name)

    def get_short_name(self):
        return self.first_name

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_admin(self):
        return self.admin

    @property
    def is_staff(self):
        return self.staff

    @property
    def is_superuser(self):
        return self.superuser

class AccountRegistrationSerializer(serializers.ModelSerializer):
    # password = serializers.CharField(style={'input_type':'password'}, write_only=True)
    password2 = serializers.CharField(style={'input_type':'password'}, write_only=True)
    class Meta:
        model = Account
        extra_kwargs = {
                    'password': {'write_only': True}
        }
        fields = ['email', 'first_name', 'last_name','password', 'password2',]

    def create(self, validated_data):
        account = Account(
            email=self.validated_data['email'],
            first_name=self.validated_data['first_name'],
            last_name=self.validated_data['last_name']
            )
        password = self.validated_data['password']
        password2 = self.validated_data['password2']

        if password != password2:
            raise serializer.ValidationError({'password':'Passwords must match'})
        account.set_password(password)
        account.save()
        return account

class AccountLoginSerializer(serializers.ModelSerializer):

    class Meta:
        model = Account
        extra_kwargs = {
            'password': {
                'write_only': True
            },
            'first_name': {
                'read_only': True
            },
            'last_name': {
                'read_only': True
            },

        }
        fields = ['email', 'first_name', 'last_name', 'password']

    def validate(self, data):
        return data

class AccountLoginView(APIView):
    permission_classes = [AllowAny,]
    serializer_class = AccountLoginSerializer
    def post(self, request, *args, **kwargs):
        data = request.data
        serializer = AccountLoginSerializer(data=data)
        if serializer.is_valid(raise_exception=True):
            new_data = serializer.data
            return Response(new_data, status=HTTP_200_OK)
        return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)

---

我问这个问题已经5天了。 我通过重写到_internal_value方法并验证序列化程序解决了这个问题

序列化程序.py

def to_internal_value(self, data):   
    try:
        try:
            email = data["email"]
            user = Account.objects.filter(email=email)
            return data
        except KeyError:
            raise serializers.ValidationError({'email':'Please Input your Email'})
        except ValueError:
            raise serializers.ValidationError({'email':'Email Not Valid'})
    except Account.DoesNotExist:
        raise serializers.ValidationError({'error':'Database Error'})

def validate(self, data):
    user_obj=None
    email = data.get('email', None)
    password = data.get('password', None)
    if not email and not username:
        raise ValidationError({"error":"Need to be filled"})

    user = Account.objects.filter(
            Q(email=email)
        ).distinct()
    user = user.exclude(email__isnull=True).exclude(email__iexact='')
    if user.exists() and user.count() == 1:
        user_obj = user.first()
    else:
        raise ValidationError({"email":"Not valid"})
    if user_obj:
        if not user_obj.check_password(password):
            raise ValidationError({"password":"Incorrect credentials please try again"})
    new_data = user_obj
    return new_data

---

看起来您不是在登录，而是在创建新用户。我希望它会返回数据。或者serializer.is_有效，它将允许我们将用户创建为默认用户？您是否在settings.py中将自定义用户模型指定为默认用户模型

AUTH\u USER\u MODEL='app.Account'

yes，我是AUTH\u USER\u MODEL='Account.Account'这可能是因为我使用ModelSerializer登录，所以序列化程序.is\u valid（）将引用帐户创建模型？