后台管理器

使用后台管理Models

后台登录地址：http://localhost:8000/admin
1、创建后台管理员
    ./manage.py createsuperuser
    Username:
    Email Address:
    Password:
    Password(again):
2、基本管理
    1、在应用中的admin.py中注册要管理的数据
        1、admin.py
            作用：注册需要管理的Models，只有在此注册的Model才允许被管理，否则无法管理
        2、注册Model
            from .models import *
            admin.site.register(Entry)
            ex:
                admin.site.register(Author)
        3、修改 models.py 处理显示内容
            后台默认效果可读性不高
            在models.py中的各个 class 中追加

            def __str__(self):
                return self.name
        4、通过内部类Meta实现展现的属性
            允许为每个 model 类设置内部类 Meta 来设置起展现形式

            class Author(models.Model):
                .... ....
                .... ....
                .... ....

                class Meta:
                    1、db_table : 指定该实体类对应到表的名称
                    2、verbose_name : 定义该实体类在 admin 中显示的名字(单数形式)
                    3、verbose_name_plural : 效果同上，是复数形式
                    4、ordering ：在后台显示数据时的排序规则,取值为一个 列表，默认是按升序，降序的话则添加 '-'
3、高级管理
    1、在 admin.py 中创建管理类，实现高级管理功能
        1、定义 EntryAdmin 类，继承自 admin.ModelAdmin
            class AuthorAdmin(admin.ModelAdmin):
                pass
        2、注册 高级管理类
            admin.site.register(Entry,EntryAdmin)

            admin.site.register(Author,AuthorAdmin)
        3、允许在EntryAdmin增加的属性
            1、list_display
                作用：在显示实体信息的页面上，都显示哪些字段
                取值：由属性名组成的元组或列表
                ex:
                    list_display=('name','age','email')
            2、list_display_links
                作用：定义能够链接到具体实体页面的链接们
                取值：由属性名组成的元组或列表
                注意：取值要必须出现在 list_display 中
                ex:
                    list_display_links=('name','email')
            3、list_editable
                作用：定义在列表页面中允许被修改的字段
                取值：由属性名组成的元组或列表
                注意：list_editable的值不能出现在list_display_links中
            4、search_fields
                作用：添加允许被搜索的字段
                取值：由属性名组成的元组或列表
            5、list_filter
                作用：在列表的右侧增加过滤器，实现快速筛选
                取值：由属性名组成的元组或列表
            6、date_hierarchy
                作用：在顶部增加一个时间选择器，所以取值必须是 DateField 或 DateTimeField 的列
            7、fields
                作用：在实体的详细页面中，显示哪些属性，并按照什么样的顺序显示
                取值：由属性名组成的元组或列表
            8、fieldsets
                作用：在实体的详细页面中，对属性进行分组
                注意：fieldsets 与 fields 不能共存
                语法：
                    fieldsets=(
                        ('分组名称',{'fields':(属性1,属性2),'classes':('collapse')}),
                    )

Django连接查询

1、一对一映射(1:1)
    1、什么是一对一
        A表中的一条记录只能与B表中的一条记录匹配关联
        典型代表：一夫一妻制
        数据库中的实现：
            A表：设计主键
            B表：有主键，增加一列，并引用A表中的主键值，还得增加一个唯一约束
    2、语法
        属性 = models.OneToOneField(Entry)

    3、查询
        class Wife(models.Model):
            .... ....
            author = models.OneToOneField(Author)

        正向查询：通过 wife 找 author
            w = Wife.objects.get(id=1)
            a = w.author

        反向查询：通过 author 找 wife
            a = Author.objects.get(id=1)
            w = a.wife

            wife 是由Django通过OneToOneField在Author中默认增加的一个属性
2、一对多映射(1:M)
    1、什么是一对多
        A表中的一条数据可以与B表中的任意多条数据匹配

        比如 出版社 和 书籍 之间的关系

    2、语法
        使用 外键(Foreign Key)
        属性 = models.ForeignKey(实体类)

        ex:
            Book(M) 和 Publisher(1)

            class Book(models.Model):
                ... ...
                publisher = models.ForeignKey(Publisher)
    3、查询
        Book(M) 和 Publisher(1)

            class Book(models.Model):
                ... ...
                publisher = models.ForeignKey(Publisher)

        1、正向查询 - 通过 Book 查询 Publisher
            book = Book.objects.get(id=1)
            publisher = book.publisher
        2、反向查询 - 通过 Publisher 查询 Book
            publisher = Publisher.objects.get(id=1)
            通过 publisher.book_set.all()得到所有的关联数据
            bookSet = publisher.book_set.all()

Django中的连接查询

1、多对多查询
    1、什么是多对多
        A表中的一条记录可以与B表中的任意多条记录匹配，同时B表中的每一条记录也可以与A表中的任意多条记录相匹配
    2、语法
        entry = models.ManyToManyField(Entry)
    3、查询
        class Author(models.Model):
            ... ...
            publish = models.ManyToManyField(Publish)
        
        正向查询：在 Author 中查询 Publish
            author = Author.objects.get(id=3)
            pub_list=author.publish.all()

            通过关联属性.all()
        反向查询：在 Publisher 中查询 Author
            pub = Publisher.objects.get(id=1)
            auList = pub.author_set.all()

自定义查询对象 - objects

1、声明类 EntryManager,继承自models.Manager,并添加自定义函数
    class EntryManager(models.Manager):
        def  函数名(self,自定以参数):
            ... ...
            return ...
2、使用EntryManager 覆盖 Models中的objects
    class Entry(models.Model):
        objects = EntryManager()

HttpRequest 介绍

1、什么是HttpRequest
    HttpRequest,请求对象，封装了请求过程中的所有信息
    在Django中，HttpRequest 被化身成了 request封装到视图处理函数中作为参数.该参数，在调用视图处理函数时自动传入
    print(dir(request))
2、HttpRequest 中的主要内容
    1、request.scheme : 请求协议
    2、request.body 请求主体
    3、request.path 请求路径
    4、request.get_host() 请求的主机地址 / 域名
    5、request.method 请求方法
    6、request.GET get的请求数据
    7、request.POST post的请求数据
    8、request.COOKIES cookies的数据
    9、request.META 请求的元数据
3、有关HTTP协议
    1、每个请求一定会有 method
        get,post,put,delete,... ...

        get:向服务器要数据时使用
            传递数据到服务器时会直接将请求数据封装到地址之后

            http://www.baidu.com/s?wd=佳能&price=3000
        
        post:想传递数据到服务器处理的时候，用post
            post的请求提交的数据全部封装在 "请求主体" 中
    2、请求主体
        只有post 和 put 请求方式才能产生请求主体
        其他请求方式都没有请求主体
4、获取请求提交的数据
    1、GET请求
        request.GET['名称']
    2、POST请求
        request.POST['名称']

csrf 跨站点攻击

目的：为了解决跨站点发送post请求
解决方案：
    1、删除 CsrfViewMiddleWare 中间件
    2、在视图函数增加@csrf_protect
    3、
        在模板中 <form> 底下第一行增加一个标签{%csrf_token%}

        <form method="" action="">
            {%csrf_token%}
        </form>

使用 forms 模块处理表单

1、forms 模块的作用
    通过forms模块，允许将表单控件与py文件相结合
2、使用 forms 模块
    1、创建 forms.py 文件
    2、导入 forms 
        from django import forms
    3、创建class，一个class对应一个表单
        该 class 必须继承自 forms.Form
    4、在class中创建属性
        一个属性对应一个表单控件
3、在模板中，解析 form 对象
    1、注意
        1、需要自定义 <form>
        2、需要自定义 提交按钮
    2、处理方法
        1、手动解析
            {%for filed in form%}
                <p>{{filed.label}}:{{field}}</p>
            {%endfor%}
        2、自动解析
            {{form.as_p}}
            {{form.as_ul}} - 需要自定义 ul
            {{form.as_table}} - 需要自定义 table
4、在HTML中提交的表单内容也可以传递给forms.Form
    views.py

    def remark_views(request):
        form = RemarkForm(request.POST)
        if form.is_valid():#必须要经过验证才能继续
            cd = form.cleaned_data #封装了提交的数据
            print(cd['uname'])

5、forms 的高级处理
    将 Models 和 Forms 结合到一起使用
    通过Models 自动生成表单
    1、创建 class ，EntryForm ,并继承自 forms.ModelForm
    2、创建内部类 Meta ，并定义相关信息
        1、model ：指定关联的Models是谁
        2、fields
            1、指定一个列表，声明允许生成表单控件的属性
            2、取值 "__all__"，表示全部属性都允许被生成表单控件
        3、labels - 字典
            {
                '属性1':'显示文本1',
                '属性2':'显示文本2',
            }
6、内置小部件(widgets)
    1、什么是小部件
        生成到网页上的控件的类型
    2、常用小部件
        1、TextInput : type="text"
        2、NumberInput : type="number"
        3、EmailInput : type="email"
        4、URLInput : type="url"
        5、PasswordInput : type="password"
        6、HiddenInput : type="hidden"
        7、CheckboxInput : type="checkbox"
        8、Textarea : <textarea></textarea>
        9、Select : <select></select>
    3、小部件的使用
        1、继承自 forms.Form
            subject = forms.CharField(
                label='标题',
                widget=forms.TextInput(
                    attrs={
                        '属性名':'属性值',
                        'class':'form-control',
                        'placeholder':'请输入用户名'
                    }
                )
            )
        2、继承自 forms.ModelForm
            class WidgetForm(forms.ModelForm):
                class Meta:
                    model = Users
                    fields = '__all__'
                    labels = {
                        'uname':'...'
                    }
                    widgets = {
                        'uname':forms.TextInput(attrs={
                            'class':'form-control',
                            'placeholder':'xxx'
                        })
                    }

cookies 和 session

1、cookies
1、什么是cookies
    cookies是一种数据存储技术
    将一段文本保存在客户端(浏览器)的一种技术。并可以长时间的保存
2、cookies的使用场合
    1、保存登录信息
    2、保存用户的搜索关键词
3、django 中使用 cookies
    1、设置cookies(保存数据到客户端)
        1、不使用模板
            resp = HttpResponse("给客户端的一句话")
            resp.set_cookie(key,value,expires)
            return resp

            key : cookie的名称
            value : 保存的cookie的值
            expires : 保存的时间，以 s 为单位

            ex:
                resp.set_cookie('uname','zsf',60*60*24*365)
        2、使用模板
            resp = render(request,'xxx.html',locals())
            resp.set_cookie(key,value,expires)
            return resp
        3、重定向
            resp = HttpResponseRedirect('/login/')
            resp.set_cookie(key,value,expires)
            return resp

    2、获取cookies(从客户端获取数据)
        request.COOKIES

session - 会话

1、什么是session
    session(会话)，实际上就是服务器为每个浏览器临时开辟的一段空间，用于保存 相关的请求信息
2、session的应用场合
    session也是为了存放数据而存在的，通常会把服务器端要用到的数据保存进 session
3、Django中使用session
    1、设置session的值
        request.session['key']=值
        request.session.set_expiry(time):设置过期时间，如果设置为0的话则表示浏览器关闭则失效
    2、获取session的值
        request.session.get('key')
    3、删除 session 的值
        del request.session['key']
    4、settings.py 有关session的设置
        1、SESSION_COOKIE_AGE = 60 * 30
        2、SESSION_EXPIRE_AT_BROWSER_CLOSE = True