. . . . . Authentication & Permissions

上一篇的练习实现用户认证
API没有任何的认证策略，但是可以有一些高级的行为来实现它

认证

是在as_view里的dispatch里认证，就意味dispatch着是在自己写的方法执行前
层级关系
认证

• 什么是认证？
  • 用户身份登录验证
  • 根据提供的令牌找到用户
• REST-Framework
  • 根据令牌找到用户之后，把用户存在了Request上
• as_view
  • dispatch
    • initial
      • perform_authentication
        • request.user
          • 函数 -> 使用@Property
          • _authenticate()
            • authenticators 是Request构建来的
            • initialize_request 构建的Request
            • get_authenticators 获取构建时的认证器
            • authentication_classes 是APIView类属性
            • 认证成功会将登陆用户和令牌作为一个元组返回，否则返回None

0846.png

以后写认证器就可以在views里指定就可以了

12329.png

调的是一个函数authenticator()
如果认证成功返回的user_auth_tuple,里面是元祖，元祖里有两个元祖，一个是self.user，一个是self.auth（令牌）

自己实现，需要继承系统里的基类

6464.png

源码

里面有两个方法，一个是抽象的一个是通用，使用authenticate方法会报错，因为他是一个抽象方法
如果自己想写一个认证器，首先继承BaseAuthentication(object)这个类，然后手动来实现authenticate这个方法

class BaseAuthentication(object):
    """
    All authentication classes should extend BaseAuthentication.
    """

    def authenticate(self, request):
        """
        Authenticate the request and return a two-tuple of (user, token).
        """
        raise NotImplementedError(".authenticate() must be overridden.")

    def authenticate_header(self, request):
        """
        Return a string to be used as the value of the `WWW-Authenticate`
        header in a `401 Unauthenticated` response, or `None` if the
        authentication scheme should return `403 Permission Denied` responses.
        """
        pass

1.在自己项目中创建模块auth.py

auth.py(验证器)

继承自BaseAuthentication
alt+enter 来实现BaseAuthenticate里的抽象方法authenticate。

454531.png

authenticate方法认证成功后会返回一个元祖，元祖里有两个元素：一个是用户，一个是令牌
1.通过request.query_params.get('token')拿到token
2.通过token拿到user_id
3.同通过user_id找到use

from django.core.cache import cache
from rest_framework.authentication import BaseAuthentication

from AuthenticationAndPermission.models import User


class UserAuthentication(BaseAuthentication):
    # 认证方法   认证成功会返回一个元组， 元组中包含两个元素，一个是用户，另外一个是令牌
    def authenticate(self, request):

        try:

            token = request.query_params.get("token")

            user_id = cache.get(token)

            user = User.objects.get(pk=user_id)
        except Exception as e:
            print(e)
            return None

        return user, token

serializer.py

先只看Userserializer类

from rest_framework import serializers

from AuthenticationAndPermission.models import User, Blog, Address


class UserSerializer(serializers.ModelSerializer):

    class Meta:
        model = User
        fields = ("id", "u_name", "u_password")


class BlogSerializer(serializers.ModelSerializer):

    b_author = serializers.ReadOnlyField(source="b_author.u_name")

    class Meta:
        model = Blog
        fields = ("id", "b_title", "b_content", "b_author")


class AddressSerializer(serializers.ModelSerializer):

    class Meta:
        model = Address
        fields = ("id", "a_address")

view.py

添加验证器：
就是将代码给抽离出来了，变成了一个配置的方式
authentication_classes = ('auth.py创建的类')
get函数用来做后续判断
如果拿不到令牌，抛出异常
还是返回self.list(request, *args, **kwargs)

class BlogsAPIView(ListCreateAPIView):
    queryset = Blog.objects.all()
    serializer_class = BlogSerializer

    # 验证
    authentication_classes = (UserAuthentication)

    # 后续判断
    def get(self, request, *args, **kwargs):
        if not request.auth:
            raise APIException(detail='没有auth')
        return self.list(request, *args, **kwargs)

不重写get函数，实现验证

下面就是权限，因为登录也是一种权限，登录和没有登录页面是不一样的

权限

• 什么是权限
  • 代表操作某类，某种行为的一种限定
• REST-Framework
  • 通过用户身份判定是否具有某权限
• as_view
  • dispatch
    • initial
      • check_permissions
        • get_permissions
          • permission_classes
        • 对权限检查进行遍历
          • has_permission
          • 如果能通过权限检测，所有权限均满足
          • 有一个权限通不过，你就没有权限操作

3242345.png

dispatch里有一个initial，initial有一个执行认证函数

53.png

initial有一个执行认证函数perform_authentication(request)
下一步检查权限check_permission(request)点进去

屏幕快照 2018-11-17 下午9.23.23.png

get_permission():拿到权限进行遍历，如果有一个不通过所有就不通过，就直接拒绝。
has_permission()方法：如果能通过权限检测，所有权限均满足，有一个权限通不过，就没有权限操作

345436.png

get_peimission()是从我们自己提供的permission_classes类(就是自己定义的权限类)

21313.png

24234243.png

自定义权限

有两个方法，默认都返回True，默认都有权限

23419.png

通过request拿到user
user是User的 Model对象才能登陆的，否则就不是user，就登陆不了

from rest_framework.permissions import BasePermission

from AuthenticationAndPermission.models import User


class LoginPermission(BasePermission):

    def has_permission(self, request, view):
        try:
            user = request.user
            if isinstance(user, User):
                return True
        except Exception as e:
            print(e)
            return False

views.py

这里面的就可以将get方法去掉了

class BlogsAPIView(ListCreateAPIView):
    queryset = Blog.objects.all()
    serializer_class = BlogSerializer

    # 验证
    authentication_classes = (UserAuthentication)
    # 权限
    permission_calsses = (Loginpermission)
    # 后续判断
   # def get(self, request, *args, **kwargs):
       # if not request.auth:
           # raise APIException(detail='没有auth')
       # return self.list(request, *args, **kwargs)

queryset = Models.objects.all()
要操作的数据，操作的数据是哪个

authentication_classes = ()
认证模块解决的问题：
必须登录才能访问，如果登录了，将登录的用户和登录的令牌存在request中

permission_classes = ()
权限：根据用户的级别，限定能不能访问这个接口

如果那个接口必须登录，给这个接口价格属性就可以了

class AddressesAPIView(ListCreateAPIView):

    serializer_class = AddressSerializer
    queryset = Address.objects.all()
    authentication_classes = (UserAuthentication,)
    permission_classes = (LoginPermission,)

eg:

serializer.py

class AddressSerializer(serializers.ModelSerializer):

    class Meta:
        model = Address
        fields = ("id", "a_address")

views.py

authentication_classes 是用户登陆状态的获取
permission_classes是用户登陆状态的判断

class AddressesAPIView(ListCreateAPIView):
    serilizer_class = AddressSerializer
    queryset = Address.objects.all()
    
    # 用户登陆才能看
    authentication_classes = (UserAuthentication,)
    
    permission_classes = (LoginPermission,)

权限认证总结

• 为什么实现
• 因为它们的是在dispatch中执行的
• 在get，post，delete等之前执行的
• 提前做了检测，验证
• 和中间件有啥区别？
  • 更具灵活性
  • 在指定的类中使用

数据级联

views.py

需求在存储过程中将博客内容和用户级联在一起

分析：只要能进到authentication_classes和permission_classes中意味着已经登录了，所以只需要重写CreateAPIView，将博客内容和用户级联在一起就可以了

三个函数：
create函数：serializer：获取序列化数据，serializer_is_valid:可用的，self.perform_create(serializer):执行创建
preform_create函数：将序列化数据保存
直接修改序列化存储过程，需要重写perform_create函数,在save()的时候将user给传进去

eqqgggr07.png

重写preform_create(self, serializer):
首先拿到user，self.request.user: self代表APIView，APIView有request属性

需求二

只查出自己发表的博客

只需重写get_queryset()方法,现在的queryset是Blog，所以要根据b_author=self.request.user进行筛选

xzcz.png

如果父类里的判断功能也需要加上下面的代码:
query_set = super().get_queryset()super()是父类的代理对象
return query_set.filter(b_author=self.request.user)
这样获取就是当前用户的，
应用场景比如在做地址查询的时候，不可能查出所有地址，只能查出自己的地址

class BlogsAPIView(ListCreateAPIView):

    serializer_class = BlogSerializer
    queryset = Blog.objects.all()
    authentication_classes = (UserAuthentication,)
    permission_classes = (LoginPermission, )
   # throttle_classes = (BlogThrottling,)

    def perform_create(self, serializer):
        serializer.save(b_author=self.request.user)

    def get_queryset(self):
        return self.queryset.filter(b_author=self.request.user)
        # query_set = super().get_queryset()
        # return query_set.filter(b_author=self.request.user)

serializer.py

需要在博客里加上b_author
在存的时候就可以在views.py里serializer.save(b_author=self.request.user),但是这样会报错：'This field is required',需要重写b_author字段改为只读。b_author = serializers.ReadOnlyField()

class BlogSerializer(serializer.ModelSerializer):
    # 如果想将作者名字映射，加上下面这个字段
    b_author = serializers.ReadOnlyField(source='b_author.u_name') # 只给一个名字就不涉及到序列化了
    class Meta:
        model = Blog
            # 如果想将作者名字映射，加上下面这个字段
            fields = ('id', 'b_title', 'b_content', 'b_author')

            # 如果值返回博客内容不返回作者名字，加上下面这个字段
            fields = ('id', 'b_title', 'b_content')

urls.py

from django.conf.urls import url

from AuthenticationAndPermission import views

urlpatterns = [
    url(r'^users/', views.UsersAPIView.as_view()),
    url(r'^blogs/', views.BlogsAPIView.as_view()),
    url(r'^addresses/', views.AddressesAPIView.as_view()),
]

---

models.py

related_name='隐性属性的名字'可以不指定，如果不改就是blogs_set

from django.db import models


class User(models.Model):

    u_name = models.CharField(max_length=32, unique=True)
    u_password = models.CharField(max_length=256)

    def check_password(self, password):
        return self.u_password == password


class Blog(models.Model):
    b_title = models.CharField(max_length=128)
    b_content = models.TextField()
    # related_name='隐性属性的名字'可以不指定，如果不改就是blogs_set
    b_author = models.ForeignKey(User)


class Address(models.Model):
    a_address = models.CharField(max_length=128)
    a_user = models.ForeignKey(User)