Django 소스 혈액 세척

8681 단어
Why
많은 것들이 문서만 보고 이해할 수 없어서 관련 코드를 찾아 읽었다.
Model
비교적 복잡한 데이터 관계에 현기증이 난 후, 나의 이 LowLow의 디자인 코드 능력은 근본적으로 쓰기에 부족하다.그럼django의 사용자, 그룹, 권한 시스템부터 시작합시다.
코딩 디자인
내 코드 디자인은 똥덩어리야.
코딩 사양
내 코드는 똥덩어리야.
Djanog 1.9.6 >> Lib/site-packages/django/contrib/auth/models.py
  • 권한:
  • class Permission(models.Model):
        """
        The permissions system provides a way to assign permissions to specific
        users and groups of users.
    
        The permission system is used by the Django admin site, but may also be
        useful in your own code. The Django admin site uses permissions as follows:
    
            - The "add" permission limits the user's ability to view the "add" form
              and add an object.
            - The "change" permission limits a user's ability to view the change
              list, view the "change" form and change an object.
            - The "delete" permission limits the ability to delete an object.
    
        Permissions are set globally per type of object, not per specific object
        instance. It is possible to say "Mary may change news stories," but it's
        not currently possible to say "Mary may change news stories, but only the
        ones she created herself" or "Mary may only change news stories that have a
        certain status or publication date."
    
        Three basic permissions -- add, change and delete -- are automatically
        created for each Django model.
        """
        name = models.CharField(_('name'), max_length=255)
        content_type = models.ForeignKey(
            ContentType,
            models.CASCADE,
            verbose_name=_('content type'),
        )
        codename = models.CharField(_('codename'), max_length=100)
        objects = PermissionManager()
        class Meta:
            verbose_name = _('permission')
            verbose_name_plural = _('permissions')
            unique_together = (('content_type', 'codename'),)
            ordering = ('content_type__app_label', 'content_type__model',
                        'codename')
    
  • 그룹 관리:
  • class GroupManager(models.Manager):
        """
        The manager for the auth's Group model.
        """
        use_in_migrations = True
    
        def get_by_natural_key(self, name):
            return self.get(name=name)
    
  • 그룹:
  • class Group(models.Model):
        """
        Groups are a generic way of categorizing users to apply permissions, or
        some other label, to those users. A user can belong to any number of
        groups.
    
        A user in a group automatically has all the permissions granted to that
        group. For example, if the group Site editors has the permission
        can_edit_home_page, any user in that group will have that permission.
    
        Beyond permissions, groups are a convenient way to categorize users to
        apply some label, or extended functionality, to them. For example, you
        could create a group 'Special users', and you could write code that would
        do special things to those users -- such as giving them access to a
        members-only portion of your site, or sending them members-only email
        messages.
        """
        name = models.CharField(_('name'), max_length=80, unique=True)
        permissions = models.ManyToManyField(
            Permission,
            verbose_name=_('permissions'),
            blank=True,
        )
    
        objects = GroupManager()
    
        class Meta:
            verbose_name = _('group')
            verbose_name_plural = _('groups')
    
  • 사용자 관리:
  • class UserManager(BaseUserManager):
        use_in_migrations = True
    
        def _create_user(self, username, email, password, **extra_fields):
            """
            Creates and saves a User with the given username, email and password.
            """
            if not username:
                raise ValueError('The given username must be set')
            email = self.normalize_email(email)
            user = self.model(username=username, email=email, **extra_fields)
            user.set_password(password)
            user.save(using=self._db)
            return user
    
        def create_user(self, username, email=None, password=None, **extra_fields):
            extra_fields.setdefault('is_staff', False)
            extra_fields.setdefault('is_superuser', False)
            return self._create_user(username, email, password, **extra_fields)
    
        def create_superuser(self, username, email, password, **extra_fields):
            extra_fields.setdefault('is_staff', True)
            extra_fields.setdefault('is_superuser', True)
    
            if extra_fields.get('is_staff') is not True:
                raise ValueError('Superuser must have is_staff=True.')
            if extra_fields.get('is_superuser') is not True:
                raise ValueError('Superuser must have is_superuser=True.')
    
            return self._create_user(username, email, password, **extra_fields)
    
  • 그룹과 권한 관련:
  • class PermissionsMixin(models.Model):
        """
        A mixin class that adds the fields and methods necessary to support
        Django's Group and Permission model using the ModelBackend.
        """
        is_superuser = models.BooleanField(
            _('superuser status'),
            default=False,
            help_text=_(
                'Designates that this user has all permissions without '
                'explicitly assigning them.'
            ),
        )
        groups = models.ManyToManyField(
            Group,
            verbose_name=_('groups'),
            blank=True,
            help_text=_(
                'The groups this user belongs to. A user will get all permissions '
                'granted to each of their groups.'
            ),
            related_name="user_set",
            related_query_name="user",
        )
        user_permissions = models.ManyToManyField(
            Permission,
            verbose_name=_('user permissions'),
            blank=True,
            help_text=_('Specific permissions for this user.'),
            related_name="user_set",
            related_query_name="user",
        )
    
        class Meta:
            abstract = True
    
  • 추상 사용자:
  • class AbstractUser(AbstractBaseUser, PermissionsMixin):
        """
        An abstract base class implementing a fully featured User model with
        admin-compliant permissions.
    
        Username and password are required. Other fields are optional.
        """
        username = models.CharField(
            _('username'),
            max_length=30,
            unique=True,
            help_text=_('Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only.'),
            validators=[
                validators.RegexValidator(
                    r'^[\w.@+-]+$',
                    _('Enter a valid username. This value may contain only '
                      'letters, numbers ' 'and @/./+/-/_ characters.')
                ),
            ],
            error_messages={
                'unique': _("A user with that username already exists."),
            },
        )
        first_name = models.CharField(_('first name'), max_length=30, blank=True)
        last_name = models.CharField(_('last name'), max_length=30, blank=True)
        email = models.EmailField(_('email address'), blank=True)
        is_staff = models.BooleanField(
            _('staff status'),
            default=False,
            help_text=_('Designates whether the user can log into this admin site.'),
        )
        is_active = models.BooleanField(
            _('active'),
            default=True,
            help_text=_(
                'Designates whether this user should be treated as active. '
                'Unselect this instead of deleting accounts.'
            ),
        )
        date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
    
        objects = UserManager()
    
        USERNAME_FIELD = 'username'
        REQUIRED_FIELDS = ['email']
    
        class Meta:
            verbose_name = _('user')
            verbose_name_plural = _('users')
            abstract = True
    
  • 사용자(Why?):
  • class User(AbstractUser):
        """
        Users within the Django authentication system are represented by this
        model.
    
        Username, password and email are required. Other fields are optional.
        """
        class Meta(AbstractUser.Meta):
            swappable = 'AUTH_USER_MODEL'
    

    좋은 웹페이지 즐겨찾기