Сериализатор Django-rest-framework не будет хэшировать пароль

Question

Привет, я пытаюсь отобразить хешированный пароль в API для просмотра.Я переключил стандартный алгоритм хеширования на Bcrypt.Кажется, я не могу хэшировать поле пароля на моем сериализаторе, я делал это раньше в другом проекте и ссылался на него, но все то же самое.Может ли кто-нибудь помочь мне с этим?Примечание. Хеширование работает в консоли при регистрации суперпользователя.Теперь я создал сериализатор для административного пользователя и не могу отображать хэш в доступном для просмотра API, как мой предыдущий проект.

from rest_framework import serializers
from App1.models import (AdminUser, RegularUser)

#--------------------------ADMIN SERIALIZER REGISTER------------------------
class AdminUserSerializer(serializers.ModelSerializer):
    """ This is a serializer connected to the AdminUser model in models.py
     used to register a new Admin with full permissions. """

    id = serializers.ReadOnlyField()
    password = serializers.CharField(max_length=255,
    style={'input_type':'password'})

    class Meta:

        model = AdminUser

        fields = ('id', 'ADMIN_PROFILE_PIC','admin_date_of_birth',
         'admin_first_name', 'admin_last_name', 'admin_email', 'password',
         'admin_phone_number',)

        read_only_fields = ('id', 'last_login', 'admin_date_joined',)

        depth = 1

        extra_kwargs = {'password':{'write_only':True}}

        def create(self, validated_data):
            """ This creates an Admin User instance """

            new_admin = AdminUser(
                ADMIN_PROFILE_PIC=validated_data['ADMIN_PROFILE_PIC'],
                admin_first_name=validated_data['admin_first_name'],
                admin_last_name=validated_data['admin_last_name'],
                admin_email=validated_data['admin_email'],
                admin_phone_number=validated_data['admin_phone_number'],
            )

            new_admin.set_password(validated_data['password'])
            new_admin.save()

            return new_admin

#------------------------------END---------------------------------------

-------------------------------VIEWS.PY----------------------------------
from django.shortcuts import render
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from rest_framework import filters
from rest_framework.decorators import action
from App1.models import (AdminUser, RegularUser)
from App1.serializers import (AdminUserSerializer, RegularUserSerializer)
from rest_framework.authentication import (TokenAuthentication)
# Create your views here.

#----------------------------ADMIN MODEL VIEWSET--------------------------
class AdminUserViewset(viewsets.ModelViewSet):
    """ This is a viewset to display a registration form to create
     a new user """

    queryset = AdminUser.objects.all()
    serializer_class = AdminUserSerializer
    filter_backends = (filters.SearchFilter,)
    authentication_classes = (TokenAuthentication,)
    search_fields = ('id','admin_first_name', 'admin_email', 'admin_last_name',
     'admin_phone_number')

    @action(methods=['POST'], detail=True)
    def set_password(self, request, pk=None):
        """ This creates a user instance and finalizes our serializer """

        serializer = AdminUserSerializer(data=request.data)

        if serializer.is_valid(raise_exception=True):
            admin_user_now.save()
            admin_first_name = serializer.data.get('admin_first_name')
            admin_last_name = serializer.data.get('admin_last_name')
            message = ("Hellow {} {} welcome to Bonky").format(admin_first_name, admin_last_name)
            return Response({'message':message})

        else:
            return Response(serializer.errors,
             status=status.HTTP_404_BAD_REQUEST)


#---------------------------------END------------------------------------
#------------------------------MODELS.PY-------------------------------
from django.db import models
from django.contrib.auth.models import (BaseUserManager, AbstractBaseUser,
 PermissionsMixin)
from datetime import datetime

# Create your models here.

#------------------------- Admin User Model class------------------------
class AdminUserModelManager(BaseUserManager):
    """ This is a model manager to provide updates and perform operations
     like crud (Create, Read, Update, Delete) to the admin.py """

    def create_user(self, admin_first_name, admin_last_name,
     admin_email, admin_phone_number, admin_date_of_birth, password=None):
        """ This will create a admin user in our database """

        if not admin_first_name:
            raise ValueError("Please enter in a first name.")
        if not admin_last_name:
            raise ValueError("Please enter in a last name.")
        if not admin_email:
            raise ValueError("Please enter in a email.")

        admin_email = self.normalize_email(admin_email)
        admin_user = self.model(
            admin_first_name=admin_first_name,
            admin_last_name=admin_last_name,
            admin_email=admin_email,
            admin_phone_number=admin_phone_number,
            admin_date_of_birth=admin_date_of_birth,
        )

        admin_user.set_password(password)
        admin_user.save(using=self._db)

        return admin_user

    def create_superuser(self, admin_first_name, admin_last_name, admin_email,
     admin_phone_number, admin_date_of_birth, password):

        """ this create a superuser in our database. """

        new_admin_user = self.create_user(
            admin_first_name=admin_first_name,
            admin_last_name=admin_last_name,
            password=password,
            admin_email=admin_email,
            admin_phone_number=admin_phone_number,
            admin_date_of_birth=admin_date_of_birth,
        )

        new_admin_user.is_staff = True
        new_admin_user.is_admin = True
        new_admin_user.is_superuser = True
        new_admin_user.is_active = True

        return new_admin_user


# Points to the AdminUserModel
class AdminUser(AbstractBaseUser, PermissionsMixin):
    """ This class points to the AdminUserModelManager class and also
     inherits from PermissionsMixin class (predefined Django class) """

    # Admin Profle Photo
    ADMIN_PROFILE_PIC = models.ImageField(null=True, blank=True,
     upload_to='App1/static/images/', verbose_name='Profile Photo')

    admin_first_name = models.CharField(verbose_name='first name', max_length=255)
    admin_last_name = models.CharField(verbose_name='last name', max_length=255)
    admin_email = models.EmailField(verbose_name='email address',
     max_length=255, unique=True)
    admin_phone_number = models.CharField(verbose_name='phone number', max_length=255)
    admin_date_of_birth = models.DateField(verbose_name='date of birth',
     null=True, blank=True)
    admin_date_joined = models.DateField(auto_now_add=True)
    is_staff = models.BooleanField(default=True)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=True)
    is_superuser = models.BooleanField(default=True)

    # POINTER TO THE ADMINUSERMODEL CLASS
    objects = AdminUserModelManager()

    USERNAME_FIELD = 'admin_email'

    REQUIRED_FIELDS = ['admin_first_name', 'admin_last_name', 'admin_phone_number',
     'admin_date_of_birth']

    def get_full_name(self):
        """ Will get the full name of a administrative user """

        return self.admin_first_name

    def get_short_name(self):
        """ Gets the short/nickname of the administrative user """

        return self.admin_first_name

    def get_username(self):
        """ This gets the username of the _ADMIN USER """

        return self.admin_email

    def __str__(self):
        """ Django needs this so it can give us a string representation
         of the object and it's fields """

        return (self.admin_first_name + ' ' + self.admin_last_name +
         ' ' + self.admin_email)

#----------------------------END ADMIN MODEL-----------------------------

Answer 1

Не совсем уверен, в чем проблема, но вот рабочая комбинация model с serializer и view.

ТРЕБОВАНИЯ: Django == 2.1, djangorestframework == 3.9.0

ЦЕЛЬ: Хэш-пароль!

MODELS.PY

from django.db import models
from django.contrib.auth.models import (BaseUserManager, AbstractBaseUser,
 PermissionsMixin)
# Create your models here.

#---------------------------ADMIN CUSTOMIZATION---------------------------------
class ManagerialUser(BaseUserManager):
    """ This is a manager to perform duties such as CRUD(Create, Read,
     Update, Delete) """

    def create_user(self, email, name, password=None):
         """ This creates a admin user object """

         if not email:
             raise ValueError("It is mandatory to require an email!")

         if not name:
             raise ValueError("Please provide a name:")

         email = self.normalize_email(email=email)
         user = self.model(email=email, name=name)

         """ This will allow us to store our password in our database
         as a hash """
         user.set_password(password)
         user.save(using=self._db)

         return user


    def create_superuser(self, email, name, password):
         """ This creates a superuser for our Django admin interface"""

         user = self.create_user(email, name, password)
         user.is_superuser = True
         user.is_staff = True
         user.save(using=self._db)

         return user


class AdminUser(AbstractBaseUser, PermissionsMixin):
    """ This represents a admin User in the system and gives specific permissions
 to this class. This class wont have staff permissions """

    # We do not want any email to be the same in the database.
    email = models.EmailField(max_length=255, unique=True)
    name = models.CharField(max_length=255)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)

    USERNAME_FIELD = 'email'

    REQUIRED_FIELDS = ['name',]

    # CLASS POINTER FOR CLASS MANAGER
    objects = ManagerialUser()

    def get_full_name(self):
        """ This function returns a users full name """

        return self.name

    def get_short_name(self):
        """ This will return a short name or nickname of the admin user
        in the system. """

        return self.name

    def __str__(self):
        """ A dunder string method so we can see a email and or
        name in the database """

        return self.name + ' ' + self.email
#--------------------------END AMDIM CLASSES------------------------------------
#--------------------------Start Regular Users----------------------------------

class RegularUserManager(BaseUserManager):
    """ Manages the regular everyday users in our database """

    def create_user(self, email, name, password=None):
        """ This creates a regular user in our system """

        if not email:
            raise ValueError("Please enter in an email!")

        if not name:
            raise ValueError("Please enter in a first name!")

        def normalize_email(self):
            """ This will make the every regular users email lowercase """

            email = normalize_email(email=email)
            user = self.model(email=email, name=name)

            return user


        def set_password(self, password):
            """ This allows the regular user to set a set_password and hash
            it in our database """

            user = self.create_user(email, name, password)

            user.is_superuser = False
            user.is_staff = False
            user.is_active = False
            user.set_password(password)
            user.save(using=self._db)

            return user


class RegularUser(AbstractBaseUser):
    """ A regular user in our database and they're permissions """

    email = models.EmailField(max_length=255, unique=True)
    name =  models.CharField(max_length=255)
    last_name = models.CharField(max_length=255)
    phone_number = models.CharField(max_length=20)
    is_active = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)
    is_superuser = models.BooleanField(default=False)

    USERNAME_FIELD = 'email'

    REQUIRED_FIELDS = ['name',]

    # THIS POINTS TO OUR CLASS MANAGER
    objects = RegularUserManager()

    def get_full_name(self):
        """ Gets full name of the regular user """

        return self.name

    def get_short_name(self):
        """ Gets short or nickname of the regular user """

        return self.name


    def __str__(self):
        """ Dunder method defined to return a readable copy of a string """

        return self.name + ' ' + self.last_name + ' ' + self.email

SERIALIZERS.PY

from rest_framework import serializers
from datetime import datetime
from App1.models import (AdminUser, RegularUser)

class ProfileSerializer(serializers.ModelSerializer):
    """ A serializer for our user profiles """

    id = serializers.ReadOnlyField()
    is_active = serializers.ReadOnlyField()
    password = serializers.CharField(max_length=255,
     style={'input_type': 'password'})


    class Meta:

        model = RegularUser
        fields = ['id', 'is_active', 'name',
         'last_name','email','password', 'phone_number']

        extra_kwargs = {'password': {'write_only':True}}


    def create(self, validated_data):
        """ Creates and returns a new user """

        # Validating Data
        user = RegularUser(
        name=validated_data['name'],
        last_name=validated_data['last_name'],
        email=validated_data['email'],
        phone_number=validated_data['phone_number'],
        )

        user.set_password(validated_data['password'])
        user.save()

        return user

VIEWS.PY

from django.shortcuts import render
from rest_framework.response import Response
from App1.serializers import (ProfileSerializer)
from rest_framework import status
from rest_framework import viewsets
from App1.models import (AdminUser, RegularUser)
from rest_framework.authentication import TokenAuthentication
from rest_framework import filters
# Create your views here.

class RegularAPIViewSet(viewsets.ModelViewSet):
    """ The functionallity of this class allows the user to register
     themeselves as a regular based user in our system """

    queryset = RegularUser.objects.all()
    serializer_class = ProfileSerializer
    filter_backends = (filters.SearchFilter,)
    search_fields = ('name', 'email', 'phone_number')

    def create(self, request):
        """ This validates and saves the registered regular user
         in the database. """

        serializer = ProfileSerializer(data=request.data)
        queryset = RegularUser.objects.all()

        if serializer.is_valid():
            serializer.save()
            id = serializer.data.get('id')
            name = serializer.data.get('name')
            last_name = serializer.data.get('last_name')
            message = "Hellow ID:{}, {} {}".format(id, name, last_name)

            return Response({'message':message})
        else:
            return Response(serializer.errors,
             status=status.HTTP_400_BAD_REQUEST)

Answer 2

Пользователь serializer.save () вместо пользователя admin_user_now.save ().