from django.conf.urls import url
from django.urls import path, include
urlpatterns = [
    
    url(r'^api-auth/', include('rest_framework.urls'))  #添加该urls
]

class UserModer(models.Model):
    username = models.CharField(max_length=200, null=False, blank=False)
    age = models.IntegerField()
    gender = models.BooleanField(default=False)
    
    def to_json(self):
    return {"username": self.username, "age": self.age, "gender": self.gender}
   

调用所有的网页页面  例如：foo/html/index.html/

def index(request, file):
	return render(request, file)

head头里 index.html 编写用户信息展示表单：
	1.导入jquery:
		<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
	2.使用：
    <script>
        $(document).ready(function() {
            $.get("/foo/api/user/",
                function (users) {
                    users.forEach(function (user) {
                        // $('#id_users').append(user.user);
                        // $('#id_users').append(user.age);
                       $("#id_users").append("<tr><td>"+user.username+"</td><td>" + 
                       user.age + "</td></tr>")
                    })
                }
            )
        });
    </script>
    页面...
    <tbody id = "id_users">
    	上面设置的后端处理内容将显示在这里
    </tbody>

4.urls创建：如api 1步骤

app下创建urls.py
from django.urls import path
from foo import views

urlpatterns = [
	path('html/<str:file>', views.index)
	path('api/user/', views.get_user)

	

根urls:
from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('foo/', include('foo.urls')),
    url(r'^api-auth/', include('rest_framework.urls'))
]

前端调用展示相关数据：

1 html(user.html) 编写用户输入表单:
<form method='post', action='/foo/api/user/'>
	username:<input placeholder="username", name="username">....  #添加name以此为POST数据的名称
	</form>
	
2 views:
	只推送数据到前端展示：地址：foo/api/user/
		def get_user(request):
				users = UserModer.object.all()
				user_info = [u.to_json() for u in users]
				return JsonResponse(user_info, safe=False)
	POST则获取前端user.html的表单数据并保存(foo/html/user.html)/否则返回数据到前端(foo/api/user/)
		@csrf_exempt
		def do_user(request):
			if request.method == "POST":
				user = UserModel() #取出Model中的字段
				user.username = request.POST['username']  #赋值给相应字段
				...
				user.save()   #保存到数据库
				return JsonResponse(user.to_json())  #将数据发送给前端  地址：foo/api/user/
			else: 推送数据到前端


3 urls(当前app中):
	path('api/user/', views.do_user)  #2推送的消息返回前端的地址规则

1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能

## serializers.py
from rest_framework import serializers

class UserSerializer(serializers.Serializer):
	username = serializers.CharFiled(requird = True, max_length=50)
	...  #需要进行数据转换的字段设,并修改字段相应类型
	def create(self, validated_data):  #重写create方法 
		model = UserModel()
		model.username = validated_data['username']
		...
		model.save()
		return model 
		
model ：指明该序列化器处理的数据字段从模型类Student参考生成
fields ：指明该序列化器包含模型类中的哪些字段，__all__指明包含所有字段   

Serializer(instance=None, data=empty, **kwarg)

serializer = StudentSerializer(instance, context={'request': request})

def do_user(request):
	if request.method == "POST":  #foo/api/user/1   
		serializer = UserSerializer(data=request.POST)   
			#包括：serializer的__init__中有instance,data，many等字段，
		if not serializer.is_valid():  
			return JsonResponse(serializer.errors)
		serializer.save(force_insert=True)
		return JsonResponse(serializer.validated_data)  
		
		#serializer中会将data中的数据赋值给validated_data
		
	else:
			users = UserModer.object.all()
			user_info = [u.to_json() for u in users]
			return JsonResponse(user_info, safe=False)
			

path('api/user/<int:id>', views.do_user) 

使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。

在获取反序列化的数据前，必须调用is_valid()方法进行验证，验证成功返回True，否则返回False。

验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误。
如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。

验证成功，可以通过序列化器对象的validated_data属性获取数据。

在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。

## serializers.py
class UserSerializer2(serializers.ModelSerializer): #需申明调用模型信息
	class Meta:
		model = UserModel  #model添加上to_json  直接继承Model的字段
		exclude = ('gender',)  #不在前端展示的字段
	
## views.py
def do_user(request, id=None):
	if not id:
		if request.method == "POST":  #根据前端输入的资源进行保存数据库中并返回给前端  
			serializer = UserSerializer(data=request.POST)  #数据转换（反序列化） 
			if not serializer.is_valid():  
				return JsonResponse(serializer.errors)  #响应错误
			serializer.save(force_insert=True)  #存储数据
			return JsonResponse(serializer.validated_data)  #响应数据
		else:  #被序列化的是包含多条数据的查询集QuerySet，可通过many=True参数补充说明 
				users = UserModer.object.all() #获取数据
				#不需要在model中定义to_json传资源
				user_info = UserSerializer2(instance=users, many=True) #转化多个数据，需要加上many=True
				#user_info.data ：序列化器转化后的数据（字典） 
				return JsonResponse(user_info.data, safe=False)
				#响应数据给客户端
				#返回的Json数据，如果是列表，需要声明safe=False
	else:  
		if request.method == "GET"：  
			user = UserModel.object.get(pk = id)  #获取数据
			user_info = UserSerializer2(instance=user) #数据转换（序列化）
			return JsonResponse(user_info.data)   #响应数据

class BookSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = Book
        fields = '__all__'

model 指明参照哪个模型类
fields 指明为模型类的哪些字段生成

我们可以在python manage.py shell中查看自动生成的BookSerializer的具体实现
>>> from booktest.serializers import BookSerializer
>>> serializer = BookSerializer()
>>> serializer

class BookSerializer(serializers.ModelSerializer):
    """图书序列化器"""
    class Meta:
        model = Book
        fields = ('id', 'title', 'pub_date', 'read', 'comment')
        extra_kwargs = {
            'read': {'min_value': 0, 'required': True},
            'comment': {'min_value': 0, 'required': True},
        }

#models.py
class LessonModel(models.Model):
    subject = models.CharField(max_length=255)
    student = models.ForeignKey('UserModer', on_delete=models.CASCADE)

#serializer.py
class LessonSerializer(serializers.ModelSerializer):
	#序列化调用上面学生信息（对student字段进行处理后返回）
	student = serializer.SerializerMethodField()
	
	def get_student(self, instance):
		#instance.student 为获取数据
		u = UserSerializer2(instance=instance.student) #数据转化
		return u.data #返回转化数据  使得该序列化可以转化学生信息数据并一起发给前端
	
	#定义任意需要的字段
	count = serializer.SerializerMethodField()
	
	def get_count(self, instance):
		return 12
		
    class Meta:
        model = LessonModel  #声明model  (instance中包括的字段)
        fields = ("subject", "student", 'count')  #指明序列化model中的字段与exclude相反

#views.py
def do_lesson(request, id=None):
	if not id:
		lesson = LessonModel.object.all() #获取数据
		json_lesson = LessonSerializer(instance=lesson, many=True)  #数据转化（序列化）
		return JsonResponse(json_lesson.data, safe=False)  
		#响应数据(subject,student,count的所有序列化返回的数据)

新建一个子应用books。

data = {'title': 'python'}  #传入的数据
serializer = BookSerializer(data=data)  #序列化
serializer.is_valid()  # True   验证结果返回值 （字段的限制若不满足直接False）
serializer.errors  # {}  错误信息
serializer.validated_data  #  OrderedDict([('btitle', 'python')])

class BookSerializer(serializers.Serializer):
    """图书数据序列化器"""
    ...
    def validate_title(self, value):
        if 'django' not in value.lower():
            raise serializers.ValidationError("图书不是关于Django的")
        return value

验证：
from book.serializers import BookSerializer
data = {'title': 'python'}
serializer = BookSerializer(data=data)
serializer.is_valid()  # False   
serializer.errors
#  {'title': [ErrorDetail(string='图书不是关于Django的', code='invalid')]}

class BookSerializer(serializers.Serializer):
    """图书序列化器"""
    ...

    def validate(self, attrs):
        read = attrs['read']
        comment = attrs['comment']
        if read < comment:
            raise serializers.ValidationError('阅读量小于评论量，不可以通过')
        return attrs
        
   
from book.serializers import BookSerializer
data = {'title': 'about django', 'read': 10, 'comment': 20}
s = BookSerializer(data=data)
s.is_valid()  # False
s.errors
#  {'non_field_errors': [ErrorDetail(string='阅读量小于评论量', code='invalid')]}

def about_django(value):
    if 'django' not in value.lower():
        raise serializers.ValidationError("图书不是关于Django的")

class BookSerializer(serializers.Serializer):
    """图书序列化器"""
    id = serializers.IntegerField(label='ID', read_only=True)
     #验证字段title
    title = serializers.CharField(label='名称', max_length=20, validators=[about_django])    	 pub_date = serializers.DateField(label='发布日期', required=False)
    read = serializers.IntegerField(label='阅读量', required=False)
    comment = serializers.IntegerField(label='评论量', required=False)

  
from book.serializers import BookSerializer
data = {'title': 'python'}
serializer = BookSerializer(data=data)
serializer.is_valid()  # False   
serializer.errors
#  {'title': [ErrorDetail(string='图书不是关于Django的', code='invalid')]}

#Model.py
class UserModel(models.Model):
	password = models.CharField(max_length=255, null=True)
   salt = models.CharField(max_length=255, default='123456')

#serializers.py 序列化

如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，
如果传递了instance实例，则调用save()方法的时候，update()被调用

class UserSerializer2(serializers.ModelSerializer):
    class Meta:
        model = UserModer
        exclude = ('password', ）
	#创建密码  validated_data是反序列化验证成功后获得的数据
    def create(self, validated_data):
        model = super().create(validated_data)
        model.salt = uuid.uuid4().hex
        password = '12345' + model.salt
        import hashlib
        md5 = hashlib.md5()
        md5.update(password.encode('utf-8'))
        model.password = md5.hexdigest()
        model.save()
        return model
	# 更新密码
    def update(self, instance, validated_data):
        model = super().update(instance, validated_data)
        if "password" in validated_data:
            password = validated_data['password'] + model.salt
            import hashlib
            md5 = hashlib.md5()
            md5.update(password.encode('utf-8'))
            model.password = md5.hexdigest()
            model.save()
        	  return model

@api_view(['GET', 'POST'])  #如果未制定 默认是GET 其它以“405 Method Not Allowed ”进行响应
def hello_world(request):
    if request.method == 'POST':
        return Response({"message": "Got some data!", "data": request.data})
    return Response({"message": "Hello, world!"})

# views.py

@api_view("GET", "POST" ) 
def do_user(request, id=None): #可指定format:json(前端显示方式为json)
	assert isinstance(request, Request)
	# request.query_params == request.GET  urls中的数据
	# request.data == request.POST   报文中的数据
	if not id:
		if request.method == "POST":   
			serializer = UserSerializer(data=request.POST)   
			if not serializer.is_valid():  #序列化验证 
				return JsonResponse(serializer.errors)  
			serializer.save(force_insert=True) #保存 
			#return JsonResponse(serializer.validated_data)
			#使用rest_framework 的Response 
			return Response(serializer.validated_data)  #响应数据  
 
# app/urls
path('api/user', views.do_user, {'format':'json'}) #上述指定format后需要制定

#views.py

class UserView(APIView):
    def get(self, request, id=None, *args, **kwargs):
    # request.query_params == request.GET  urls中的数据
	 # request.data == request.POST   报文中的数据
        if id:
            user = UserModer.objects.get(pk=id)
            user_info = UserSerializer2(instance=user)
            return Response(user_info.data)
        else:
            users = UserModer.objects.all()
            users_info = UserSerializer2(instance=users, many=True)
            return Response(users_info.data)

    def post(self, request, *args, **kwargs):
        serializer = UserSerializer2(data=request.data)
        if not serializer.is_valid():
            return JsonResponse(serializer.errors)
        serializer.save()
        return Response(serializer.validated_data)
    def put(self, request, id=None, *args, **kwargs):
    	  if id:
    	  		model = UserModel.object.get(pk=id)
    	  else:
    	  		model = UserModel.object.get(pk=request.data['id'])
    	  serializer = UserSerializer2(data=request.data)
    	  if not serializer.is_valid():
    	  	  print(serializer.errors)
            return Response(status=401)
        serializer.save()
        return Response(serializer.data)
    	  

# app/urls.py

path('api/user/', views.UserView.as_view())

class UserView(mixins.ListModelMixin,
               mixins.CreateModelMixin,
               mixins.RetrieveModelMixin,
               mixins.UpdateModelMixin,
               mixins.DestroyModelMixin,
               generics.GenericAPIView):

    queryset = UserModer.objects.all()
    serializer_class = UserSerializer2

    def get(self, request, pk=None, *args, **kwargs):
        if not pk:
            return self.list(request, *args, **kwargs)
        else:
            return self.retrieve(request, pk, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)
        

#views.py:

class UserView(ModelViewSet):
    queryset = UserModer.objects.all()
    serializer_class = UserSerializer2


list_view = UserView.as_view({
        "get": "list",
        "post": 'create'})

detail_view = UserView.as_view(
    {
        "get": "retrieve",
        "put": "update",
        "delete": "destroy"
    }
)

    # path('api/user/', views.list_view),
    # path('api/user/<int:pk>', views.detail_view),

#views.py
 class LessonView(ModelViewSet):
     queryset = LessonModel.objects.all()
     serializer_class = LessonSerializer
     
#app/urls.py
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register('user', views.UserView)
router.register('lesson', views.LessonView)

path('api/', include(router.urls)),

from rest_framework.permissions import IsAuthenticated, BasePermission

class TokenPermissionClass(BasePermission): #验证方法重写
    def has_object_permission(self, request, view, obj):
        pass
    def has_permission(self, request, view):
        if isinstance(view, UserView):
            return False
        return True
           
class LessonView(ModelViewSet):
    permission_classes = [TokenPermissionClass]  #调用上面的验证方式
    queryset = LessonModel.objects.all()
    serializer_class = LessonSerializer

#authentications.py

from rest_framework.authentication import BaseAuthentication, BasicAuthentication
from foo.models import UserModer

class UserPasswordAuthentication(BaseAuthentication):
    def authenticate(self, request):
        user = request.query_params.get('username')
        password = request.query_params.get('password')
        try:
            user = UserModer.objects.get(username=user)
        except:
            return None, None
        new_password = password + user.salt
        import hashlib
        md5 = hashlib.md5()
        md5.update(new_password.encode('utf-8'))
        if user.password == md5.hexdigest():
            return user, None
        else:
            return None, None
            
#views.py

class UserView(ModelViewSet):  #若有权限即验证通过，则序列化
    permission_classes = [IsAuthenticated]
    authentication_classes = [UserPasswordAuthentication]
    queryset = UserModer.objects.all()
    serializer_class = UserSerializer2
 
 #models.py
 class UserModer(models.Model):
 	...
 	
   @property
   def is_authenticated(self):  
   #(IsAuthenticated中request.user和request.user.is_authenticated需要同时满足 这里重写其中一个)
        return True

#地址栏输入  字段名=值 可以查询出该字段里所有符合的值的数据
class UserView(ModelViewSet):  
    queryset = UserModer.objects.all()
    serializer_class = UserSerializer2

    def list(self, request, *args, **kwargs):
        for arg, value in request.query_params.items():
            self.queryset = self.queryset.filter(**{arg: value})

        return super(UserView, self).list(request, *args, **kwargs)

pip3 install django-filters

import django_filters.rest_framework


class UserView(ModelViewSet):

    queryset = UserModer.objects.all()
    filter_backends = [django_filters.rest_framework.DjangoFilterBackend, SearchFilter]
    serializer_class = UserSerializer2
    filterset_fields = ['gender', 'salt']

#http://127.0.0.1:8000/foo/api/user/?gender=1

class LessonView(ModelViewSet):
    queryset = LessonModel.objects.all()
    serializer_class = LessonSerializer
    filter_backends = [SearchFilter]
    search_fields = ['subject', 'student__username']

#http://127.0.0.1:8000/foo/api/lesson/?search=a