项目源码下载：https://github.com/Cherish-sun/NEWS/tree/master
实现新闻标签、广告的web API
一、serializers.py 添加
# 按serializers来序列化新闻标签
class TagSerializer(serializers.ModelSerializer):
# id = serializers.Field()
name = serializers.CharField(required=True, max_length=100)
slug = serializers.CharField(required=True, max_length=100)
class Meta:
model = Tag
fields = ('id', 'name', 'slug')
# 广告
class AdSerializer(serializers.ModelSerializer):
class Meta:
model = Ad
fields = "__all__"
二、views.py中设置新闻标签、广告的Viewset
class TagViewset(viewsets.ModelViewSet):
"""
list:
GET url: /tag/ 标签列表数据
create:
POST url: /tag/ 创建标签详情，返回新生成的标签对像
retrieve:
GET url: /tag/1/ 获取标签详情，返回标签对像
update:
PUT url: /tag/1/ 修改标签详情，返回标签对像
delete:
DELETE url: /tag/1/ 删除标签详情，返回空对像
"""
# 用于从此视图返回对象的查询器集。
queryset = Tag.objects.all()
# filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)
# 查询
# filter_class =
# SearchFilter对应search_fields，对应模糊查询,也可用关连表的字段进行查询，但需要二个下划线连接，如categorys__title
search_fields = ('name')
# 用于验证和反序列化输入以及序列化输出的serializer类。通常，您必须设置此属性，或覆盖该 get_serializer_class()方法。
serializer_class = TagSerializer
# 应用于执行单个模型实例的对象查找的模型字段。默认为’pk’。
lookup_field = "id"
class AdViewset(viewsets.ModelViewSet):
"""
list:
GET url: /ad/ 广告列表数据
create:
POST url: /ad/ 创建广告详情，返回新生成的广告对像
retrieve:
GET url: /ad/1/ 获取广告详情，返回广告对像
update:
PUT url: /ad/1/ 修改广告详情，返回广告对像
delete:
DELETE url: /ad/1/ 删除广告详情，返回空对像
"""
# 用于从此视图返回对象的查询器集。
queryset = Ad.objects.all()
# filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)
# 查询
# filter_class =
# SearchFilter对应search_fields，对应模糊查询,也可用关连表的字段进行查询，但需要二个下划线连接，如categorys__title
search_fields = ('title')
# 用于验证和反序列化输入以及序列化输出的serializer类。通常，您必须设置此属性，或覆盖该get_serializer_class()方法。
serializer_class = AdSerializer
# 应用于执行单个模型实例的对象查找的模型字段。默认为’pk’。
lookup_field = "id"
三、将两个类注册到urls.py里
router.register(r'tag', view.TagViewset, base_name='tag')
router.register(r'ad', view.AdViewset, base_name='ad')
四、实现文章的web API
1、serializers.py 添加
# 新闻文章
class ArticleSerializer(serializers.ModelSerializer):
# 外键相关对象
item = ItemSerializer()
author = UserSerializer()
tags = TagSerializer(many=True)
class Meta:
model = Article
fields = "__all__"
# 热门文章
class Hot_articleSerializer(serializers.ModelSerializer):
item = ItemSerializer()
author = UserSerializer()
tags = TagSerializer(many=True)
class Meta:
model = Article
fields = "__all__"
2、在article目录下新建myfilter.py
# -*- coding: utf-8 -*-
import django_filters
from django.db.models import Q
from .models import Article, Item
class ArticleFilter(django_filters.rest_framework.FilterSet):
"""
文章的过滤类
"""
author = django_filters.CharFilter(name='author', help_text="作者")
status = django_filters.ChoiceFilter(name='status', help_text="状态")
publish_date = django_filters.DateTimeFilter(name='publish_date', help_text="发布时间")
item = django_filters.CharFilter(name='item', help_text="分类")
tags = django_filters.CharFilter(name='tags', help_text="标签")
# 其中method指向自己定义的过滤函数，label用于标识在测试API界面中的过滤界面字段，categorys控制查询字段
categorys = django_filters.NumberFilter(method='item_categorys_filter', help_text="大类")
# top_category = django_filters.NumberFilter(method='item_categorys_filter')
def item_categorys_filter(self, queryset, name, value):
return queryset.filter(item__categorys=value)
class Meta:
model = Article
fields = ['author', 'status', 'publish_date', 'is_active', 'item', 'categorys', 'tags']
3、views.py 添加
from rest_framework.pagination import PageNumberPagination
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework import filters
from .myfilter import ArticleFilter
from rest_framework.response import Response
class ArticlePagination(PageNumberPagination):
page_size = 5
page_size_query_param = 'page_size'
page_query_param = "page"
max_page_size = 20
class ArticleListViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
"""
文章列表页, 分页， 搜索， 过滤， 排序
可根据'author', 'status', 'publish_date', 'is_active', 'item', 'tags' 查询
"""
# throttle_classes = (UserRateThrottle, )
# 查询对象集
queryset = Article.objects.all()
# 序列化的类名
serializer_class = ArticleSerializer
# 分页，有分页列表结果时应使用的分页类。
pagination_class = ArticlePagination
# authentication_classes = (TokenAuthentication, )
# 过滤、查询类
filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)
# DjangoFilterBackend对应filter_fields属性，做相等查询
# 过滤字段类
filter_class = ArticleFilter
# SearchFilter对应search_fields，对应模糊查询
search_fields = ('title', 'item__title', 'tags__name')
# 排序
ordering_fields = ('id', 'publish_date')
lookup_field = "id"
# 重写retrieve方法，取出数据后，将浏览数加一，重新取回数据
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
instance.read_num += 1
instance.save()
serializer = self.get_serializer(instance)
return Response(serializer.data)
class Hot_articleListViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
"""
热门文章
"""
# throttle_classes = (UserRateThrottle, )
# 查询对象集
queryset = Article.objects.filter(is_active='True')[:10]
# 序列化的类名
serializer_class = ArticleSerializer
# 排序
ordering_fields = ('-id',)
lookup_field = "id"
五、实现用户相关的web API（实现注册、登录、重置密码功能）
1、views.py添加
from rest_framework.authtoken.models import Token
from rest_framework.authentication import TokenAuthentication, SessionAuthentication
from rest_framework import permissions
from rest_framework.status import HTTP_200_OK, HTTP_400_BAD_REQUEST, HTTP_201_CREATED
from rest_framework.decorators import action
from rest_framework.views import APIView
class UserViewset(viewsets.ModelViewSet):
"""
用户查询和注册
list:
GET url: /user/ 用户列表数据
creat:
POST url: /user/ 创建用户详情
retrieve:
GET url: /user/1/ 获取用户详情
update:
PUT url: /user/1/ 修改用户详情
delete:
DELETE url: /user/1/ 删除用户详情
"""
# queryset = User.objects.all()
# serializer_class = UserDetailSerializer
def get_serializer_class(self):
if self.action == "retrieve":
return UserDetailSerializer
elif self.action == "create":
return UserRegSerializer
return UserDetailSerializer
# 认证策略属性
authentication_classes = (TokenAuthentication, SessionAuthentication)
def get_queryset(self):
users = User.objects.filter(id=self.request.user.id)
if users:
for user in users:
issuperuser = user.is_superuser
if issuperuser:
queryset = User.objects.all()
else:
queryset = users
else:
queryset = users
return queryset
permission_classes = (permissions.IsAuthenticated,)
def get_permissions(self):
if self.action == "retrieve":
return [permissions.IsAuthenticated()]
elif self.action == "create":
return []
return []
# 重写create方法,给密码加密，并查询和创建token
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
passwd = request.data['password']
user = self.perform_create(serializer)
# 给密码加密
user.set_password(passwd)
user.save()
re_dict = serializer.data
# 查询和创建token
token = Token.objects.get_or_create(user=user)
serializer = UserRegSerializer({'id': user.id, 'username': user.username, 'token': token[0]})
serializer.data["status"] = HTTP_201_CREATED
# headers = self.get_success_headers(serializer.data)
return Response(serializer.data)
def perform_create(self, serializer):
return serializer.save()
class UserLoginViewset(mixins.CreateModelMixin, viewsets.GenericViewSet):
"""
实现用户登录
返回用户名、ID、token
"""
serializer_class = UserLoginSerializer
# 因登录只需post方法，可重写create方法，取消原有保存对象逻辑，加入登录逻辑
def create(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data,
context={'request': request})
if serializer.is_valid(raise_exception=True):
user = serializer.validated_data['user']
# 登录时，创建新的token
tokenobj = Token.objects.update_or_create(user=user)
token = Token.objects.get(user=user)
# 重构返回数据
serializer = UserLoginSerializer(
{'username': user.username, 'id': user.id, 'password': '', 'token': token.key})
return Response(serializer.data, status=HTTP_200_OK)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def get_object(self):
return self.request.user
class UserSetPasswordViewset(mixins.CreateModelMixin, viewsets.GenericViewSet):
"""
实现用户修改密码
输入username、password，验证正确返回password 修改成功，否则返回HTTP_400_BAD_REQUEST
"""
serializer_class = UserSetPasswordSerializer
# 设置对象集
queryset = User.objects.all()
# 因修改密码只需post方法，可重写create方法，取消原有保存对象逻辑，加入修改密码逻辑
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid(raise_exception=True):
# 取出已验证的用户对象
instance = serializer.validated_data['user']
# 设置加密密码
instance.set_password(request.data['newpassword'])
# 保存
instance.save()
return Response({'status': 'password 修改成功'})
else:
return Response(serializer.errors,
status=HTTP_400_BAD_REQUEST)
六、实现用户收藏的web API
class UserFavViewset(mixins.CreateModelMixin, mixins.ListModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, viewsets.GenericViewSet):
"""
list:
获取用户收藏列表
retrieve:
判断某文章是否已经收藏
create:
收藏文章
"""
# permission_classes = (permissions.IsAuthenticated, )
# 加入认证
authentication_classes = (TokenAuthentication, SessionAuthentication)
lookup_field = "articles_id"
serializer_class = UserFavSerializer
# 重写get_queryset
def get_queryset(self):
if self.request.user:
queryset = UserFav.objects.filter(user=self.request.user)
else:
queryset = []
return queryset
# 重写create
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
articleid = request.data['articles']
userid = request.data['user']
userfav = UserFav.objects.get_or_create(articles_id=articleid, user_id=userid)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=HTTP_201_CREATED, headers=headers)
到此为止，新闻管理系统后端全部代码就写完了。。。。。运行newsapi项目，打开浏览器 http://0.0.0.0:8005/
后端完成效果