Django에서 자주 사용하는 웹 응용 프로그램 도구

Django는 캐시, 로그, 메일 발송, 사용자 정의 인증 등 웹 응용 프로그램 개발에 필요한 다양한 상용 도구를 제공합니다. 1. 사용자 정의 권한
주어진 모델 객체에 대한 사용자 정의 권한을 만들려면 permissions 모델 메타 속성을 사용합니다.

#          ，         Task             
class Task(models.Model):
    ...
    class Meta:
        permissions = [
            ("change_task_status", "         "),
            ("close_task", "                   "),
        ]

사용자에게 권한이 있는지 확인하려면 다음과 같이 하십시오.

user.has_perm('app.close_task')         # has_perm()    

추가 사용 권한은 테이블을 볼 수 있습니다auth_permission.
2. 기존 User 모델 확장
2.1 User 일대일 연결
이와 관련된 정보User를 저장하고 싶으면 aOneToOneField를 사용하여 이 필드를 포함하는 모델에 가서 다른 정보를 얻을 수 있습니다.이러한 일대일 모델을 일반적으로 프로필 모델이라고 하는데, 왜냐하면 사이트 사용자에 대한 비신분 검증과 관련된 정보를 저장할 수 있기 때문이다.예를 들어, Employee 모델을 생성할 수 있습니다.

from django.contrib.auth.models import User

class Employee(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    department = models.CharField(max_length=100)

액세스:

>>> u = User.objects.get(username='fsmith')
>>> freds_department = u.employee.department

관리자의 사용자 페이지에 프로파일 모델 필드를 추가하려면admin.py:

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.models import User

from my_user_profile_app.models import Employee

# Define an inline admin descriptor for Employee model
# which acts a bit like a singleton
class EmployeeInline(admin.StackedInline):
    model = Employee
    can_delete = False
    verbose_name_plural = 'employee'

# Define a new User admin
class UserAdmin(BaseUserAdmin):
    inlines = (EmployeeInline,)

# Re-register UserAdmin
admin.site.unregister(User)
admin.site.register(User, UserAdmin)

2.2 사용자 정의User 모델 교체
만약 네가 auth_user 이 시계 이름을 사용하고 싶지 않다면, 너도 settings 에서 설정할 수 있다.

AUTH_USER_MODEL = 'myapp.MyUser'

2.3 프로젝트를 시작할 때 사용자 정의 사용자 모델 사용
새 프로젝트를 시작하려면 기본값User 모델이 충분하더라도 사용자 정의 사용자 모델을 설정하는 것이 좋습니다.이 모델의 동작은 기본 사용자 모델과 동일하지만 필요하면 나중에 사용자 정의할 수 있습니다.

from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    pass

그것을 지적하는 것을 잊지 마라. AUTH_USER_MODEL마이그레이션을 생성하거나 처음 실행하기 전에 이 작업을 수행합니다.manage.py migrate
또한 응용 프로그램에 모델을 등록admin.py합니다.

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import User

admin.site.register(User, UserAdmin)

2.4 사용자 정의 인증
Django의 권한 프레임워크를 사용자 클래스에 포함시키기 위해 Django가 제공했습니다 PermissionsMixin.이것은 추상적인 모델로 사용자 모델의 클래스 차원 구조에 포함될 수 있으며 Django 권한 모델을 지원하는 데 필요한 모든 방법과 데이터베이스 필드를 제공할 수 있습니다.PermissionsMixin는 다음과 같은 메서드와 속성을 제공합니다.

is_superuser()

has_perm (perm): 지정된 권한이 있는지 여부

has_perms(perm list): 사용 권한 목록

위의 세 가지를 제외하고는 홈페이지에서 제공한 문서나 원본을 볼 수 있다. .
1、 settings.py

AUTH_USER_MODEL = 'crm.UserProfile'

2、 models.py
models에서 사용자 인증을 사용자 정의하고 다음 세 가지 종류를 계승하여 Django가 제공하는 권한 도구, 사용자 인증 등 도구를 사용할 수 있습니다.

BaseUserManager: 일반, 수퍼유저 생성 방법 또는 속성 제공

AbstractBaseUser: 비밀번호를 암호화하고 사용자의 로그인 여부를 검증하는 방법이나 속성을 제공

PermissionsMixin: 권한 관련 메서드 또는 속성 제공

from django.db import models
from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser, PermissionsMixin
)

class UserProfileManager(BaseUserManager):
    def create_user(self, email, name, password=None):
        """      """
        if not email:
            raise ValueError('           ')

        user = self.model(
            email=self.normalize_email(email),
            name=name,
        )
        #          （md5+salt）
        user.set_password(password)
        user.save(using=self._db)   #   
        return user

    def create_superuser(self, email, name, password):
        """      """
        user = self.create_user(
            email,
            password=password,
            name=name,
        )
        user.is_admin = True    
        user.save(using=self._db)
        return user


class UserProfile(AbstractBaseUser,PermissionsMixin):
    email = models.EmailField(
        verbose_name='  ',
        max_length=255,
        unique=True,
    )
    name = models.CharField(max_length=64)
    role = models.ManyToManyField(Role, blank=True, null=True)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)
    #            ，     
    objects = UserProfileManager()

    USERNAME_FIELD = 'email'
    #       
    REQUIRED_FIELDS = ['name']

    def __str__(self):
        return self.email

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

    def has_module_perms(self, app_label):
        "           app `app_label`?"
        return True

    def get_full_name(self):
        # The user is identified by their email address
        return self.email

    def get_short_name(self):
        # The user is identified by their email address
        return self.email

    @property
    def is_staff(self):
        "Is the user a member of staff?"
        # Simplest possible answer: All admins are staff
        return self.is_admin

3、 admin.py

from django import forms
from django.contrib import admin
from django.contrib.auth.models import Group
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField

from app01.models import UserProfile


class UserCreationForm(forms.ModelForm):
    """          。         ，       ."""
    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)

    class Meta:
        model = UserProfile
        fields = ('email', 'name')

    #     
    def clean_password2(self):
        # Check that the two password entries match
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError("       ")
        return password2

    def save(self, commit=True):
        # Save the provided password in hashed format
        #      save()
        user = super(UserCreationForm, self).save(commit=False)
        #          
        user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
        return user


class UserChangeForm(forms.ModelForm):
    """         。         ，  admin's              .
    """
    #          
    password = ReadOnlyPasswordHashField()

    class Meta:
        model = UserProfile
        fields = ('email', 'password', 'name', 'is_active', 'is_superuser')

    def clean_password(self):
        # Regardless of what the user provides, return the initial value.
        # This is done here, rather than on the field, because the
        # field does not have access to the initial value
        return self.initial["password"]


class UserProfileAdmin(BaseUserAdmin):
    # The forms to add and change user instances
    form = UserChangeForm
    add_form = UserCreationForm

    # The fields to be used in displaying the User model.
    # These override the definitions on the base UserAdmin
    # that reference specific fields on auth.User.
    list_display = ('email', 'name','is_superuser')
    list_filter = ('is_superuser',)
    fieldsets = (
        (None, {'fields': ('email', 'password')}),
        ('Personal info', {'fields': ('name',)}),
        ('Permissions', {'fields': ('is_staff','is_active','role','user_permissions','groups','is_superuser')}),
    )
    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
    # overrides get_fieldsets to use this attribute when creating a user.
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'name', 'password1', 'password2')}
        ),
    )
    search_fields = ('email',)
    ordering = ('email',)
    filter_horizontal = ('role','user_permissions','groups')

# Now register the new UserProfileAdmin...
admin.site.register(UserProfile, UserProfileAdmin)
# ... and, since we're not using Django's built-in permissions,
# unregister the Group model from admin.
# admin.site.unregister(Group)