BBS - 预备知识

一、中介模型

四个项目：
苑昊
 
博客（BBS） (7-8)
 
CRM
    1.权限组件 (3)
    2.start组件 -- admin (5)
        1.使用
        2.源码 django 源码 （面向对象）
            以源码为导师
            使用python最顶头的人写出来的
        3.开发类似于源码的组件
        4.面向对象。。。优点。。。
    3.crm (4)
 
路飞学城
    1.vue (3)
    2.rest-framework (4)
    3.路飞学诚
 
爬虫
linux
flask
 
-------------------------------------------------
Book():
    title =
    publish = models.ForeignKey(to='Publish',to_field='id')
    authors = models.manytomany(to='author')
 
Publish():
    name=
    email=
 
Author():
    name=
 
book author
    id  book_id  author_id
     1       1     1
 
class book2author():
    id=
    book=models.ForeignKey('Book')
    author=models.ForeignKey('Author')
    xxx=models...
 
book2author
    id  book_id  author_id
     1       1     1
 
     book_obj = Book.object.filter(pk=1).first()
     book_obj.authors.all()
     book_obj.authors.add(1,2)
     book_obj.authors.set([1,2]) 刷新在插入
                      remove  解除
                      clear   全解除
 
     如果没有  // authors = models.manytomany(to='author')
        Book2author.object.create(book_id=1,author_id=2)
        意味着 跨表查询没有了  正向查询按字段 反向查询按表名
        那如果用字段authors = models.manytomany(to='author')，但是第三张表用自己的！
             authors = models.manytomany(to='author',through="Book2Author")...通过through
             以后跨表查询就走的是自己建的表，（中介模型）自己建的表（Book2Author叫中介模型）可进行扩展
 
中介模型：第三张表 可以create 可不可以add？ 不可以！！
    Book2author.object.create(book_id=1,author_id=2)
    book_obj.authors.add(1,2) 这个方法就不能使用了！！否则就会报错 add  set  remove  clear  都不能用了

笔记

中介模型：
    只针对 多对多
    authors = models.manytomany(to='author')
        book_obj.authors.add(1,2)
    authors = models.manytomany(to='author',through="Book2Author")  # （好处，可扩展）
        #（add  set  remove  clear  都不能用了！！）
        # 不能使用接口函数！
        Book2author.object.create(book_id=1,author_id=2,... )
        class Book2Author():
            id = ...
            book = models.Foreignkey()
            author = models.ForeighKey()
            xxx = ... # 有可能有多个字段。。扩展

二、简介

博客系统（cnblog） https://www.cnblogs.com/
预备知识：
    1.django ORM  （object relation mapping 对象关系映射）  表 = 类  对象 = 记录
        跨表查询  分组查询 annotate()   聚合查询  aggregate(*args, **kwargs)
    2.bootstrap
    3.Ajax (jquery javascript) --- javascript 去写ajax  去写写
        登录注册 点赞评论
        用框架 底层要会！
    4.用户认证系统！
        auth user   session 考虑的太多 会报异常！！所以用auth user
 
实现功能：
    1.基于Ajax和用户认证实现登录验证！
        --- 验证码  图片 滑动（插件）
        登录 注册  Ajax
 
    2.基于Ajax和form组件实现注册功能！
 
    3.系统首页的布局
        https://www.cnblogs.com/
 
        表关系 第一步：
            文章表： 表头 内容，发布时间
            用户表： 一对多
 
    4.个人站点页面设计
        https://www.cnblogs.com/wupeiqi
        https://www.cnblogs.com/linhaifeng
 
        标签 分类  归档（发布日期 group by）
        分类表：一对多  和文章表
        标签表：多对多  和文章表
 
    5.文章详细页面
        模板继承
        文章表 content内容非常多，分成两张表，否则会每次都查所有的字段；
        Artical
            id
            title  ...
            desc   ...
            create_time  ...
            ad_id = models.OneToOne()  1 / 5
        ArticalDetail:
            id
            content ...
        一对一
 
    6.基于Ajax实现文章点赞与踩灭
        描述行为的就是数据；
        ArticalUpDown
            id
            user_id
            artical_id
            is_up true false
            ( user_id artical_id 联合唯一 unqiue_together )
        ArticalUpDown.object.create()
 
    7.基于Ajax实现评论框
        Comment:
            id
            user_id
            artical_id
            create_time
            content
 
        对文章的评论和对评论的评论
        评论树：
            111
                444
                    555
                666
            222
            333
        评论楼：
            直接按时间下来的
 
        user
        id  name
         1   alex
         2   egon
 
        id  user_id  artical_id  create_time  content   p_id(记录父评论)
        1    1        2           2012         111        None
        2    2        2           2012         222        None
        3    3        2           2012         333        None
        4    4        2           2012         444         1
        5    5        2           2012         555         4
        6    6        2           2012         666         1
 
        create Comment():
            id = ...
            user = models.ForeignKey('User')
            artical = models.ForeignKey('Artical')
            create_time =
            content = ...
            pid = models.ForeignKey("selef",null=true,default=None)  # 表的自关联
 
    8.kindeditor 文本编辑器
    防止跨域，安全攻击！发文章 有些<js>恶意攻击
    思路：1.转义，对文章过滤，<script></script>
            beautitulSoup 模块

表设计：
    Artical
        id
        title
        desc
        create_time
        ad_id = models.OneToOne('ArticalDetail')
        type_id = models.ForeignerKey('Type')
        tag_id = models.ManyToMany('Tag')
 
    ArticalDetail: 一对一
        id
        content
 
    User:
        id
        username
        password
 
    Type 分类表： 一对多
        id
        name
 
    Tag 标签表： 多对多
        id
        name
 
    ArticalUpDown 点赞踩灭表： 联合唯一  unique(user_id,artical_id)
        id
        user_id = models.ForeignKey('User')
        artical_id = models.ForeignKey('Artical')
        is_up    true/false
 
    Comment 评论表 注意：对文章的评论和对评论的评论：评论树，评论楼, 表的自关联(null=true)
        id
        user_id = models.ForeignKey('User')
        artical_id = models.ForeignKey('Artical')
        create_time
        content
        p_id = models.ForeignKey('self',null=true,default=None)
        #（记录父评论） None / 1 / 4 / ...

表设计

三、cookie session

cookie session
 
    request.session['key'] = 'value'
    request.session.get('key')
 
必须要知道源码流程，知其然还要知其所以然
 
用户认证组件(基于session)(auth / User)

session：
 
1.使用

   def login(request):
        if request.method == 'POST':
            user = request.POST.get('user')
            pwd = request.POST.get('pwd')
 
            user = models.UserInfo.objects.filter(name=user,pwd=pwd).first()
            if user:
                request.session['username'] = user.name
                request.session['user_id'] = user.pk
                return redirect('/index/')
            else:
                return render(request,'login.html')
 
        return render(request,'login.html')
 
    def index(request):
        username = request.session.get('username')
        if not username:
            return redirect('/login/',)
        return render(request,'index.html',{'username':username})

2.分析session
    django 到了做了什么，其他框架没有session组件！！
 
    request.session['username'] = user.name
        0.判断session_id是否已经存在，存在就更新，不存在就创建
        1.obj.set_cookie('session_id','hn9tyjh56msytq8j4tuyffpezb9vfg09')
        2.django-session
            session-key         session-date                        expire-date
              hn9tyj***        {'username':'alex','user_id':1}    2018-06-14 04:05:28.620101
 
    request.session.get('username'):
        1.cookie{'session_id':'hn9tyj***'}
        2.在django-session表中：
            obj = django-session.object.filter(session-key='hn9tyj***'),first()
            obj.session-data.get('username)
 
    疑问：
        同一个浏览器多个用户登录：session表里不会多一个数据，除非换了浏览器；
        第二次访问，代码发生了什么事情！session表里，一个浏览器一条记录！
        每个浏览器都维持一个cookie ！为什么这样？源码
 
        第一次浏览器访问，取不出来session_id 就创建，一条记录 create
        第二次浏览器访问，能取出来session_id,就更新，不在是创建 update
 
3.查看源码
    from django.contrib.sessions.middleware import SessionMiddleware
        def process_request(self, request):pass
        def process_response(self, request, response):pass
 
    注意：
        1.def process_request(self, request):pass
            django 有两个settings
            用户级别 比 系统级别的高，可覆盖！
 
            from django.contrib.sessions.backends import db
            class SessionStore(SessionBase):pass
            request.session = self.SessionStore(session_key)
 
            所以：request.session 是一个空对象
            能这样赋值使因为：request.session['username'] = 'alex'
                    def __getitem__(self, key):
                        return self._session[key]
 
                    def __setitem__(self, key, value):
                        self._session[key] = value
                        self.modified = True
 
            结果：得到一个request.session空对象{}
                  视图函数里赋值：
                  request.session['username'] = 'alex'
 
        2.def process_response(self, request, response):pass
            request.session.save()
            obj.save(force_insert=must_create, force_update=not must_create, using=using)
            浏览器的session_id 有，就更新，没有，就创建；
 
    总结：
        session源码：
        请求：http://127.0.0.1:8080/login   post name=alex&pwd=123
        第一站：
            中间件SessionMiddleWare的process_request
 
            def process_request():
                request.session = self.SessionStore(session_key)
                 _session = {}
                 _session_cache = {}
 
        第二站：views:
            def login(request):
                user = request.POST.get('user')
                pwd = request.POST.get('pwd')
 
                user = models.UserInfo.objects.filter(name=user,pwd=pwd).first()
                if user:
                    request.session['username'] = user.name
                    request.session['user_id'] = user.pk
                    return redirect('/index/')
                else:
                    return render(request,'login.html')
 
            操作：
                执行 self.SessionStore(session_key)类下的__setitem__():
                    self._session_cache = {'username':'alex','user_id',1}
 
        第三站：中间件 SessionMiddleware的process_response():
            存储记录：
                if self._session_key:
                    self._session_key = 'asdas23213123ssasda'
                    self.save(must_create=True)
 
                self.save(must_create=False)
            写Cookie
                response.set_cookie(
                    'session_id',
                     self._session_key,
                )
 
        看源码：理解，学习，使用！！
 
4.django得流程
    浏览器  (请求首行 请求头 请求体)  wsgi （http协议整理数据 解析数据） 中间件  url views  orm
    中间件 process_request process_response process_view process_exception process_template_response
 
    wsgi 功能：1.解析请求的数据，request 之后随便用
               2.响应体 view 返回 字符串，返回浏览器 按响应格式返回，否则浏览器不识别（响应首行，响应头）

四、用户认证组件

python manage.py makemigrations
python manage.py migrate
也可以：
Tools / Run manage.py Task 
    makemigrations
    migrate
 
-------------------------    
 
用户认证组件：
 
from django.contrib import auth
from django.contrib.auth.models import User
 
auth  
    针对 auth_user 表
创建超级用户：
    python manage.py createsuperuser
    root root1234
    alex alex1234
 
1.user = auth.authenticate(username=user, password=pwd)
    成功返回用户对象 <class 'django.contrib.auth.models.User'>
    失败返回 None  
 
2.auth.login(request,user)
    request.session['user_id'] = user.pk
    # request.user = user # 不能用这个 否则多个人 就串了！！
    request.user = User.objects.filter(pk=user.pk).first()  
 
    就可以 调用 
    request.user  匿名对象 / 该用户对象 
 
3.auth.logout(request)
    request.session.flush()
 
4.from django.contrib.auth.models import User
    User.objects.create_user(username=user,password=pwd)
    User.objects.create_superuser(username=user,password=pwd,email='123@qq.com')
    权限用户 超级用户 所有表的所有权限 
    
示例：

from django.shortcuts import render,HttpResponse,redirect
from django.contrib import auth
from django.contrib.auth.models import User
 
def login(request):
    if request.method == 'POST':
        user = request.POST.get('user')
        pwd = request.POST.get('pwd')
        user = auth.authenticate(username = user,password=pwd)
        if user:
            auth.login(request,user)
            return redirect('/index/')
    return render(request,'login.html')
 
def index(request):
    username = request.user.username
    if not request.user.is_authenticated:
    # if not username:
        return redirect('/login/')
    return render(request,'index.html',{'username':username})
 
def logout(request):
    auth.logout(request)
    return redirect('/login/')
 
def reg(request):
    if request.method == 'POST':
        user = request.POST.get('user')
        pwd = request.POST.get('pwd')
        user = User.objects.create_user(username=user,password=pwd)
        auth.login(request,user)
        return redirect('/index/')
    return render(request,'login.html')

？既想用 auth_user 表,还想扩展,表字段如何做呢？
 
models.py
    from django.db import models
    from django.contrib.auth.models import User,AbstractUser
 
    # 用类继承
    # userinfo 和 auth_user 合成一张表
    # 因此可以用登录认证的功能
 
    class UserInfo(AbstractUser):
        tel = models.CharField(max_length=32)
 
# settings配置 若没有，报错'UserInfo.groups'；
AUTH_USER_MODEL = 'app01.UserInfo'
 
Tools / Run manage.py Task 
    makemigrations
    migrate
 
新生成得表 app01_userinfo （可以用登录认证的功能）
    字段就是 auth_user 和 UserInfo 得合成！！