ContentType组件

ContentType是Django的内置的一个应用，可以追踪项目中所有的APP和model的对应关系，并记录在ContentType表中。
当项目做数据迁移后，会有很多django自带的表，其中就有django_content_type表

ContentType组件应用

• 在model中定义ForeignKey字段，并关联到ContentType表，通常这个字段命名为content-type
• 在model中定义PositiveIntergerField字段, 用来存储关联表中的主键，通常用object_id
• 在model中定义GenericForeignKey字段，传入上面两个字段的名字
• 方便反向查询可以定义GenericRelation字段
• postman

1from django.db import models
2from django.contrib.contenttypes.models import ContentType
3from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
4
5# Create your models here.
6
7
8class Food(models.Model):
9    """
10    id      title
11    1       面包
12    2       牛奶
13    """
14    title = models.CharField(max_length=32)
15    # 不会生成字段 只用于反向查询
16    coupons = GenericRelation(to="Coupon")
17
18
19class Fruit(models.Model):
20    """
21    id      title
22    1       苹果
23    2       香蕉
24    """
25    title = models.CharField(max_length=32)
26
27
28# 如果有40张表
29# class Coupon(models.Model):
30#     """
31#     id      title          food_id    fruit_id
32#     1       面包九五折         1         null
33#     2       香蕉满10元减5元    null       2
34#     """
35#     title = models.CharField(max_length=32)
36#     food = models.ForeignKey(to="Food")
37#     fruit = models.ForeignKey(to="Fruit")
38
39
40# class Coupon(models.Model):
41#     """
42#     id      title        table_id      object_id
43#     1       面包九五折       1             1
44#     2       香蕉满10元减5元  2             2
45#     """
46#     title = models.CharField(max_length=32)
47#     table = models.ForeignKey(to="Table")
48#     object_id = models.IntegerField()
49#
50#
51# class Table(models.Model):
52#     """
53#     id      app_name       table_name
54#     1       demo            food
55#     2       demo            fruit
56#     """
57#     app_name = models.CharField(max_length=32)
58#     table_name = models.CharField(max_length=32)
59
60
61class Coupon(models.Model):
62    title = models.CharField(max_length=32)
63    # 第一步:注意没有引号因为是导入的
64    content_type = models.ForeignKey(to=ContentType, on_delete=None)
65    # 第二步
66    object_id = models.IntegerField()
67    # 第三步 不会生成字段,用来操作增删改查
68    content_object = GenericForeignKey("content_type", "object_id")

models.py

1from django.shortcuts import render
2from rest_framework.views import APIView
3from rest_framework.response import Response
4from .models import Food, Coupon
5from django.contrib.contenttypes.models import ContentType
6
7# Create your views here.
8
9
10class DemoView(APIView):
11
12    def get(self, request):
13        # 给面包创建一个优惠券
14        food_obj = Food.objects.filter(id=1).first()
15        # Coupon.objects.create(title="面包九五折", content_type_id=8, object_id=1)
16        # Coupon.objects.create(title="双十一面包九折促销", content_object=food_obj)
17
18        #查询食物都有哪些优惠券
19        #定义了反向查询
20        coupons = food_obj.coupons.all()
21        print(coupons)
22
23        # 如果没定义反向查询
24        content = ContentType.objects.filter(app_label="app01", model="food").first()
25        coupons = Coupon.objects.filter(content_type=content, object_id=1).all()
26        print(coupons)
27
28        # 优惠券查对象
29        # 查询优惠券id=1绑定了哪个商品
30        coupon_obj = Coupon.objects.filter(id=1).first()
31        content_obj = coupon_obj.content_object
32        print(coupon_obj.title,content_obj.title)
33
34        # 通过ContentType表找表模型
35        content = ContentType.objects.filter(app_label="app01", model="food").first()
36        # content=food  获取food表的表模型用model_class() 
37        model_class = content.model_class()
38        ret = model_class.objects.all()
39        print(ret)
40
41        return Response("ContentType测试")

views.py

media的配置

1#静态文件
2STATIC_URL = '/static/'  
3STATICFILES_DIRS=(
4    os.path.join(BASE_DIR,'static'),  
5)
6# Media配置
7MEDIA_URL = "media/"
8MEDIA_ROOT = os.path.join(BASE_DIR, "media")

settings.py

1from django.conf.urls import url, include
2from django.contrib import admin
3from django.views.static import serve
4from new_luffy import settings
5
6
7urlpatterns = [
8    url(r'^admin/', admin.site.urls),
9    url(r'^api/course/', include("course.urls")),
10
11    # media路径配置
12    url(r'media/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT})
13]

urls.py

项目路由配置

1from django.contrib import admin
2from django.urls import path, include, re_path
3from django.views.static import serve
4from LuffyCity import settings
5from Login.views import GeetestView
6
7
8urlpatterns = [
9    path('admin/', admin.site.urls),
10    path('api/course/', include("Course.urls")),
11    path('api/shop/', include("shopping.urls")),
12    path('api/', include("Login.urls")),
13    path('pc-geetest/register', GeetestView.as_view()),
14    path('pc-geetest/ajax_validate', GeetestView.as_view()),
15
16
17    # media路径配置
18    # path('media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT})
19    re_path('media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT})
20]

项目urls.py

一、课程模块

1. 课程模块，包括了免费课程以及专题课程
2. 主要是课程的展示，点击课程进入课程详细页面
3. 课程详细页面展示，课程的概述，课程的价格策略，课程章节，评价以及常见问题

1、设计表结构

1from django.db import models
2# Create your models here.
3
4from django.db import models
5from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
6from django.contrib.contenttypes.models import ContentType
7
8# Create your models here.
9__all__ = ["Category", "Course", "CourseDetail", "Teacher", "DegreeCourse", "CourseChapter",
10           "CourseSection", "PricePolicy", "OftenAskedQuestion", "Comment", "Account", "CourseOutline"]
11
12
13class Category(models.Model):
14    """课程分类表"""
15    title = models.CharField(max_length=32, unique=True, verbose_name="课程的分类")
16
17    def __str__(self):
18        return self.title
19
20    class Meta:
21        verbose_name = "01-课程分类表"
22        db_table = verbose_name
23        verbose_name_plural = verbose_name
24
25
26class Course(models.Model):
27    """课程表"""
28    title = models.CharField(max_length=128, unique=True, verbose_name="课程的名称")
29    course_img = models.ImageField(upload_to="course/%Y-%m", verbose_name='课程的图片')
30    category = models.ForeignKey(to="Category", verbose_name="课程的分类", on_delete=None)
31
32
33    COURSE_TYPE_CHOICES = ((0, "付费"), (1, "vip专享"), (2, "学位课程"))
34    course_type = models.SmallIntegerField(choices=COURSE_TYPE_CHOICES)
35    degree_course = models.ForeignKey(to="DegreeCourse", blank=True, null=True, help_text="如果是学位课程，必须关联学位表", on_delete=None)
36
37
38    brief = models.CharField(verbose_name="课程简介", max_length=1024)
39    level_choices = ((0, '初级'), (1, '中级'), (2, '高级'))
40    level = models.SmallIntegerField(choices=level_choices, default=1)
41
42    status_choices = ((0, '上线'), (1, '下线'), (2, '预上线'))
43    status = models.SmallIntegerField(choices=status_choices, default=0)
44    pub_date = models.DateField(verbose_name="发布日期", blank=True, null=True)
45
46    order = models.IntegerField("课程顺序", help_text="从上一个课程数字往后排")
47    study_num = models.IntegerField(verbose_name="学习人数", help_text="只要有人买课程，订单表加入数据的同时给这个字段+1")
48
49    # order_details = GenericRelation("OrderDetail", related_query_name="course")
50    # coupon = GenericRelation("Coupon")
51    # 只用于反向查询不生成字段
52    price_policy = GenericRelation("PricePolicy")
53    often_ask_questions = GenericRelation("OftenAskedQuestion")
54    course_comments = GenericRelation("Comment")
55
56    def save(self, *args, **kwargs):
57        if self.course_type == 2:
58            if not self.degree_course:
59                raise ValueError("学位课必须关联学位课程表")
60        super(Course, self).save(*args, **kwargs)
61
62    def __str__(self):
63        return self.title
64
65    class Meta:
66        verbose_name = "02-课程表"
67        db_table = verbose_name
68        verbose_name_plural = verbose_name
69
70
71class CourseDetail(models.Model):
72    """课程详细表"""
73    course = models.OneToOneField(to="Course", on_delete=None)
74    hours = models.IntegerField(verbose_name="课时", default=7)
75    course_slogan = models.CharField(max_length=125, blank=True, null=True, verbose_name="课程口号")
76    video_brief_link = models.CharField(max_length=255, blank=True, null=True)
77    summary = models.TextField(max_length=2048, verbose_name="课程概述")
78    why_study = models.TextField(verbose_name="为什么学习这门课程")
79    what_to_study_brief = models.TextField(verbose_name="我将学到哪些内容")
80    career_improvement = models.TextField(verbose_name="此项目如何有助于我的职业生涯")
81    prerequisite = models.TextField(verbose_name="课程先修要求", max_length=1024)
82    recommend_courses = models.ManyToManyField("Course", related_name="recommend_by", blank=True)
83
84    teachers = models.ManyToManyField("Teacher", verbose_name="课程讲师")
85
86    def __str__(self):
87        return self.course.title
88
89    class Meta:
90        verbose_name = "03-课程详细表"
91        db_table = verbose_name
92        verbose_name_plural = verbose_name
93
94
95class Teacher(models.Model):
96    """讲师表"""
97    name = models.CharField(max_length=32, verbose_name="讲师名字")
98    brief = models.TextField(max_length=1024, verbose_name="讲师介绍")
99
100    def __str__(self):
101        return self.name
102
103    class Meta:
104        verbose_name = "04-教师表"
105        db_table = verbose_name
106        verbose_name_plural = verbose_name
107
108
109class DegreeCourse(models.Model):
110    """
111    字段大体跟课程表相同，哪些不同根据业务逻辑去区分
112    """
113    title = models.CharField(max_length=32, verbose_name="学位课程名字")
114
115    def __str__(self):
116        return self.title
117
118    class Meta:
119        verbose_name = "05-学位课程表"
120        db_table = verbose_name
121        verbose_name_plural = verbose_name
122
123
124class CourseChapter(models.Model):
125    """课程章节表"""
126    course = models.ForeignKey(to="Course", related_name="course_chapters", on_delete=None)
127    chapter = models.SmallIntegerField(default=1, verbose_name="第几章")
128    title = models.CharField(max_length=32, verbose_name="课程章节名称")
129
130    def __str__(self):
131        return self.title
132
133    class Meta:
134        verbose_name = "06-课程章节表"
135        db_table = verbose_name
136        verbose_name_plural = verbose_name
137        unique_together = ("course", "chapter")
138
139
140class CourseSection(models.Model):
141    """课时表"""
142    chapter = models.ForeignKey(to="CourseChapter", related_name="course_sections", on_delete=None)
143    title = models.CharField(max_length=32, verbose_name="课时")
144    section_order = models.SmallIntegerField(verbose_name="课时排序", help_text="建议每个课时之间空1至2个值，以备后续插入课时")
145    section_type_choices = ((0, '文档'), (1, '练习'), (2, '视频'))
146    free_trail = models.BooleanField("是否可试看", default=False)
147    section_type = models.SmallIntegerField(default=2, choices=section_type_choices)
148    section_link = models.CharField(max_length=255, blank=True, null=True, help_text="若是video，填vid,若是文档，填link")
149
150    def course_chapter(self):
151        return self.chapter.chapter
152
153    def course_name(self):
154        return self.chapter.course.title
155
156    def __str__(self):
157        return "%s-%s" % (self.chapter, self.title)
158
159    class Meta:
160        verbose_name = "07-课程课时表"
161        db_table = verbose_name
162        verbose_name_plural = verbose_name
163        unique_together = ('chapter', 'section_link')
164
165
166class PricePolicy(models.Model):
167    """价格策略表"""
168    content_type = models.ForeignKey(ContentType, on_delete=None)  # 关联course or degree_course
169    object_id = models.PositiveIntegerField()
170    content_object = GenericForeignKey('content_type', 'object_id')
171
172    valid_period_choices = ((1, '1天'), (3, '3天'),
173                            (7, '1周'), (14, '2周'),
174                            (30, '1个月'),
175                            (60, '2个月'),
176                            (90, '3个月'),
177                            (120, '4个月'),
178                            (180, '6个月'), (210, '12个月'),
179                            (540, '18个月'), (720, '24个月'),
180                            (722, '24个月'), (723, '24个月'),
181                            )
182    valid_period = models.SmallIntegerField(choices=valid_period_choices)
183    price = models.FloatField()
184
185    def __str__(self):
186        return "%s(%s)%s" % (self.content_object, self.get_valid_period_display(), self.price)
187
188    class Meta:
189        verbose_name = "08-价格策略表"
190        db_table = verbose_name
191        verbose_name_plural = verbose_name
192        unique_together = ("content_type", 'object_id', "valid_period")
193
194
195class OftenAskedQuestion(models.Model):
196    """常见问题"""
197    content_type = models.ForeignKey(ContentType, on_delete=None)  # 关联course or degree_course
198    object_id = models.PositiveIntegerField()
199    content_object = GenericForeignKey('content_type', 'object_id')
200
201    question = models.CharField(max_length=255)
202    answer = models.TextField(max_length=1024)
203
204    def __str__(self):
205        return "%s-%s" % (self.content_object, self.question)
206
207    class Meta:
208        verbose_name = "09-常见问题表"
209        db_table = verbose_name
210        verbose_name_plural = verbose_name
211        unique_together = ('content_type', 'object_id', 'question')
212
213
214class Comment(models.Model):
215    """通用的评论表"""
216    content_type = models.ForeignKey(ContentType, blank=True, null=True, on_delete=None)
217    object_id = models.PositiveIntegerField(blank=True, null=True)
218    content_object = GenericForeignKey('content_type', 'object_id')
219
220    content = models.TextField(max_length=1024, verbose_name="评论内容")
221    account = models.ForeignKey("Account", verbose_name="会员名", on_delete=None)
222    date = models.DateTimeField(auto_now_add=True)
223
224    def __str__(self):
225        return self.content
226
227    class Meta:
228        verbose_name = "10-评价表"
229        db_table = verbose_name
230        verbose_name_plural = verbose_name
231
232
233class Account(models.Model):
234    username = models.CharField(max_length=32, verbose_name="用户姓名")
235    pwd = models.CharField(max_length=32, verbose_name="密文密码")
236    # head_img = models.CharField(max_length=256, default='/static/frontend/head_portrait/logo@2x.png',
237    #                             verbose_name="个人头像")
238    balance = models.IntegerField(verbose_name="贝里余额", default=0)
239
240    def __str__(self):
241        return self.username
242
243    class Meta:
244        verbose_name = "11-用户表"
245        db_table = verbose_name
246        verbose_name_plural = verbose_name
247
248
249class CourseOutline(models.Model):
250    """课程大纲"""
251    course_detail = models.ForeignKey(to="CourseDetail", related_name="course_outline", on_delete=None)
252    title = models.CharField(max_length=128)
253    order = models.PositiveSmallIntegerField(default=1)
254    # 前端显示顺序
255
256    content = models.TextField("内容", max_length=2048)
257
258    def __str__(self):
259        return "%s" % self.title
260
261    class Meta:
262        verbose_name = "12-课程大纲表"
263        db_table = verbose_name
264        verbose_name_plural = verbose_name
265        unique_together = ('course_detail', 'title')

Course中models.py

2、接口的编写

• 课程这个模块，所有的功能都是展示，基于数据展示的，通常称为数据接口
• 课程页面:有课程所有分类这个接口,有展示课程的接口
• 课程详情页面:详情页面的数据接口
• 详情页面下的子路由对应子组件的数据接口:课程章节课时、课程的评论、课程的常见问题

1from django.urls import path
2from .views import CategoryView, CourseView, CourseDetailView, CourseChapterView, CourseCommentView, QuestionView
3from .video_view import PolyvView
4
5
6urlpatterns = [
7    path('category', CategoryView.as_view()),
8    path('list', CourseView.as_view()),
9    path('detail/<int:pk>', CourseDetailView.as_view()),
10    path('chapter/<int:pk>', CourseChapterView.as_view()),
11    path('comment/<int:pk>', CourseCommentView.as_view()),
12    path('question/<int:pk>', QuestionView.as_view()),
13    path('polyv', PolyvView.as_view()),
14
15]

Course中urls.py

1from rest_framework import serializers
2from . import models
3
4
5class CategorySerializer(serializers.ModelSerializer):
6    class Meta:
7        model = models.Category
8        fields = "__all__"
9
10
11class CourseSerializer(serializers.ModelSerializer):
12    level = serializers.CharField(source="get_level_display")
13    price = serializers.SerializerMethodField()
14
15    def get_price(self, obj):
16        print(obj.price_policy.all())
17        return obj.price_policy.all().order_by("price").first().price
18
19    class Meta:
20        model = models.Course
21        fields = ["id", "title", "course_img", "brief", "level", "study_num", "price"]
22
23
24class CourseDetailSerializer(serializers.ModelSerializer):
25    level = serializers.CharField(source="course.get_level_display")
26    study_num = serializers.IntegerField(source="course.study_num")
27    recommend_courses = serializers.SerializerMethodField()
28    teachers = serializers.SerializerMethodField()
29    price_policy = serializers.SerializerMethodField()
30    course_outline = serializers.SerializerMethodField()
31
32
33    def get_course_outline(self, obj):
34        return [{"id": outline.id, "title": outline.title, "content": outline.content} for outline in obj.course_outline.all().order_by("order")]
35
36
37    def get_price_policy(self, obj):
38        return [{"id": price.id, "valid_price_display": price.get_valid_period_display(), "price": price.price} for price in obj.course.price_policy.all()]
39
40
41    def get_teachers(self, obj):
42        return [{"id": teacher.id, "name": teacher.name} for teacher in obj.teachers.all()]
43
44    def get_recommend_courses(self, obj):
45        return [{"id": course.id, "title": course.title} for course in obj.recommend_courses.all()]
46
47    class Meta:
48        model = models.CourseDetail
49        fields = ["id", "hours", "summary", "level", "study_num", "recommend_courses", "teachers",
50                  "price_policy", "course_outline"]
51
52
53class CourseChapterSerializer(serializers.ModelSerializer):
54    sections = serializers.SerializerMethodField()
55
56    def get_sections(self, obj):
57        return [{"id": section.id, "title": section.title, "free_trail": section.free_trail} for section in obj.course_sections.all().order_by("section_order")]
58
59    class Meta:
60        model = models.CourseChapter
61        fields = ["id", "title", "sections"]
62
63
64class CourseCommentSerializer(serializers.ModelSerializer):
65    account = serializers.CharField(source="account.username")
66
67    class Meta:
68        model = models.Comment
69        fields = ["id", "account", "content", "date"]
70
71
72class QuestionSerializer(serializers.ModelSerializer):
73    class Meta:
74        model = models.OftenAskedQuestion
75        fields = ["id", "question", "answer"]

Course中serializers.py

1from django.shortcuts import render
2from rest_framework.views import APIView
3from rest_framework.response import Response
4from . import models
5from .serializers import CategorySerializer, CourseSerializer, CourseDetailSerializer, CourseChapterSerializer
6from .serializers import CourseCommentSerializer, QuestionSerializer
7
8# Create your views here.
9
10
11class CategoryView(APIView):
12    """课程分类接口"""
13    def get(self, request):
14        # 通过ORM操作获取所有分类数据
15        queryset = models.Category.objects.all()
16        # 利用序列化器去序列化我们的数据
17        ser_obj = CategorySerializer(queryset, many=True)
18        # 返回
19        return Response(ser_obj.data)
20
21
22class CourseView(APIView):
23    """查看所有免费课程的接口"""
24    def get(self, request):
25        # 获取过滤条件中的分类ID
26        category_id = request.query_params.get("category", 0)
27        # 根据分类获取课程
28        if category_id == 0:
29            # 证明没有分类，可以拿所有的课程数据
30            queryset = models.Course.objects.all().order_by("order")
31        else:
32            queryset = models.Course.objects.filter(category_id=category_id).all().order_by("order")
33        # 序列化课程数据
34        ser_obj = CourseSerializer(queryset, many=True)
35        # 返回
36        return Response(ser_obj.data)
37
38
39class CourseDetailView(APIView):
40    """课程详情页面"""
41    def get(self, request, pk):
42        # 根据pk获取到课程详情对象
43        course_detail_obj = models.CourseDetail.objects.filter(course__id=pk).first()
44        if not course_detail_obj:
45            return Response({"code": 1001, "error": "查询的课程详情不存在"})
46        # 序列化课程详情
47        ser_obj = CourseDetailSerializer(course_detail_obj)
48        # 返回
49        return Response(ser_obj.data)
50
51
52class CourseChapterView(APIView):
53    """课程章节接口"""
54    def get(self, request, pk):
55        # 数据结构["第一章": {课时一， 课时二}]
56        queryset = models.CourseChapter.objects.filter(course_id=pk).all().order_by("chapter")
57        # 序列化章节对象
58        ser_obj = CourseChapterSerializer(queryset, many=True)
59        # 返回
60        return Response(ser_obj.data)
61
62
63class CourseCommentView(APIView):
64    def get(self, request, pk):
65        # 通过课程id找到课程所有的评论
66        queryset = models.Course.objects.filter(id=pk).first().course_comments.all()
67        # 序列化
68        ser_obj = CourseCommentSerializer(queryset, many=True)
69        # 返回
70        return Response(ser_obj.data)
71
72
73class QuestionView(APIView):
74    def get(self, request, pk):
75        queryset = models.Course.objects.filter(id=pk).first().often_ask_questions.all()
76        ser_obj = QuestionSerializer(queryset, many=True)
77        return Response(ser_obj.data)

Course中views.py

1from django.contrib import admin
2
3# Register your models here.
4from . import models
5
6for table in models.__all__:
7    admin.site.register(getattr(models, table))

Course中admin.py

二、登录认证模块(token存Redis)

• 以前前后端不分离用cookie，session解决,现在前后端分离使用token令牌。
• 用户登录成功后，生成一个随机字符串token给前端返回
• 前端以后都携带这个token来访问,这样后端只需要鉴别这个token就可以做认证

1import redis
2POOL = redis.ConnectionPool(host="127.0.0.1", port=6379, decode_responses=True, max_connections=10)

utils中redis_pool.py

1class BaseResponse(object):
2
3    def __init__(self):
4        self.code = 1000
5        self.data = None
6        self.error = None
7
8    @property
9    def dict(self):
10        return self.__dict__

utils中base_response.py

1from rest_framework.authentication import BaseAuthentication
2from rest_framework.exceptions import AuthenticationFailed
3from .redis_pool import POOL
4from Course.models import Account
5import redis
6
7
8
9CONN = redis.Redis(connection_pool=POOL)
10
11
12class LoginAuth(BaseAuthentication):
13    def authenticate(self, request):
14        # 从请求头中获取前端带过来的token
15        token = request.META.get("HTTP_AUTHENTICATION", "")
16        if not token:
17            raise AuthenticationFailed("没有携带token")
18        # 去redis比对
19        user_id = CONN.get(str(token))
20        if user_id == None:
21            raise AuthenticationFailed("token过期")
22        user_obj = Account.objects.filter(id=user_id).first()
23        return user_obj, token

utils中my_auth.py

1urlpatterns = [
2    path('register', RegisterView.as_view()),
3    path('login', LoginView.as_view()),
4    path('test_auth', TestView.as_view()),
5
6]

Login中urls.py

1from rest_framework import serializers
2from Course.models import Account
3import hashlib
4
5
6class RegisterSerializer(serializers.ModelSerializer):
7
8    class Meta:
9        model = Account
10        fields = "__all__"
11
12    def create(self, validated_data):
13        pwd = validated_data["pwd"]
14        pwd_salt = "luffy_password" + pwd
15        md5_str = hashlib.md5(pwd_salt.encode()).hexdigest()
16        user_obj = Account.objects.create(username=validated_data["username"], pwd=md5_str)
17        return user_obj

Login中serializers.py

1from django.shortcuts import render
2from rest_framework.views import APIView
3from rest_framework.response import Response
4from .serializers import RegisterSerializer
5from utils.base_response import BaseResponse
6from Course.models import Account
7from utils.redis_pool import POOL
8import redis
9import uuid
10from utils.my_auth import LoginAuth
11from utils.geetest import GeetestLib
12from django.http import HttpResponse
13import json
14
15# Create your views here.
16
17
18class RegisterView(APIView):
19
20    def post(self, request):
21        res = BaseResponse()
22        # 用序列化器做校验
23        ser_obj = RegisterSerializer(data=request.data)
24        if ser_obj.is_valid():
25            ser_obj.save()
26            res.data = ser_obj.data
27        else:
28            res.code = 1020
29            res.error = ser_obj.errors
30        return Response(res.dict)
31
32
33class LoginView(APIView):
34
35    def post(self, request):
36        res = BaseResponse()
37        username = request.data.get("username", "")
38        pwd = request.data.get("pwd", "")
39        user_obj = Account.objects.filter(username=username, pwd=pwd).first()
40        if not user_obj:
41            res.code = 1030
42            res.error = "用户名或密码错误"
43            return Response(res.dict)
44
45        # 用户登录成功生成一个token写入redis
46        # 写入redis  token : user_id
47        conn = redis.Redis(connection_pool=POOL)
48        try:
49            token = uuid.uuid4()
50            # conn.set(str(token), user_obj.id, ex=10)
51            conn.set(str(token), user_obj.id)
52            res.data = token
53        except Exception as e:
54            print(e)
55            res.code = 1031
56            res.error = "创建令牌失败"
57        return Response(res.dict)
58
59
60class TestView(APIView):
61    authentication_classes = [LoginAuth, ]
62
63    def get(self, request):
64        return Response("认证测试")
65
66
67pc_geetest_id = "b46d1900d0a894591916ea94ea91bd2c"
68pc_geetest_key = "36fc3fe98530eea08dfc6ce76e3d24c4"
69REDIS_CONN = redis.Redis(connection_pool=POOL)
70
71
72class GeetestView(APIView):
73
74    def get(self, request):
75        user_id = 'test'
76        gt = GeetestLib(pc_geetest_id, pc_geetest_key)
77        status = gt.pre_process(user_id)
78        # request.session[gt.GT_STATUS_SESSION_KEY] = status
79        REDIS_CONN.set(gt.GT_STATUS_SESSION_KEY, status)
80        # request.session["user_id"] = user_id
81        REDIS_CONN.set("gt_user_id", user_id)
82        response_str = gt.get_response_str()
83        return HttpResponse(response_str)
84
85    def post(self, request):
86        # print(request.session.get("user_id"))
87        print(request.META.get("HTTP_AUTHENTICATION"))
88        print(request.data)
89        gt = GeetestLib(pc_geetest_id, pc_geetest_key)
90        challenge = request.data.get(gt.FN_CHALLENGE, '')
91        validate = request.data.get(gt.FN_VALIDATE, '')
92        seccode = request.data.get(gt.FN_SECCODE, '')
93        # username
94        # pwd
95        # status = request.session.get(gt.GT_STATUS_SESSION_KEY)
96        # print(status)
97        # user_id = request.session.get("user_id")
98        # print(user_id)
99        status = REDIS_CONN.get(gt.GT_STATUS_SESSION_KEY)
100        user_id = REDIS_CONN.get("gt_user_id")
101        if status:
102            result = gt.success_validate(challenge, validate, seccode, user_id)
103        else:
104            result = gt.failback_validate(challenge, validate, seccode)
105        result = {"status": "success"} if result else {"status": "fail"}
106        # if result:
107        #     # 证明验证码通过
108        #     # 判断用户名和密码
109        # else:
110        #     #  返回验证码错误
111        return HttpResponse(json.dumps(result))

Login中views.py

三、登录认证模块(token存mysql)

1# 拓展之前课程模块下的用户表
2class Account(models.Model):
3    username = models.CharField(max_length=32, verbose_name="用户姓名", unique=True)
4    password = models.CharField(max_length=32, verbose_name="用户密码")
5    # head_img = models.CharField(max_length=256, default='/static/frontend/head_portrait/logo@2x.png',
6    #                             verbose_name="个人头像")
7    token = models.UUIDField(null=True, blank=True)
8
9    def __str__(self):
10        return self.username
11
12    class Meta:
13        verbose_name = "11-用户表"
14        db_table = verbose_name
15        verbose_name_plural = verbose_name

models.py 扩展之前功能模块的用户表

1class BaseResponse(object):
2
3    def __init__(self):
4        self.code = 1000
5        self.data = None
6        self.error = None
7
8    @property
9    def dict(self):
10        return self.__dict__

utils中base_response.py

1from rest_framework.authentication import BaseAuthentication
2from rest_framework.exceptions import AuthenticationFailed
3from Course.models import Account
4# django 提供的拿时间的接口 提供的是根据django配置的时区拿到的当前时间
5from django.utils.timezone import now
6
7
8class LoginAuth(BaseAuthentication):
9    def authenticate(self, request):
10        # 从请求头中获取前端带过来的token
11        token = request.META.get("HTTP_AUTHENTICATION", "")
12        if not token:
13            raise AuthenticationFailed("没有携带token")
14        # 去redis比对
15        user_obj = Account.objects.filter(token=token).first()
16        if not user_obj:
17            raise AuthenticationFailed("token过期")
18        else:
19            old_time = user_obj.create_token_time
20            if (now() - old_time).days > 7:
21                raise AuthenticationFailed({"code": 1020, "error": "无效的token"})
22            return user_obj, token

utils中my_auth.py

1urlpatterns = [
2    path('register', RegisterView.as_view()),
3    path('login', LoginView.as_view()),
4    path('test_auth', TestView.as_view()),
5
6]

Login中urls.py

1from rest_framework import serializers
2from Course.models import Account
3import hashlib
4
5
6class RegisterSerializer(serializers.ModelSerializer):
7
8    class Meta:
9        model = Account
10        fields = "__all__"
11
12    def create(self, validated_data):
13        pwd = validated_data["pwd"]
14        pwd_salt = "luffy_password" + pwd
15        md5_str = hashlib.md5(pwd_salt.encode()).hexdigest()
16        user_obj = Account.objects.create(username=validated_data["username"], pwd=md5_str)
17        return user_obj

Login中serializers.py

1from django.shortcuts import render
2from rest_framework.views import APIView
3from rest_framework.response import Response
4from .serializers import RegisterSerializer
5from utils.base_response import BaseResponse
6from Course.models import Account
7import uuid
8
9
10
11# Create your views here.
12
13class RegisterView(APIView):
14
15    def post(self, request):
16        res = BaseResponse()
17        # 用序列化器做校验
18        ser_obj = RegisterSerializer(data=request.data)
19        if ser_obj.is_valid():
20            ser_obj.save()
21            res.data = ser_obj.data
22        else:
23            res.code = 1020
24            res.error = ser_obj.errors
25        return Response(res.dict)
26
27
28class LoginView(APIView):
29
30    def post(self, request):
31        res = BaseResponse()
32        username = request.data.get("username", "")
33        pwd = request.data.get("pwd", "")
34        user_obj = Account.objects.filter(username=username, pwd=pwd).first()
35        if not user_obj:
36            res.code = 1030
37            res.error = "用户名或密码错误"
38            return Response(res.dict)
39
40        try:
41            token = uuid.uuid4()
42            ###
43            user_obj.update(token=token)
44            res.data = token
45        except Exception as e:
46            print(e)
47            res.code = 1031
48            res.error = "创建令牌失败"
49        return Response(res.dict)
50
51# 所有这是一个需要认证的接口
52class TestView(APIView):
53    authentication_classes = [LoginAuth, ]
54
55    def get(self, request):
56        return Response("认证测试")

Login中views.py

四、购物车模块

1. 用户点击商品加入购物车，个人中心可以查看自己所有购物车中数据
2. 在购物车中可以删除课程，还可以更新购物车中课程的价格策略
3. 所以接口应该有四种请求方式， get，post，patch，delete
4. 因为购物车是属于中间状态数据而且很多时候需要过期时间所以选择存储到redis

1from django.urls import path
2from .views import ShoppingCarView
3from .settlement_view import SettlementView
4from .payment_view import PaymentView
5
6urlpatterns = [
7    path('shopping_car', ShoppingCarView.as_view()),
8    path('settlement', SettlementView.as_view()),
9    path('payment', PaymentView.as_view()),
10]

shopping中urls.py

1from rest_framework.authentication import BaseAuthentication
2from rest_framework.exceptions import AuthenticationFailed
3from .redis_pool import POOL
4from Course.models import Account
5import redis
6
7
8
9CONN = redis.Redis(connection_pool=POOL)
10
11
12class LoginAuth(BaseAuthentication):
13    def authenticate(self, request):
14        # 从请求头中获取前端带过来的token
15        token = request.META.get("HTTP_AUTHENTICATION", "")
16        if not token:
17            raise AuthenticationFailed("没有携带token")
18        # 去redis比对
19        user_id = CONN.get(str(token))
20        if user_id == None:
21            raise AuthenticationFailed("token过期")
22        user_obj = Account.objects.filter(id=user_id).first()
23        return user_obj, token

utils中my_auth.py

1from django.shortcuts import render
2from rest_framework.views import APIView
3from rest_framework.response import Response
4from utils.base_response import BaseResponse
5from utils.my_auth import LoginAuth
6from utils.redis_pool import POOL
7from Course.models import Course
8import json
9import redis
10
11# Create your views here.
12
13# 前端传过来 course_id  price_policy_id
14# 把购物车数据放入redis
15"""
16{
17    SHOPPINGCAR_USERID_COURSE_ID: {
18        "id",   课程id
19        "title",  课程标题
20        "course_img", 
21        "price_policy_dict": {
22            price_policy_id: "{valid_period,  price, valid_period_display}"
23            price_policy_id2: "{valid_period,  price, valid_period_display}"
24            price_policy_id3: "{valid_period,  price, valid_period_display}"
25        
26        },
27        "default_price_policy_id": 1  默认选中的价格id
28        
29    
30    }
31
32
33}
34"""
35
36SHOPPINGCAR_KEY = "SHOPPINGCAR_%s_%s"
37CONN = redis.Redis(connection_pool=POOL)
38
39
40class ShoppingCarView(APIView):
41    authentication_classes = [LoginAuth, ]
42    # 给购物车增加商品
43    def post(self, request):
44        res = BaseResponse()
45        try:
46            # 1, 获取前端传过来的数据以及user_id
47            course_id = request.data.get("course_id", "")
48            price_policy_id = request.data.get("price_policy_id", "")
49            user_id = request.user.pk
50            # 2, 校验数据的合法性
51            # 2.1 校验课程id合法性
52            course_obj = Course.objects.filter(id=course_id).first()
53            if not course_obj:
54                res.code = 1040
55                res.error = "课程id不合法"
56                return Response(res.dict)
57            # 2.2 校验价格策略id是否合法
58            price_policy_queryset = course_obj.price_policy.all()
59            price_policy_dict = {}
60            for price_policy in price_policy_queryset:
61                price_policy_dict[price_policy.id] = {
62                    "price": price_policy.price,
63                    "valid_period": price_policy.valid_period,
64                    "valid_period_display": price_policy.get_valid_period_display()
65                }
66            if price_policy_id not in price_policy_dict:
67                res.code = 1041
68                res.error = "价格策略id不合法"
69                return Response(res.dict)
70            # 3，构建redisKEY
71            key = SHOPPINGCAR_KEY % (user_id, course_id)
72            # 4，构建数据结构
73            course_info = {
74                "id": course_obj.id,
75                "title": course_obj.title,
76                "course_img": str(course_obj.course_img),
77                "price_policy_dict": json.dumps(price_policy_dict, ensure_ascii=False),
78                "default_price_policy_id": price_policy_id
79            }
80            # 5  写入redis
81            CONN.hmset(key, course_info)
82            res.data = "加入购物车成功"
83        except Exception as e:
84            res.code = 1012
85            res.error = "加入购物车失败"
86        return Response(res.dict)
87
88    def get(self, request):
89        res = BaseResponse()
90        try:
91            # 1, 拼接redis key
92            user_id = request.user.pk
93            shopping_car_key = SHOPPINGCAR_KEY % (user_id, "*")
94            # 2, 去redis中读取数据
95            # 2.1 模糊匹配所有的keys
96            # 3，构建数据结构展示
97            all_keys = CONN.scan_iter(shopping_car_key)
98            ret = []
99            for key in all_keys:
100                ret.append(CONN.hgetall(key))
101            res.data = ret
102        except Exception as e:
103            res.code = 1013
104            res.error = "获取购物车失败"
105        return Response(res.dict)
106
107    def put(self, request):
108        # 前端 course_id  price_policy_id
109        res = BaseResponse()
110        try:
111            # 1, 获取前端传过来的数据以及user_id
112            course_id = request.data.get("course_id", "")
113            price_policy_id = request.data.get("price_policy_id", "")
114            user_id = request.user.pk
115            # 2, 校验数据的合法性
116            # 2.1 course_id是否合法
117            key = SHOPPINGCAR_KEY % (user_id, course_id)
118            if not CONN.exists(key):
119                res.code = 1043
120                res.error = "课程id不合法"
121                return Response(res.dict)
122            # 2,2 price_policy_id是否合法
123            price_policy_dict = json.loads(CONN.hget(key, "price_policy_dict"))
124            if str(price_policy_id) not in price_policy_dict:
125                res.code = 1044
126                res.error = "价格策略不合法"
127                return Response(res.dict)
128            # 3, 更新redis  default_price_policy_id
129            CONN.hset(key, "default_price_policy_id", price_policy_id)
130            res.data = "更新成功"
131        except Exception as e:
132            res.code = 1014
133            res.error = "更新购物车失败"
134        return Response(res.dict)
135
136    def delete(self, request):
137        # course_list = [course_id, ]
138        res = BaseResponse()
139        try:
140            # 1 获取前端传来的数据以及user_id
141            course_list = request.data.get("course_list", "")
142            user_id = request.user.pk
143            # 2 校验course_id是否合法
144            for course_id in course_list:
145                key = SHOPPINGCAR_KEY % (user_id, course_id)
146                if not CONN.exists(key):
147                    res.code = 1045
148                    res.error = "课程ID不合法"
149                    return Response(res.dict)
150                # 3， 删除redis数据
151                CONN.delete(key)
152            res.data = "删除成功"
153        except Exception as e:
154            res.code = 1014
155            res.error = "删除购物车失败"
156        return Response(res.dict)