################
# 2017-09-10 - 课上笔记
################


上节回顾
	1.http请求周期
		请求头和请求体使用 ‘\r\n\r\n‘ 分隔

	2.Models操作
		单表
			[obj,obj,obj...] = models.xxx.objects.all()
			[{},{},{}...] = models.xxx.objects.values(xx,xx,xx...)
			[(),(),()...] = models.xxx.objects.values_list(xx,xx,xx...)

		一对多
			dep 部门表：标题
			user 员工表：用户，邮箱，部门id(外键)

			qs = [obj,obj,obj...] = models.user.objects.all()
			for row in qs:
				row.id,row.name,row.email,row.xx.title

			user 查 dep
				[{},{},{}...] = models.user.objects.values(‘id‘,‘name‘,‘email‘,‘xx__title‘)
				[(),(),()...] = models.user.objects.values_list(‘id‘,‘name‘,‘email‘,‘xx__title‘)

			dep 反查 user ：   user_set （在dep表里隐含的字段,多对多同样）

		多对多

			业务线  id name M2M

			用户表  id name 

			django给创建第三张表（因为manytomany）



	3.自定义分页模块

	4.csrf



	5.cookie 
		保存在客户端浏览器上的键值对

	6.session
		保存在服务器端的键值对，依赖cookie






day20今日内容
	1. FBV 和 CBV
		FBV：function basic view
			/index/    func(request)
						if "GET" == request.method:
							...

		CBV：class basic view
			/index/    class(object)
						- 判断：
							get请求  就执行类里的get方法
							post请求  就执行类里的post方法


		form表单只能提交 ‘get‘ 和 ‘post‘ 方法
		ajax 则可以提交：‘get‘, ‘post‘, ‘put‘, ‘patch‘, ‘delete‘, ‘head‘, ‘options‘, ‘trace‘
			ajax 遵循resful规范

/index/    obj = 类()

找到类之后，执行完 __init__ 就执行 dispatch()方法，自己不写的话就执行父类的 dispatch()
‘‘‘
class B:
	def f1(self):
		self.f2()

class A(B):
	def f2(self):
		print("---> A")


obj = A()
obj.f1()  --->  B.f1(obj)  --> obj.f2()
‘‘‘
	
    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn‘t exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn‘t on the approved list.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)


	POST   obj.post   是通过反射 getattr()
	GET    obj.get    是通过反射 getattr()

			‘‘‘执行super，调用父类的dispatch方法‘‘‘
		    def dispatch(self, request, *args, **kwargs):
		    	print(‘before‘)
		        # 执行父类的 dispatch方法
		        response = super(LoginView,self).dispatch(request,*args, **kwargs)
		        print(‘after‘)
		        return response

		    ‘‘‘或者重写父类的dispatch‘‘‘
		    def dispatch(self, request, *args, **kwargs):
		        method = request.method.lower()
		        # print(‘+++++++++++++‘, self.http_method_names)
		        if hasattr(LoginView,method):
		            func = getattr(LoginView,method)
		            return func(self, request, *args, **kwargs)
		        else:
		            return HttpResponse(‘err‘)

		    def get(self,request,*args,**kwargs):
		        print(‘------->> get‘)
		        return render(request,‘login.html‘)

		    def post(self,request,*args,**kwargs):
		        print(‘------->> post‘)
		        return HttpResponse(‘ok‘)


    注意：django的CBV里装饰器不能直接用，需要使用： from django.utils.decorators import method_decorator

    	FBV -> 函数
    	CBV -> 类
    		- dispatch
    		- get/post

    	应用：
    		登录验证的几种实现方法：
    			- 继承

- 单继承实现
    				‘‘‘
from django.shortcuts import render,redirect,HttpResponse
from django.views import View
from django.views.decorators.csrf import csrf_exempt,csrf_protect
from django.core import serializers
from django.utils.decorators import method_decorator

# Create your views here.

class Login(View):
    def dispatch(self, request, *args, **kwargs):
        return super(Login,self).dispatch(request, *args, **kwargs)
    def get(self, request,*args, **kwargs):
        return render(request,‘login.html‘)
    def post(self, request,*args, **kwargs):
        user = request.POST.get(‘user‘)
        pwd = request.POST.get(‘pwd‘)
        if ‘alex‘ == user and ‘123‘ ==pwd:
            request.session[‘user‘] = user
            return render(request,‘private.html‘,{‘user‘:user})
        return render(request,‘login.html‘,{‘msg‘:‘用户名或密码错误！‘})

class Base(View):
    def dispatch(self, request, *args, **kwargs):
        if request.session.get(‘user‘):
            response = super(Base,self).dispatch(request, *args, **kwargs)
            return response
        else:
            return redirect(‘/login/‘)
class Index(Base):
    def get(self, request,*args, **kwargs):
        return render(request, ‘index.html‘, {‘user‘: request.session.get(‘user‘)})
    				‘‘‘


- 多继承实现
‘‘‘
class Base(object):
    def dispatch(self, request, *args, **kwargs):
        if request.session.get(‘user‘):
            response = super(Base,self).dispatch(request, *args, **kwargs)
            return response
        else:
            return redirect(‘/login/‘)
        
class Index(Base,View):
    def get(self, request,*args, **kwargs):
        return render(request, ‘index.html‘, {‘user‘: request.session.get(‘user‘)})
‘‘‘







    			- 装饰器
    				auth 是装饰器函数


- 加在类上 		@method_decorator(auth,name=‘post‘)

‘‘‘
# 装饰器：验证用户是否已经登录
def auth(func):
    def wrapper(request, *args, **kwargs):
        if request.session.get(‘user‘):
            obj = func(request, *args, **kwargs)
            return obj
        else:
            return redirect(‘/login/‘)
    return wrapper

@method_decorator(auth,‘get‘)
class Index(View):
    def dispatch(self, request, *args, **kwargs):
        return super(Index, self).dispatch(request, *args, **kwargs)
    def get(self, request, *args, **kwargs):
        return render(request, ‘index.html‘, {‘user‘: request.session.get(‘user‘)})
‘‘‘




- 加在dispatch上 	@method_decorator(auth)

‘‘‘
# 装饰器：验证用户是否已经登录
def auth(func):
    def wrapper(request, *args, **kwargs):
        if request.session.get(‘user‘):
            obj = func(request, *args, **kwargs)
            return obj
        else:
            return redirect(‘/login/‘)
    return wrapper

class Index(View):
    @method_decorator(auth)
    def dispatch(self, request, *args, **kwargs):
        return super(Index, self).dispatch(request, *args, **kwargs)
    def get(self, request, *args, **kwargs):
        return render(request, ‘index.html‘, {‘user‘: request.session.get(‘user‘)})
‘‘‘




- 加在具体方法上 	@method_decorator(auth)
    				 ‘‘‘
# 装饰器：验证用户是否已经登录
def auth(func):
    def wrapper(request, *args, **kwargs):
        if request.session.get(‘user‘):
            obj = func(request, *args, **kwargs)
            return obj
        else:
            return redirect(‘/login/‘)
    return wrapper

class Index(View):
    @method_decorator(auth)
    def get(self, request, *args, **kwargs):
        return render(request, ‘index.html‘, {‘user‘: request.session.get(‘user‘)})
    				 ‘‘‘


    				 from django.views.decorators.csrf import csrf_exempt,csrf_protect
    				 - csrf_exepmt 加在POST上例外，只能加在 dispatch上有效，官网bug。






	2. 序列化  （Json是不能处理 queryset的）

		- 模板渲染
		- ajax
			- from django.core import serializers
			- serializers 的局限性：
			   	queryset里必须是obj才可以
			  	如果是models.xxx.objects.values(xx,xx,xx) 这样得到的queryset是不能用serializers进行序列化的！！！
			  	只能采用在后台自己拼接好字典等形式，自己搞成json.dumps然后传给ajax
			- json 序列化 （有局限性，需自定义dumps）
				因为json能处理的数据类型有限，比如datetime类型就不能处理，需要自定义dumps函数

		方式一：
			user_list = models.UserInfo.objects.all()
			data = serializers.serialize("json", user_list)
			[
				{"model": "app01.userinfo", "pk": 1, "fields": {"username": "\u5174\u666e", "password": "123123"}}, 
				{"model": "app01.userinfo", "pk": 2, "fields": {"username": "\u94f6\u79cb\u826f", "password": "666"}}
			]
			
		方式二：
			
			user_list = models.UserInfo.objects.values(‘id‘,‘username‘)
			user_list = list(user_list)
			data = json.dumps(user_list)
			[
				{"username": "\u5174\u666e", "id": 1}, 
				{"username": "\u94f6\u79cb\u826f", "id": 2}
			]
			

			问题：json支持的数据类型有限，针对一些数据类型，例如datatime类型则不能进行序列化：
class JSONEncoder(object):
    """Extensible JSON <http://json.org> encoder for Python data structures.

    Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    To extend this to recognize other objects, subclass and implement a
    ``.default()`` method with another method that returns a serializable
    object for ``o`` if possible, otherwise it should call the superclass
    implementation (to raise ``TypeError``).

    """
...


　　　　　　　　　　　　　　 解决办法：对json.dumps做定制：
				
					import json
					from datetime import date
					from datetime import datetime

					class JsonCustomEncoder(json.JSONEncoder):
						def default(self, field):
							if isinstance(field, datetime):
								return field.strftime(‘%Y-%m-%d %H:%M:%S‘)
							elif isinstance(field, date):
								return field.strftime(‘%Y-%m-%d‘)
							else:
								return json.JSONEncoder.default(self, field)


					user_list = [
						{‘id‘:1,‘name‘:‘alex‘,‘ctime‘: datetime.now()},
						{‘id‘:2,‘name‘:‘eric‘,‘ctime‘: datetime.now()}
					]

					data = json.dumps(user_list,cls=JsonCustomEncoder)
					print(data)


ajax扩展：
	从后端获得的字符串： JSON.parse()  可以被 dataType: ‘JSON‘ 这一行替换：

# 后端代码：
...
import json
return HttpResponse(json.dumps({‘flag‘:True,‘msg‘:‘ok‘}))
...

示例1：使用JSON.parse()的情况，返回的是 object类型
<form id="my_form" action="/login/" method="post">
    {% csrf_token %}
    <input type="text" name="user">
    <input type="password" name="pwd">
    <button onclick="ajaxSubmit()">Ajax提交</button>
</form>
<script src="{% static "js/jquery-3.2.1.min.js" %}"></script>
<script src="{% static "js/jquery.cookie.js" %}"></script>
<script src="{% static "js/bootstrap.js" %}"></script>

<script>
    function ajaxSubmit() {
        $.ajax({
            url:‘/login/‘,
            type:‘POST‘,
            data:{
                ‘user‘:$(‘#my_form input[name="user"]‘).val(),
                ‘pwd‘:$(‘#my_form input[name="pwd"]‘).val()
            },
            headers:{‘X-CSRFToken‘: $.cookie(‘csrftoken‘)},
            success:function (data) {
                var info = JSON.parse(data);
                console.log(info);
                console.log(typeof info);
            }
        })
    }
</script>


示例2：使用dataType: ‘JSON‘的情况，返回的是string类型
<form id="my_form" action="/login/" method="post">
    {% csrf_token %}
    <input type="text" name="user">
    <input type="password" name="pwd">
    <button onclick="ajaxSubmit()">Ajax提交</button>
</form>
<script src="{% static "js/jquery-3.2.1.min.js" %}"></script>
<script src="{% static "js/jquery.cookie.js" %}"></script>
<script src="{% static "js/bootstrap.js" %}"></script>

<script>
    function ajaxSubmit() {
        $.ajax({
            url:‘/login/‘,
            type:‘POST‘,
            datatype:‘JSON‘,
            data:{
                ‘user‘:$(‘#my_form input[name="user"]‘).val(),
                ‘pwd‘:$(‘#my_form input[name="pwd"]‘).val()
            },
            headers:{‘X-CSRFToken‘: $.cookie(‘csrftoken‘)},
            success:function (info) {
                console.log(info);
                console.log(typeof info);
            }
        })
    }
</script>



	3. Django的Form表单验证（用户请求的验证 + 生成HTML标签）


		示例：用户管理
		添加用户页面：
			- 显示HTML标签
			- 提交：数据验证
			- 成功之后保存
			- 错误的话则提示错误信息

		from django.forms import widgets  样式


		总结：
			1. 创建类 MyForm（本质就是正则表达式的集合），继承Form类
			2. 只是生成HTML标签：form = MyForm()    添加页面
			3. 带默认值的HTML标签：form = MyForm(initial={‘xx‘:‘xx‘,...})   编辑页面
			4. 提交数据：form = Form(data=request.POST)
			             if form.is_valid():
			             	print(form.cleaned_data)
			             else:
			             	print(form.errors)
			5. 存在的问题：下拉框有更新时无法实时更新到前端页面

				解决办法：重写下 __init__(self,*args,**kwargs)

‘‘‘

class UserForm(Form):
    user = fields.CharField(required=True,error_messages={‘required‘:‘用户名不能为空‘})
    pwd = fields.CharField(required=True,error_messages={‘required‘:‘密码不能为空‘})
    email = fields.EmailField(required=True,error_messages={‘required‘:‘邮箱不能为空‘,‘invalid‘:‘邮箱格式不正确‘})
    # user_type = models.UserType.objects.values_list(‘id‘,‘title‘)
    # user_type = list(user_type)
    ut_id = fields.ChoiceField(choices=[])

    role_id = fields.MultipleChoiceField(choices=[])

    # ip = fields.GenericIPAddressField(required=True)

    # 解决下拉框数据更新后，前端页面不更新的问题
    def __init__(self,*args,**kwargs):
        super(UserForm,self).__init__(*args,**kwargs)
        self.fields[‘ut_id‘].choices = models.UserType.objects.values_list(‘id‘,‘title‘)
        self.fields[‘role_id‘].choices = models.Role.objects.values_list(‘id‘,‘caption‘)

‘‘‘



一对多


多对多





三元运算：v = xxx if xxx else []



找name等于user的input标签
$(‘#f1 input[name="user"]‘).val(‘xxxxx‘)



$(‘#f1 .error‘).remove() 

input标签后提示错误信息：
$.each(arg.msg, function(k,v){
	var tag = document.createFlement(‘span‘);
	tag.innerHTML = v[0];
	tar.className = "error"
    # <span class=‘error‘>v[0]</span>

	$(‘#f1 input[name="‘ + k + ‘user"]‘).after(tag)
})



定律：
	如果用模态对话框进行添加或者修改等操作，则前端提交数据需要用ajax，后端可以用django的form组件
	因为ajax不刷新，所以可以利用form组件的验证功能，生成HTML的功能可用可不用

	如果用新的页面进行添加或者修改等操作，则用ajax和form表单提交都可以；后端可以用django的form组件
	因为form有刷新，生成HTML的功能要使用，不可以自己手写HTML标签，避免之前的数据因为刷新导致丢失；





	4. 缓存

	5. 中间件

	6. 信号（scrapy爬虫框架里有用）

	7. Django的 Admin


JS跳转页面的方法：location.href = ‘/index.html‘





day20作业：
	还是主机管理
	1. 登录 + 注册（ajax+form组件）

	FBV / CBV 都可以
	2. 业务线管理（列表、增加、修改  页面跳转） 模态确认删除    单表
	3. 主机管理（列表、增加、修改  页面跳转） 模态确认删除      一对多
	4. 用户管理（列表、增加、修改  页面跳转） 模态确认删除      多对多

	5. 自定义分页

	6. Bootstrap


把课上讲的内容搞明白，还有几个之前忘记的点，今天老师写的；
然后开始做作业；
周六上午，整理出遇到的问题；



‘‘‘‘‘‘

# shell in a box  插件

三元运算符

列表推导式

生成器推导式