from urllib import parse


def outer(func):
    def inner(request, *args, **kwargs):
        # func 就是视图函数,第一个参数一定是request
        # 取出请求体数据
        # request.body  # json:{}   urlencoded：key=value&key1=value2  formdata：sdfaasfd
        try:
            # json格式能load成功
            request.data = json.loads(request.body)
        except Exception as e:
            request.data = request.POST
            if request.method == 'PUT':
                # key=value&key1=value2---》字典形式
                # body中是bytes格式---》转成字符串
                body_in = str(request.body, encoding='utf-8')  # 等同于  request.body.decode()
                body_in = parse.unquote(body_in)  # url 编码和解码
                # request.data = {item.split('=')[0]: item.split('=')[1] for item in body_in.split('&')}

                # 笨办法
                d = {}
                sp_1 = body_in.split('&')
                for item in sp_1:
                    key, value = item.split("=")
                    d[key] = value
                request.data = d
        res = func(request, *args, **kwargs)
        return res

    return inner


from django.http import JsonResponse


@outer
def index(request):
    print(request.data)
    return JsonResponse({"code": 100})

## 咱们的装饰器，不能装cbv中得方法
class IndexView(APIView):
    def post(self,request):
        return Response('ok')

from .serializer import AuthorSerializer


class AuthorView(APIView):
    def post(self, request):
        ser = AuthorSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '创建成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})

这个序列化类用来---》反序列化
class AuthorSerializer(serializers.ModelSerializer):
    # 表中有的字段会映射过来，没有的字段，必须重写
    telephone = serializers.CharField()
    birthday = serializers.CharField()
    addr = serializers.CharField()

    class Meta:
        model = Author
        fields = ['name', 'age', 'telephone', 'birthday', 'addr']  # 前端提交过来的字段

    # 必须重写create
    def create(self, validated_data):
        telephone = validated_data.pop('telephone')
        birthday = validated_data.pop('birthday')
        addr = validated_data.pop('addr')
        # 先创建作者详情
        author_detail = AuthorDetail.objects.create(telephone=telephone, birthday=birthday, addr=addr)
        validated_data['author_detail'] = author_detail
        author = Author.objects.create(**validated_data)

        return author

#1  执行 ser.is_valid() 就会执行 反序列化的校验---》字段自己--》局部钩子---》全局钩子
#2  入口是：ser.is_valid()---》BaseSerializer 找到了
    1 自己写的BookSerializer---》serializer.Serializer---->BaseSerializer 
    2 源码如下
    def is_valid(self, *, raise_exception=False):
        # self 是 ser对象---》自己写的BookSerializer的对象--》一开始没有
        # 一旦有了，就不执行了，优化is_valid被多次调用，只会走一次校验
        if not hasattr(self, '_validated_data'):
            try:
                # 一旦执行过，以后self中就有_validated_data
                # 接下来看self.run_validation(self.initial_data)
                self._validated_data = self.run_validation(self.initial_data)
            except ValidationError as exc:
                self._validated_data = {}
                self._errors = exc.detail
            else:
                self._errors = {}

        if self._errors and raise_exception:
            raise ValidationError(self.errors)

        return not bool(self._errors)
      3 self.run_validation(self.initial_data)---》serializer.Serializer类的，不要按住ctrl点击，否则会进 Field 类，看错了
        
      4 serializer.Serializer类的run_validation
        def run_validation(self, data=empty):
            # data前端传入的--{"name":"张三","age":68}
            # value是---》前端传入的，字段自己校验通过的字典---{"name":"张三","age":68}
            value = self.to_internal_value(data) # 执行局部钩子
            try:
                self.run_validators(value) # 先不看，忽略掉
                # self 是 BookSerializer的对象，如果我们写了全局钩子，走我们自己的，如果没写，走父类的，父类的根本没做校验
                # value={"name":"张三","age":68}
                value = self.validate(value)# 执行全局钩子
            except (ValidationError, DjangoValidationError) as exc:
                raise ValidationError(detail=as_serializer_error(exc))

            return value
        
        
      5 全局钩子读完了：self 是 BookSerializer的对象，如果我们写了全局钩子，走我们自己的，如果没写，走父类的，父类的根本没做校验
      6 局部钩子：value = self.to_internal_value(data)--》Serializer类的
        # for循环着去BookSerializer的对象中反射  validate_字段名的方法，如果有就执行，没有就不执行
     def to_internal_value(self, data):
        for field in fields: # 序列化类中所有字段类的对象 name=CharField()
            # self 是BookSerializer类的对象
            # 去BookSerializer类中，反射  validate_field字段类的对象.field_name
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 如果能拿到，说明咱么写了局部钩子
                if validate_method is not None:
                    # 执行局部钩子--》传入了当前字段的value值
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
               # 如果抛异常，会被捕获
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
            
        
# #####读了局部和全局钩子的执行位置#####
# 保存，修改也好，都要用validated_data，它是最准确的

# 默认，视图类的方法，可以处理任意编码格式
    -urlencoded
    -form-data
    -json
    
# 比如有的接口，只能接收json格式，其他格式都不能处理

## 配置方式一：视图类上配置
from rest_framework.parsers import JSONParser, FormParser, MultiPartParser
# JSONParser：json
# FormParser：urlencoded
# MultiPartParser：form-data
class TestView(APIView):
    # parser_classes = [JSONParser]
    parser_classes = [JSONParser,FormParser]
    def post(self, request):
        print(request.data)
        return Response('ok')
    
## 配置方式二：settings.py  配置文件中配置
    #### 所有drf的配置，都要写在REST_FRAMEWORK 字典中
    REST_FRAMEWORK = {
        'DEFAULT_PARSER_CLASSES': [
            # 'rest_framework.parsers.JSONParser',
            # 'rest_framework.parsers.FormParser',
            'rest_framework.parsers.MultiPartParser',
        ],
    }
    
    
# 全局使用某种，单某个视图类，局部使用---》优先用视图类配置的---》视图类没配置--》项目配置文件---》项目配置文件如果没配置---》drf配置文件（默认三个都支持）
    -配置文件正常写
    class TestView(APIView):
        parser_classes = [JSONParser,FormParser]
        
        
        
# 一般我们做---》只支持json
# 对于上传的文件的接口---》单独配置 只允许 form-data