django进阶

django ORM操作

models.py

from django.db import models

# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=128)
    price = models.PositiveSmallIntegerField(null=True)#正数,null=True不是必填
    authors = models.ManyToManyField('Author')
    publisher = models.ForeignKey('Publisher')
    pub_date = models.DateField()
    # memo = models.CharField(null=True,max_length=64)数据库新增字段的时候，需要加上null=True
    #为了在查询时显示对象的名字
    def __str__(self):
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField(unique=True)

    def __str__(self):
        return self.name

class Publisher(models.Model):
    name = models.CharField(max_length=128,unique=True)
    website = models.URLField(unique=True)

    def __str__(self):
        return "%s %s"%(self.name,self.website)

terminal下进行数据库的增删改查

python3 manage.py shell
from app01 import models

book表增加数据，关联author和publisher表，所以先创建author和publisher,创建时不能直接指定author

models.Author.objects.create(name='alex',email='alex3714@126.com')
models.Publisher.objects.create(name='tsinghua',website='http://tsinghua.com)b2 = models.Book.objects.create(name='linux',price=55,publisher_id=2,pub_date='2016-01-01')b2.authors.add(1,2)b2.authors.all()#查询这本书的作者，创建完之后是保存在app01_book_authors表中b2.authors.remove()b2.publiser.name#查看外键关键的表的属性

查

返回列表　　models.Book.objects.fliter()

返回单个对象或错误，如果get到多条会报错　　models.Book.objects.get()

models.Book.objects.get(pub_date__gt = '2017-01-01')

查询没有就创建

　　models.Book.objects.get_or_create(name='java',pub_date='2019-01-01',publisher_id=1)

　　(<Book: java>, True)

包含(contains,incontains忽略大小写)

　　models.Book.objects.filter(name__contains='go')

　　<QuerySet [<Book: go>]>

查name和price

　　models.Book.objects.values('name','price')

　　<QuerySet [{'name': 'python', 'price': 50}, {'name': 'linux', 'price': 55}, {'name': 'go', 'price': 100}, {'name': 'java', 'price': None}]>

查价格不等于50的book

　　models.Book.objects.exclude(price=50)

　　<QuerySet [<Book: linux>, <Book: go>, <Book: java>]>

aggregate　　聚合

　　书的平均价格

　　from django.db.models import Avg,Sum,Max,Min,Count

　　models.Book.objects.all().aggregate(Avg('price'))

　　每个出版社出的书和书的平均价格

　　from django.db.models import Count

　　models.Book.objects.values('publisher__name').annotate(Count('id'))

　　models.Book.objects.values('publisher__name').annotate(Avg('price'))

Q

　　2016或2017出版的书

　　q = Q(pub_date__year='2016')|Q(pub_date__year='2017')
　　models.Book.objects.filter(q)
　　<QuerySet [<Book: python>, <Book: linux>]>

F

　　自修改

　　　　from django.db.models import F

　　　　models.Book.objects.update(price=F('price')+10)

　　本表两字段比较

　　　　from datetime import timedelta

　　　　models.Book.objects.filter(pub_date__lt=F('pub_date')+timedelta(days=3))

　　字段迁移

　　　　from django.db.models import F

　　　　models.Book.objects.update(memo=F('name'))

通过出版社查询每个出版社出了多少书

　　p1 = models.Publisher.objects.all()[1]

　　p1.book_set.all()

FBV和CBV

　　function+base+view

　　class+base+view

• urls.py

url(r'^home/',views.Home.as_view())

• views.py

from django.views import View

class Home(View):

　　def dispatch(self.request,*args,**kwargs):

　　　　print('before')#类似于装饰器，先执行类里面自己定义的dispatch

　　　　result = super(Home,self).dispatch(request,*args,**kwargs)#执行View自己的dispatch，类似python的反射

　　　　return result

　　　　print('after')

　　def get(self,request):

 　　　　pass

　　def post(self,post):　　　　　　　　 pass

 

　　　　

 

 

FORM表单

1、app01下创建文件forms.py

from django import forms
from app01 import models
FAVORITE_COLORS_CHOICES=(
    ('blue','BLUE'),
    ('green','Green'),
    ('black','Black'),
)
BIRTH_YEAR_CHOICES = ('1980','1981','1982')
seat_CHOICE = (('1','First',),('2','Second',))

import re
def mobile_validate(value):
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
    if not mobile_re.match(str(value)):
        raise forms.ValidationError('手机号码格式错误')


class MailSendForm(forms.Form):
    sender = forms.EmailField()
    receiver = forms.EmailField()
    subject = forms.CharField(max_length=12)
    content = forms.CharField(widget=forms.Textarea(attrs={'cols':100,
                                                           'class':'font-color',
                                                           'style':'background-color:lightgreen'}))
    birth_year = forms.DateField(widget=forms.SelectDateWidget(years=BIRTH_YEAR_CHOICES))
    mobile = forms.IntegerField(validators=[mobile_validate, ],
                                error_messages={'required': '手机不能为空'},
                                widget=forms.TextInput(attrs={'class': 'form-control',
                                                              'placeholder': '手机号码'}))

    choice_field = forms.ChoiceField(widget=forms.RadioSelect,choices=seat_CHOICE)
    favorite_colors = forms.MultipleChoiceField(
        widget=forms.CheckboxSelectMultiple,
        choices=FAVORITE_COLORS_CHOICES,
    )
    def clean_sender(self):#对哪个字段做认证，就clean_xx
        print('validate sender',self.cleaned_data)
        if self.cleaned_data.get('sender') != 'alex@126.com':
            self.add_error('sender','only')
        return self.cleaned_data.get('sender')#不返回的话cleaned_data里面'sender'为None

    def clean(self):#所有的clean_field都验证完成后，才会执行
        print('clean data',self.cleaned_data)
        sender = self.cleaned_data.get('sender')
        receiver = self.cleaned_data.get('receiver')
        if sender == receiver:
            raise forms.ValidationError('发送者和接受者不能相同')

class BookForm(forms.ModelForm):
    class Meta:
        model = models.Book
        fields = "__all__"
        exclude = ['memo',]

2、views.py

from django.shortcuts import render
from app01.forms import MailSendForm
from app01.forms import BookForm
from django.views import View
# Create your views here.
def mail(request):
    if request.method == 'POST':
        form = MailSendForm(request.POST)
        if form.has_changed():
            print('form has changed')
        if form.is_valid():#验证表单数据是否合法
            print('fuck',form.cleaned_data)
        else:
            print('error',form.errors)

    else:
        form = MailSendForm(initial={'sender':'sb@126.com'})

    return render(request,'mail_send.html',{'form':form})

def book_mgr(request):
    if request.method == 'POST':
        form = BookForm(data=request.POST)
        if form.is_valid():
            form.save()
            form = BookForm()
    else:
        form = BookForm()
    return render(request,'book.html',{'form':form})
class BookMgr(View):
    form_class = BookForm
    template_name = 'book.html'

    def get(self,request):
        print('get',request.GET)
        form = self.form_class()
        return render(request,self.template_name,{'form':form})

    def post(self,request):
        form = self.form_class(data=request.POST)
        if form.is_valid():
            form.save()
            form = self.form_class()
        return render(request,self.template_name,{'form':form})

3、mail_send.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <div>
        <form method="post">
            {% for item in form %}
                <div>
                    {{ item.label }} {{ item }}
                    {% if item.errors %}
                        <span style="color: red">
                            {{ item.errors }}
                        </span>

                    {% endif %}
                </div>

            {% endfor %}
            <input type="submit" value="send"/>
        </form>
    </div>
</body>
</html>

modelform

form.py

class BookForm(forms.ModelForm):
    class Meta:
        model = models.Book
        fields = "__all__"
        exclude = ['memo',]

view.py

def book_mgr(request):
    if request.method == 'POST':
        form = BookForm(data=request.POST)
        if form.is_valid():
            form.save()
            form = BookForm()
    else:
        form = BookForm()
    return render(request,'book.html',{'form':form})

 

CSRF（Cross Site Request Forgery, 跨站域请求伪造）

CSRF 背景与介绍

CSRF（Cross Site Request Forgery, 跨站域请求伪造）是一种网络的攻击方式，它在 2007 年曾被列为互联网 20 大安全隐患之一。其他安全隐患，比如 SQL 脚本注入，跨站域脚本攻击等在近年来已经逐渐为众人熟知，很多网站也都针对他们进行了防御。然而，对于大多数人来说，CSRF 却依然是一个陌生的概念。即便是大名鼎鼎的 Gmail, 在 2007 年底也存在着 CSRF 漏洞，从而被黑客攻击而使 Gmail 的用户造成巨大的损失。

CSRF 攻击实例

CSRF 攻击可以在受害者毫不知情的情况下以受害者名义伪造请求发送给受攻击站点，从而在并未授权的情况下执行在权限保护之下的操作。比如说，受害者 Bob 在银行有一笔存款，通过对银行的网站发送请求 http://bank.example/withdraw?account=bob&amount=1000000&for=bob2 可以使 Bob 把 1000000 的存款转到 bob2 的账号下。通常情况下，该请求发送到网站后，服务器会先验证该请求是否来自一个合法的 session，并且该 session 的用户 Bob 已经成功登陆。黑客 Mallory 自己在该银行也有账户，他知道上文中的 URL 可以把钱进行转帐操作。Mallory 可以自己发送一个请求给银行：http://bank.example/withdraw?account=bob&amount=1000000&for=Mallory。但是这个请求来自 Mallory 而非 Bob，他不能通过安全认证，因此该请求不会起作用。这时，Mallory 想到使用 CSRF 的攻击方式，他先自己做一个网站，在网站中放入如下代码： src=”http://bank.example/withdraw?account=bob&amount=1000000&for=Mallory ”，并且通过广告等诱使 Bob 来访问他的网站。当 Bob 访问该网站时，上述 url 就会从 Bob 的浏览器发向银行，而这个请求会附带 Bob 浏览器中的 cookie 一起发向银行服务器。大多数情况下，该请求会失败，因为他要求 Bob 的认证信息。但是，如果 Bob 当时恰巧刚访问他的银行后不久，他的浏览器与银行网站之间的 session 尚未过期，浏览器的 cookie 之中含有 Bob 的认证信息。这时，悲剧发生了，这个 url 请求就会得到响应，钱将从 Bob 的账号转移到 Mallory 的账号，而 Bob 当时毫不知情。等以后 Bob 发现账户钱少了，即使他去银行查询日志，他也只能发现确实有一个来自于他本人的合法请求转移了资金，没有任何被攻击的痕迹。而 Mallory 则可以拿到钱后逍遥法外。

CSRF 攻击的对象

在讨论如何抵御 CSRF 之前，先要明确 CSRF 攻击的对象，也就是要保护的对象。从以上的例子可知，CSRF 攻击是黑客借助受害者的 cookie 骗取服务器的信任，但是黑客并不能拿到 cookie，也看不到 cookie 的内容。另外，对于服务器返回的结果，由于浏览器同源策略的限制，黑客也无法进行解析。因此，黑客无法从返回的结果中得到任何东西，他所能做的就是给服务器发送请求，以执行请求中所描述的命令，在服务器端直接改变数据的值，而非窃取服务器中的数据。所以，我们要保护的对象是那些可以直接产生数据改变的服务，而对于读取数据的服务，则不需要进行 CSRF 的保护。比如银行系统中转账的请求会直接改变账户的金额，会遭到 CSRF 攻击，需要保护。而查询余额是对金额的读取操作，不会改变数据，CSRF 攻击无法解析服务器返回的结果，无需保护。

 

防御策略：在请求地址中添加 token 并验证

CSRF 攻击之所以能够成功，是因为黑客可以完全伪造用户的请求，该请求中所有的用户验证信息都是存在于 cookie 中，因此黑客可以在不知道这些验证信息的情况下直接利用用户自己的 cookie 来通过安全验证。要抵御 CSRF，关键在于在请求中放入黑客所不能伪造的信息，并且该信息不存在于 cookie 之中。可以在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端建立一个拦截器来验证这个 token，如果请求中没有 token 或者 token 内容不正确，则认为可能是 CSRF 攻击而拒绝该请求。

token 可以在用户登陆后产生并放于 session 之中，然后在每次请求时把 token 从 session 中拿出，与请求中的 token 进行比对，但这种方法的难点在于如何把 token 以参数的形式加入请求。对于 GET 请求，token 将附在请求地址之后，这样 URL 就变成 http://url?csrftoken=tokenvalue。 而对于 POST 请求来说，要在 form 的最后加上 <input type=”hidden” name=”csrftoken” value=”tokenvalue”/>，这样就把 token 以参数的形式加入请求了。但是，在一个网站中，可以接受请求的地方非常多，要对于每一个请求都加上 token 是很麻烦的，并且很容易漏掉，通常使用的方法就是在每次页面加载时，使用 javascript 遍历整个 dom 树，对于 dom 中所有的 a 和 form 标签后加入 token。这样可以解决大部分的请求，但是对于在页面加载之后动态生成的 html 代码，这种方法就没有作用，还需要程序员在编码时手动添加 token。

Django 中使用CSRF

How to use it¶

To take advantage of CSRF protection in your views, follow these steps:

1. The CSRF middleware is activated by default in the MIDDLEWARE_CLASSES setting. If you override that setting, remember that 'django.middleware.csrf.CsrfViewMiddleware' should come before any view middleware that assume that CSRF attacks have been dealt with.

   If you disabled it, which is not recommended, you can use csrf_protect() on particular views you want to protect (see below).

2. In any template that uses a POST form, use the csrf_token tag inside the <form> element if the form is for an internal URL, e.g.:

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

   This should not be done for POST forms that target external URLs, since that would cause the CSRF token to be leaked, leading to a vulnerability.

3. In the corresponding view functions, ensure that RequestContext is used to render the response so that {%csrf_token %} will work properly. If you’re using the render() function, generic views, or contrib apps, you are covered already since these all use RequestContext.

CSRF with AJAX

While the above method can be used for AJAX POST requests, it has some inconveniences:you have to remember to pass the CSRF token in as POST data with every POST request. For this reason, there is an alternative method: on each XMLHttpRequest, set a custom X-CSRFToken header to the value of the CSRF token. This is often easier, because many JavaScript frameworks provide hooks that allow headers to be set on every request.

As a first step, you must get the CSRF token itself. The recommended source for the token is the csrftokencookie, which will be set if you’ve enabled CSRF protection for your views as outlined above.

 

Acquiring the token is straightforward:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// using jQuery function getCookie(name) {     var cookieValue = null;     if (document.cookie && document.cookie != '') {         var cookies = document.cookie.split(';');         for (var i = 0; i < cookies.length; i++) {             var cookie = jQuery.trim(cookies[i]);             // Does this cookie string begin with the name we want?             if (cookie.substring(0, name.length + 1) == (name + '=')) {                 cookieValue = decodeURIComponent(cookie.substring(name.length + 1));                 break;             }         }     }     return cookieValue; } var csrftoken = getCookie('csrftoken');

The above code could be simplified by using the JavaScript Cookie library to replace getCookie:　　

1	var csrftoken = Cookies.get('csrftoken');

Finally, you’ll have to actually set the header on your AJAX request, while protecting the CSRF token from being sent to other domains using settings.crossDomain in jQuery 1.5.1 and newer:

 

1 2 3 4 5 6 7 8 9 10 11

function csrfSafeMethod(method) {     // these HTTP methods do not require CSRF protection     return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method)); } $.ajaxSetup({     beforeSend: function(xhr, settings) {         if (!csrfSafeMethod(settings.type) && !this.crossDomain) {             xhr.setRequestHeader("X-CSRFToken", csrftoken);         }     } });

 

中间件middleware

为了能使用户对django的request/response请求处理过程及请求数据包进行全局的修改

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',　　'bbs.middleware.SimpleMiddleware',

]

如果要禁用或启用某个中间件，只需要在settings.py里修改MIDDLEWARE配置

middleware.py

from django.shortcuts import HttpResponseclass SimpleMiddleware(object):    def __init__(self, get_response):        self.get_response = get_response        # One-time configuration and initialization.    def __call__(self, request):        # Code to be executed for each request before        # the view (and later middleware) are called.        response = self.get_response(request)        print("middleware",response)        # Code to be executed for each request/response after        # the view is called.        return response　　#views.py执行之前    def process_view(self,request,view_func,view_args,view_kwargs):        print('process view',self,request,view_func,view_args,view_kwargs)        print(request.META.items())        if request.META.get('REMOTE_ADDR') == '127.0.0.1':            return HttpResponse('fobidden')

　　　　　　必须返回 None 或者 HttpResponse 对象
　　　　　　返回None代表django继续处理该request请求，并执行其他middleware中的process_view
　　　　　　返回HttpResponse django会直接return 不会执行views函数与其他middleware中的process_view

   #views.py有异常会触发 　　def process_exception(self,request,exception):        print('proces excetion',request,exception)        return HttpResponse('error happend...%s'%exception)   #在views.py执行结束返回之前执行 　　def process_template_response(self,request,response):        print('process_template_response',request,response)

 

 

来源：https://www.cnblogs.com/hongpeng0209/p/6590886.html