Django项目回顾.md · 老男孩Python全栈21期/190326053

### 第一天

# CRM流程分析

## 一.CRM客户关系管理系统

#### 1.表结构

```
部门表
用户表
客户表
校区表
班级表
跟进记录表
报名表
缴费记录表
课程记录表
学习记录表
```

#### 2.CRM功能----登陆注册

```
创建路由：register（注册）,login（登陆）,index（首页）三个路由匹配
创建视图函数：register（注册）,login（登陆）,index（首页）三个路由匹配
	login  get/post请求
	register   get/post请求  
		1.register需要ModelForm
		2.区分：widget  在Meta 外部设置，自定义插件，用于渲染HTML
			 widgets  Meta 内部设置，自定义插件，用于渲染HTML
			 widget=forms.PasswordInput(attrs={})    
			 widgets={"username":forms.EmailInput(attrs={})}
		3.如果要设置限定条件，比如min_length，max_length等，需要在Meta类外部设置,Meta无法设置限定条件
		
		示例：
		class RegForm(forms.ModelForm):
			password = forms.CharField(min_length=6,max_length=10,
									error_messages={
										"min_length":"长度小于6位"，
										"required":"不能为空",
										"max_length":"长度大于10位"},
									}
        							widget = forms.PasswordInput（
        								attrs={'placeholder': '您的密码', 'autocomplete': 'off'
        							）
        	class Meta:
        		model = models.UserProfile
        		fields = "__all__"
        		exclude = ["is_active",]
        		widgets={
            	"username":forms.EmailInput(attrs={"placeholder":"用户名","autocomplete":"off"}),
            	"name":forms.TextInput(attrs={"placeholder":"真实姓名","autocomplete":"off"}),
            	"mobile":forms.TextInput(attrs={"placeholder":"手机号","autocomplete":"off"}),
        }
        
        4.全局钩子设置，用于注册2次密码输入是否一致
        5.self._validate_unique = True 校验账号是否重复。
        
        
```

#### 3.展示客户表

```
1.通过ORM查询符合要求数据渲染页面。查询条件为登陆时，把登陆的用户id记录在session中
	方便后续公司户转换
2.公有客户和私有客户分开，每个用户不但能看到自己客户，还能看到公有用户信息。
3.通过ORM操作筛选符合条件数据对象，返回展示页面。
```

#### 4分页显示

```
限制条件
总页码数divmod计算，最大展示页码数为自行设置
1.总页码数小于设置页码数，起始页码1，终止最大展示页码数
2.当前页码数，小于等于一半页码数，起始页码1，终止最大展示页码数
3.当前页码数加一半的最大展示页码数大于总页码数，起始位总页码数减去一半最大展示页码数加1，终止总页码数
4.其他情况，当前页码数加减，最大展示页码数的一半

分页增加类
```

#### 5.客户增加和编辑

```
定义类RegFormadd继承ModelForm

增加：
	get请求，通过RegFormadd()
	post请求，通过RegFormadd(request.POST)，判断is_valid(),存储save()
编辑：
	get请求，获取pk,通过pk用orm操作查询该对象。form_obj = RegFormadd(instance=obj)
	post请求，获取pk,RegFormadd(request.POST,instance=obj) ,判断is_valid(),存储save()

```

#### 6.中间件校验是否登陆状态

```
定义中间件process_request方法
#白名单验证
#免验证
#通过session获取当前用户id,查询ORM是否有该用户对象
	如果有将该对象保存在request中
	如果没有让返回登陆页面
	
```

#### 7.公户私户转换

```
模板设置：
	设置input框，type="checkbox"   value = {{customer.pk}}
	将要提交的数据用form表单包起来，发post请求
	customer_list,定义2个方法（公转私，私转公）用于操作数据库
	post请求，通过反射方法进行数据库操作。
```

#### 8.路径的保存

```
#templatetags/my_tags.py
通过过滤器，sample_tag实现，app项目下创建templatetags文件夹--->my_tags文件
	获取当前路径next = request.get_full_path()
	再获取当前要访问的路径,通过反向解析获取reverse(name,args=args,kwargs=kwargs)
	创建一个对象qd = QueryDict(mutable=True)，存放当前路径qd["next"] = next：
		mutable意思位可编辑的。
		通过qd.urlencode(),使用url编码方式拿取当前路径
	路径拼接，并返回路径
#视图函数调用
	next = request.GET.get("next")
	if next:
		return redirect(next)
#模板中使用
	{% load my_tags %}
	{% reverse_url request "edit_customer" customer.pk %}

示例：
@register.simple_tag
def reverse_url(request,name,*args,**kwargs):
    #当前路径
    next = request.get_full_path()#/crm/my_customer/?search=1&page=2

#获取当前的访问的路径
    # print(args)
    # print(kwargs)
    url = reverse(name,args=args,kwargs=kwargs)
    #使用可编辑有序字典，将编辑前的页面放入字典中
    qd = QueryDict(mutable=True)
    qd["next"] = next
    #使用反向解析路径进行路径拼接
    return_url = "{}?{}".format(url,qd.urlencode())
    return return_url
```

#### 9.Q查询：

```
from django.db.models import Q
模板设置：
	form表单，get请求即可。
视图函数：
	定义一个方法,方法参数为设置查询条件：
		将get请求url上提交数据获取到。
		实例化一个对象q = Q()
		设置q连接器为"OR"，q.connector="OR"   默认为"AND"
		循环查询条件，将形成元组，加入到q对象中
		q.children.append(("{}__contains".format(field),search))
	get方法调用函数
		q_search = self.search(["qq","name","phone"])
	将返回值，放入筛选条件语句中。
	
```

#### 10.跟进表的展示

```
菜单栏展示--->显示所有人的跟进记录
我的客户表点击查看跟进记录显示---->显示一个人所有跟进记录

需要设置2个路由，
#个人跟进记录
url(r'^add_enrollment/(？P<customer_id>\d+)$',views.Enrollment_change.as_view(),name='add_enrollment'),
#所有人跟进记录
url(r'^edit_enrollment/(\d+)/$',views.Enrollment_change.as_view(),name='edit_enrollment'),

#注意点视图函数需要携带customer_id，查看所有跟进记录，customer_id设置默认值0.
```

#### 11.跟进表编辑和增加

```
#pk为当前跟进表id--->编辑, customer_id为当前客户id--->新增
新增方式：
	菜单栏跟进记录表添加
	  通过customer_id--->models.ConsultRecord(customer_id=customer_id,consultant=request.user_obj)
	  设置默认customer_id = 0
	客户列表添加:
	  通过customer_id--->models.ConsultRecord(customer_id=customer_id,consultant=request.user_obj)
编辑方式：
	菜单栏跟进记录表编辑
	  通过pk--->models.ConsultRecord.objects.filter(pk=pk).first()
	客户列表编辑
	  通过pk--->models.ConsultRecord.objects.filter(pk=pk).first()
先获取上面嫌憎编辑方式的对象。
通过ModelForm表单，instance属性传入自定义ConsultRecordForm
在ConsultRecordForm中设定限制
关键点：
	self.fields["customer"].choices=[(i.pk,str(i)) for i in models.Customer.objects.filter(pk=self.instance.customer_id)]
	#customer为要设置限制的字段，self.instance为传入当前ConsultRecord表的 object
#注意：
	在客户表---查看跟进表，需携带携带当前客户id，这样进入跟进表进行新增和编辑可以进行当前用户新增
	
	跟进表id
	要添加跟进表编辑，需要在
```

#### 12.报名表

```
菜单栏：
	查看当前销售所有报名表
用户表，放置所有当前用户的报名表。需customer_id
```

#### 13.报名表添加。编辑

```
#pk为当前跟进表id--->编辑, customer_id为当前客户id--->新增
与跟进表添加编辑方式几乎一行
只不过添加在设置在customer_list.编辑设置在菜单报名表和客户表里查看报名表里编辑
```

#### 14.班级表展示，新增，编辑

```
班级表展示：
	ORM查询当前登陆班主任管理班级。
班级表功能：
	新增班级
		通过ModelForm.    form_obj = ClassListForm(instance=obj)
	编辑班级    pk

查看课程表的展示。
	在班级表里添加按钮查看课程记录。用于记录,当前路径
在查看课程记录内的操作
    课程的添加：class_id
    课程的编辑：pk
课程记录表内，可以查看学习记录

学习记录表展示，修改，批量添加
from django.forms import modelformset_factory
```

## 二.权限

```
用户查看添加数据
公共部分：
admin操作表
from django.contrib import admin
from rbac import models
class PermissionConfig(admin.ModelAdmin):
	list_display = ["id","url","title"]
	list_edittable = ["url","title"]
admin.site.register(models.Permission.PermissionConfig)
admin.site.register(models.Role)
admin.site.register(models.User)
```

- session1:登陆权限的控制

```
1.表的设计：用户表--->角色表--->权限表(之间关系)
2.登陆后将权限放在当前登陆用户的session中
3.setting设置白名单和免认证
4.通过中间件校验。
	from django.utils.deprecation import MiddlewareMixin
	from django.urls import reverse
	from django.shortcuts import redirect, HttpResponse
	from django.conf import settings
	import re	
```

- session2:动态生成一级菜单

```
1.权限表添加字段，区分那些是菜单
	is_menu
	icon  fa-connectdevelop客户列表，fa-code-fork账单表
2.登陆成功
	登陆用户对象，通过用户对象ORM操作获取所需权限，菜单信息。
	创建权限和菜单列表，将当前用户权限，菜单放入列表中
	将获取权限信息放入session中。
3.模板中循环菜单信息展示
```

- session3:动态生成二级菜单

```python
1.更改表结构
	创建菜单表Menu（字段：title,icon）,权限表外键关联菜单表。
	Permission---->Menu(一对多)
	外键blank=True,null=True。有外键可以删除is_menu及一级菜单样式icon
2.2.登陆成功
	登陆用户对象，通过用户对象ORM操作获取所需权限，菜单信息。
	构建菜单表结构：

"""

{   
   1 : {
        'title' : '财务管理',
        'icon' : 'fa-cny',
        'children' :  [ 
            { 'title':'缴费列表' ,'url':'/payment/list/'},
            { 'title':'报销列表' ,'url':'/baoxiao/list/'},
         ]
    
    } ,
    2 : {
        'title' : '客户管理',
        'icon' : 'fa-user-o',
        'children' :  [ 
            { 'title':'客户列表' ,'url':'/customer/list/'},
         ]
    } ,
}
"""
	创建权限列表。
    将获取权限信息，菜单表放入session中。
    使用include_tag ，将当前登陆用户菜单渲染出来
    母版调用。
	
	
	
	
	
	
	
```

1. 安排

1.业务

2.权限的组件

2. CRM

customer relationsship management 客户关系管理系统

3. 谁使用的？

销售  班主任 项目经理 财务

4.项目需求

1. 注册

2. 登录

3. 销售：

1. 客户信息的管理

展示   新增   编辑   删除

2. 跟进记录的管理

展示   新增   编辑  删除

3. 报名记录的管理

展示   新增   编辑  删除

4. 缴费记录的管理

展示   新增   编辑  删除

4. 班主任

1. 班级的管理

展示   新增   编辑  删除

2. 课程的管理

day66

3. 学习记录的管理

id     stu_id    cou_id

5. 表结构

1. 用户表
   2. 客户表
   3. 跟进记录表
   4. 报名记录表
   5. 缴费记录表
   6. 班级表
   7. 课程记录表
   8. 学习记录表

### 第二天

```python
class RegForm(forms.Form):
    username = forms.CharField(
        min_length=6,
        max_length=32,
        label='用户名',
        initial='初始值',
        error_messages={
            'required':'必填',
            'min_length':'最小长度',
            'invalid':''
        },
        validators=[],
        widget=forms.TextInput(attrs={''})
    )
    gender = forms.ChoiceField(choices=[(1,'男'),(2,'女')])

def clean_username(self):
        pass
        # 校验成功 返回该字段的值
        # 校验不成功  抛出异常

def clean(self):
        pass
        # 校验成功 返回所有的值
        # 校验不成功  抛出异常  __all__
        # self.add_error(filed,error)
        
        
        
class RegForm(forms.ModelForm):
    password = forms.CharField(min_length=6,
                               widget=forms.PasswordInput(attrs={'placeholder': '您的密码', 'autocomplete': 'off'}))
    re_password = forms.CharField(min_length=6,
                                  widget=forms.PasswordInput(attrs={'placeholder': '您的确认密码', 'autocomplete': 'off'}))

class Meta:
        model = models.UserProfile
        fields = '__all__'  # ['username']
        exclude = ['is_active']
        labels={
            'username':'用户名'
        }
        widgets = {
            'username': forms.EmailInput(attrs={'placeholder': '您的用户名', 'autocomplete': 'off',}),
            # 'password':forms.PasswordInput(attrs={'placeholder':'您的密码','autocomplete':'off'}),
            'mobile': forms.TextInput(attrs={'placeholder': '您的手机号', 'autocomplete': 'off'}),
            'name': forms.TextInput(attrs={'placeholder': '您的真实姓名', 'autocomplete': 'off'})
        }
        error_messages = {
            'username': {
                'required': '必填',
                'invalid': '邮箱格式不正确'
            }
        }

def clean(self):
        password = self.cleaned_data.get('password','')
        re_password = self.cleaned_data.get('re_password','')
        if password == re_password:
            # 对密码进行加密
            md5 = hashlib.md5()
            md5.update(password.encode('utf-8'))
            self.cleaned_data['password'] = md5.hexdigest()
            return self.cleaned_data
        else:
            self.add_error('re_password', '两次密码不一致')
            raise ValidationError('两次密码不一致!!')

```

#### 1.展示客户信息

1.普通的字段

对象.字段名

2.有choice参数

对象.字段名   —— 》 数据库的数据

`对象.get_字段名_display()`      —— 》 数据库的数据对应的中文提示

3.外键

对象.外键  ——》  外键对象   定义`__str__`

对象.外键.字段

4.自定义方法：

多对多：

```python
def show_class(self):
    return ' '.join([str(i) for i in self.class_list.all()])
```

自定义的需求：

```python
def show_status(self):
    color_dict = {
        'signed': "green",
        'unregistered': 'red',
        'studying': 'blue',
        'paid_in_full': 'gold'
    }
    return mark_safe(
        '<span style="color: white;background: {};padding: 5px" >{}</span>'.format(color_dict.get(self.status),self.get_status_display()))
```

#### 2.分页

见代码

#### 3.git版本回退

git reset --hard 版本号

git log

git reflog

#### 4. 克隆 推送 拉取

git clone https://gitee.com/old_boy_python_stack_21/teaching_plan.git  克隆远程仓库

git push origin master 推送本地代码到远程仓库

git pull origin master  拉取远程仓库代码到本地仓库

### 第三天

1.信息展示

ORM操作

all_customers = models.Customer.objects.all()

1.普通字段

对象.字段   ——》数据库中的值

2.有choices参数

对象.字段   ——》数据库中的值

`对象.get_字段_display()`     ——》数据库中的值对应的中文

3.外键

对象.外键字段   ——》所关联的对象    `__str__`

对象.外键.name

4.自定义方法

1. 多对多

```python
   def show_class(self):
       return '|'.join([  str(i) for i in self.class_list.all() ])
   ```

2. 自定义的需求

返回HTML标签

```python
   from django.utils.safestring import mark_safe
       
       
       def show_status(self):
           color_dict = {
               'signed': "green",
               'unregistered': 'red',
               'studying': 'blue',
               'paid_in_full': 'gold'
           }
   
           return mark_safe(
               '<span style="color: white;background: {};padding: 5px" >{}</span>'.format(color_dict.get(self.status),self.get_status_display()))
   
   
   ```

2.分页

需求：

- 新增客户（modelform）
  - get    返回一个页面 （form表单） 
  - post  提交数据  校验后保存到数据库
- 公户的展示
  - 筛选出没有销售的客户
- 私户的展示
  - 筛选出当前登录用户的客户

## 内容回顾

1.展示客户信息

1.普通字段

对象.字段   ——》 数据库中的值

2.choice参数

对象.字段   ——》 数据库中的值

`对象.get_字段_display（）`       ——》 中文的提示

3.外键

对象.外键   ——》 所关联的对象    `__str__`

对象.外键.name

4.自定义方法

多对多：

```python
	class Customer（）：
	def show_class(self):
        return '|'.join([ str(i)  for i in self.class_list.all()])
        
```

HTML：

2.新增和编辑客户信息

modelform

3.公户和私户的展示

filter()

今日内容：

1.公户和私户的转换

2.模糊查询

```
q = Q()
q.connector = 'OR'
q.children.append(Q(qq__contains=query))

Q(('qq__contains',query))   Q(qq__contains=query) 
```

3.分页保留搜索条件

```python
request.GET   <class 'django.http.request.QueryDict'>   'query': ['13']  
request.GET.urlencode()    ——》  query=13&page=1
request.GET._mutable = True  # 可编辑
request.GET.copy()   # 深拷贝 可编辑
QueryDict(mutable=True)   # 可编辑
```

4.编辑后跳转到源页面

```python
/crm/edit_customer/5/?next=/crm/customer_list/?query=13&page=2
```

## 内容回顾

1.公户和私户的转换

公户  客户没有销售

私户  客户绑定一个销售

2.模糊查询

filter（Q(__contains=query)|Q()）

```
Q(Q(qq__contains=query) | Q(name__contains=query) | Q(phone__contains=query))

field_list = []
q = Q()
q.connector = 'OR'
#q.children.append(Q(qq__contains=query))

# Q(qq__contains=query)  ——》   Q(('qq__contains',query))
for field in field_list:
	q.children.append( Q(('{}__contains'.format(field),query)) )
```

3.分页保留搜索条件

QueryDict    {}

qd = QueryDict(mutable=Ture)

qd['page'] = 1

qd['query'] = 123

qd.urlencode()    =>   page=1&query=123

request.GET.copy()    深拷贝  可编辑

4.编辑后跳转到源页面

simple_tag

QueryDict

1.跟进记录的管理

展示当前销售的所有的跟进记录

展示某一个客户的所有的跟进记录

新增和编辑跟进记录

- 限制条件
  - 限制跟进客户是当前销售的私户
  - 限制销售是当前用户

2.报名表的管理

## 内容回顾

1.crm

客户关系管理系统

2.使用者

销售 班主任 助教 讲师  财务 BOSS 学生

3.业务+技术点

1.注册+登录+注销

用户表

- 注册

- modelform

```python 
    from django import forms 
    from crm import models
    class RegForm(forms.Modelform):
        
        class Meta:
            model = models.UserProfile
            fields = '__all__'  # ['']
            exclude = []  
            
            labels = {
                'username':'用户名'
               
            }
            
        def clean_username(self):
            # 通过校验规则 返回当前字段的值
            # 不通过校验规则  抛出异常 
            
        def clean(self):
            self._validate_unique = True  # 检验唯一
            # 通过校验规则 返回当前所有的值
            self.add_error('re_password', '两次密码不一致')
            # 不通过校验规则  抛出异常 
            
        def __init__():
            
            
            
    使用：
    视图：
    	form_obj = RegForm()
        render(request,'reg.html',{'form_obj':form_obj})
        
        form_obj = RegForm(data=request.POST)
        form_obj.is_valid()
        form_obj.save()
        
        
    模板：
    	{{ form_obj.as_p }}
        
        {{ form_obj.username }}    ——》  # input 框
        {{ form_obj.username.label }}    ——》   # 中文提示
        {{ form_obj.username.id_for_label }}    ——》   # input 框的ID
        {{ form_obj.username.errors }}    ——》   # 一个字段所有的错误
        {{ form_obj.username.errors.0 }}    ——》  # 一个字段第一个的错误
        
        {{ form_obj.errors }}     ——》   # 表单所有的错误
        {{ form_obj.non_filed_errors }}     ——》   # __all__的错误
        
    
    ```

- 登录

- 登录视图
    - 获取用户名和密码校验
    - 校验失败 返回登录页面 错误提示
    - 校验成功
      - 保存用户的pk和登录状态 到session中   user_id   is_login 
      - 跳转到index
  - 中间件
    - process_request
    - 白名单
    - 校验
      - 获取is_login 
        - 没有  跳转到登录页面
        - 有
          - 从session中获取到user_id 查询用户对象
          - 把用户对象保存到request.user_obj（不建议使用user）

2.客户的管理

- 展示客户

- 展示不同的字段

1. 普通字段  对象.字段名
    2. choice      `对象.get_字段名_display()`
    3. 外键       对象.外键字段   给关联的对象的类中定义`__str__`
    4. 自定义方法
       1. 多对多    
       2. html     safe   mark_safe

- 公户和私户

- 分页

- page=1    start =(page-1) * per_num  start =page * per_num

- 模糊搜索

- Q

```python 
       q = Q() 
       q.connector = 'OR' 
       q.children.append( Q(('{}__contains',query)) )
      ```

- 新增和编辑客户

modelform

两个URL  一个视图函数  一个模板

视图函数;

```python
  新增：
  	get   form_obj = CustomerForm()
      post  form_obj = CustomerForm(request.POST)
      	  form_obj.is_valid()
            form_obj.save()
  编辑：
  	get   form_obj = CustomerForm(instance=obj)
      post  form_obj = CustomerForm(request.POST,instance=obj)
      	  form_obj.is_valid()
            form_obj.save()
  
  ```

模板：

```html
  {% for field in form_obj %}
  	
  	{{ field }}   {{ field.label }}   {{ field.id_for_label }}  {{ field.errors.0 }} 
  		
  {% endfor %}
  
  {{ field.non_field_errors.0 }} 
  ```

- 公户和私户的转换

反射 + ORM

3.跟进记录的管理

- 展示跟进记录  
  - 展示销售所有的跟进记录
  - 展示某个客户的所有的跟进记录
- 新增和编辑跟进记录
  - modelform
  - 修改字段的choices结果
    - 限制跟进人为当前的用户
    - 限制客户为当前用户的私户

4.报名表的管理

## 今日内容

1.公户变私户

行级锁

数据库

```sql
begin； 开启事务

select * from t6 where f1 = 23.46 for update;   加行级锁

commit； 结束事务
```

django：

```python
from django.db import transaction

try:
    with transaction.atomic():

# 方法一
        queryset = models.Customer.objects.filter(pk__in=pk, consultant=None).select_for_update()

queryset.update(consultant=self.request.user_obj)
   
except Exception as e:
	print(e)

```

2.私户的上限

settings：

```python
MAX_CUSTOMER_NUM = 3  # 配置写大写
```

views：

```python
from Aida_crm.settings import MAX_CUSTOMER_NUM
from django.conf import global_settings, settings
settings.MAX_CUSTOMER_NUM
```

3.班主任

- 班级的管理

- 课程记录的管理

- 学习记录（上课记录）的管理

批量插入

```python
  study_record_list = [] 
  for student in students:
      	study_record_list.append(models.StudyRecord(course_record=course_record,student=student))
      
  models.StudyRecord.objects.bulk_create(study_record_list)
  
  ```

form

modelform

modelformset

```python 
from django.forms import modelformset_factory
ModelFormSet = modelformset_factory(models.StudyRecord, StudyRecordForm, extra=0)
    form_set_obj = ModelFormSet(queryset=models.StudyRecord.objects.filter(course_record_id=course_record_id))

{{ form.instance  }}     StudyRecord对象
{{ form.attendance }}    _>  input select框

编辑
{{ form_set_obj.management_form }}
{{ form.id }}

ModelFormSet = modelformset_factory(models.StudyRecord, StudyRecordForm, extra=0)
    form_set_obj = ModelFormSet(queryset=models.StudyRecord.objects.filter(course_record_id=course_record_id),data=request.POST)
    
    
form_set_obj.is_valid()  对提交的数据进行校验
form_set_obj.save()  	保存修改

```

settings.py文件中的配置:

```python
LANGUAGE_CODE = 'zh-Hans'
# 语言变为汉字
TIME_ZONE = 'Asia/Shanghai'
# 时区为亚洲上海
DATE_FORMAT = 'Y-m-d'
# 日期格式为
DATETIME_FORMAT = 'Y-m-d H:i:s'
# 具体日期时间格式为
```

1.权限

2.为什么要有权限?

让不同的人使用不同的功能

3.开发一个权限的组件,为什么开发组件?

4.web开发中,什么是权限?

web开发中一个url代表一个权限

5.表结构的设计

用户表 user

id  username  pwd

1    alex    123

2    peiqi   123

权限表  permission

id  url

1     /customer_list/

2    /customer_add/

(url 权限 url地址正则表达式  不带^和$)

角色表

id     name

1    BOSS

2     二老板

用户和角色的关系表

id  user_id  role_id

1      1              1

2      1              2

3      2              1

角色和权限和的关系表

id    role_id  permission_id

1      1              1

2      1              2

6.功能实现

查询权限

values()    跨表 去重  去空

admin组件

```python
from crm import models
class CustomerConfig(admin.ModelAdmin):
    list_display = ['id', 'name', 'sex', 'phone', 'consultant', 'course', 'class_type', 'status']
    # 多行横向展示
    list_editable = ['name', 'sex', 'phone', 'consultant', 'course', 'class_type', 'status']
    # 使用
admin.site.register(models.Customer, CustomerConfig)
```

中间件

白名单  re.match

web开发中一个url代表一个权限

### 表结构设计

1. 权限表
   - url 权限 url地址正则表达式  不带^和$
   - title 标题
2. 角色表
   - name 角色名称
   - permission 多对多
3. 角色和权限的关系表
   - role_id
   - permission_id
4. 用户和角色关系表
   -  user_id
   - role_id
5. 用户表
   - name
   - password

### 重新设计

一级菜单

权限表

- url 
- title
- is_menu
- icon

二级菜单

菜单表

- title
- icon

权限表

- url
- title
- menu 外键 关联菜单表

权限的列表

![1563193015143](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1563193015143.png)

### day73

#### 关于Git

1. 配置
   - git init                                       初始化
   - git config --global user             用户名
   - git config --gobal email            邮箱
   - git ststus                                  查看状态
   - git add 文件                             监管某一文件
   - git add .                                   监管所有文件
   - git commit -m '描述'                 提交
   - git log                                       查看版本
   - git reflog                                  重新回到最新版本
   - git reset --hard 版本号             调到某一历史版本
   - git remote add origin 'url'         代码推送地址
   - git push origin master              代码推送到master分支
   - git pull origin master                代码从master分支拉取
   - git clone url地址                      从url地址克隆仓库
2. 分支
   - git branch                                查看分支
   - git branch dev                         创建分支dev
   - git checkout dev                     切换到dev分支
   - git merge dev                         将dev分支的更改应用于当前分支(master)
   - git branch -d debug                删除debug分支
   - 合并分支时如果两者都有更改,则会有冲突,需要手动修改
3. 个人开发流程
   1. 分支 master, dev
   2. 开发时在dev分支上开发
   3. 写完新的功能,合并到master上
   4. 如果出现bug
      1. 创建debug分支
      2. 切换到debug分支,修改bug
      3. 修改完成后提交,切换到dev,合并debug分支
      4. 切换到master分支,合并dev分支
      5. 删除debug分支
4. 公司开发流程
   1. 分支 master,dev,每个人自己的分支(apple,banana等)
   2. 每个人在自己的分支上操作
   3. 开发完功能,本地代码推送到自己的分支上
   4. 创建pull request 合并到dev上
   5. 领导审核代码,接受合并
   6. dev分支合并到master分支上
   7. 注:对于共同的文件修改,如settings,开发时需要协商,不然可能合并会出现问题

1.动态生成一级菜单

2.动态生成二级菜单

### day74

```python
from collections import OrderedDict
menu_dict = request.session.get(settings.MENU_SESSION_KEY)
    od = OrderedDict()
    keys_list = sorted(menu_dict, key=lambda x: menu_dict[x]['weight'], reverse=True)
    for key in keys_list:
        od[key] = menu_dict[key]
```

models.py中

添加weight字段

### day75

rbac 基于角色的权限控制

1. 如何实现权限控制

url代表权限

表结构

简单权限控制

- 权限表
     - url 权限  url的地址  正则表达式 不带^和$
     - title  标题
   - 角色表
     - name 角色名称
     - permissions  多对多  关联权限表
   - 用户表
     - username  用户名
     - password  密码
     - roles  多对多  关联角色表
   - 角色和权限的关系表
   - 用户和角色的关系表

一级菜单

- 权限表
     - url 权限  url的地址  正则表达式 不带^和$
     - title  标题
     - is_menu  是否是菜单
     - icon  图标

二级菜单

- 菜单表
     - title  一级菜单的名称
     - icon  图标
   - 权限表
     - url 权限  url的地址  正则表达式 不带^和$
     - title  标题
     - menu  外键  关联菜单表  有menu_id,当前的权限为二级菜单

二级菜单  对一级菜单进行排序

- 菜单表
     - title  一级菜单的名称
     - icon  图标
     - weight  整型

非菜单权限归属

- 权限表
     - url 权限  url的地址  正则表达式 不带^和$
     - title  标题
     - menu  外键  关联菜单表  有menu_id,当前的权限为二级菜单
     - parent  外键  自关联  有parent_id,当前的权限是子权限,没有为二级菜单

流程+技术点

1. 中间件

1. 获取当前访问的url地址

2. 白名单

- re
         - settings

3. request.current_menu_id = None

4. request.breadcrumb_list =

5. 验证登录状态

6. 免认证地址的校验

7. 权限校验

1. 从session中获取当前用户的权限信息

2. 循环权限字典  正则匹配

匹配成功

记录menu_id  breadcrumb_list  添加内容

获取权限id pid

有pid 当前访问的是子权限

request.current_menu_id = pid

request.breadcrumb_list.append()

2. 登陆的视图函数

1. 验证用户名和密码  验证成功  获取到用户的对象

2. 权限信息和菜单信息的初始化

1. 获取当前用户的权限信息

obj.roles.filter()

- 跨表
            - 去空
            - 去重

2. 构建数据结构  权限  菜单

权限:

简单的权限控制

非菜单权限的归属

路径导航

菜单:

动态生成一级菜单

menu_list = [{}]

二级菜单

menu_dict

3. 保存权限和菜单信息,登录状态到session json序列化  字典的key是数字的话,序列化时会变成字符串
         4. 重定向到首页

3. 模板

1. 母版和继承
         2. 动态生成菜单
            1. inclusion_tag
            2. 有序字典
            3. sorted 
            4. js  css

## day76

rbac

## 1.表结构

菜单表

- title  标题
- icon  图标
- weight 权限

权限表

- url   权限 url路径 正则表达式  ^$

- title  标题

- name  url的别名  唯一

- menu  外键    关联菜单表   blank  null     有menu_id  当前的权限是二级菜单 没有menu_id  当前的权限是普通权限

- parent  子关联  没有parent_id   父权限   有parent_id   子权限

is_menu  布尔   一级菜单使用的

icon 		一级菜单使用的

角色表

- name   角色的名称
- permissions  多对多 关联权限表

用户表

- username 
- password
- roles    多对多 关联角色表

角色和权限的关系表

用户和角色的关系表

## 2.流程

### 简单的权限控制

1. 登录成功保存权限信息到session中

权限的数据结构：

permission_list = [  {  url  }]

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限
     - 循环权限   正则匹配

3. 模板

- 母版和继承

### 动态生成一级菜单

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_list = [  {  url  }]

菜单的数据结构：

menu_list =  [  { url   title   } ]

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限
     - 循环权限   正则匹配

3. 模板

- 母版和继承 
   - 动态生成一级菜单
     - inclusion_tag 
     - 一层for循环 menu_list

### 动态生成二级菜单

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_list = [  {  url  }]

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   children： [  {  url   title }  ]

}

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限
     - 循环权限   正则匹配

3. 模板

- 母版和继承 
   - 动态生成二级菜单
     - inclusion_tag 
     - 两层for循环 menu_dict.values()

### 动态生成二级菜单( 一级菜单排序 )

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_list = [  {  url  }]

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   weight  children： [  {  url   title }  ]

}

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限
     - 循环权限   正则匹配

3. 模板

- 母版和继承 
   - 动态生成二级菜单
     - inclusion_tag 
     - sorted  
     - 有序字典
     - 两层for循环 od.values()

### 动态生成二级菜单( 二级菜单默认选中 展开的状态 )

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_list = [  {  url  }]

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   weight  children： [  {  url   title }  ]

}

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限
     - 循环权限   正则匹配

3. 模板

- 母版和继承 
   - 动态生成二级菜单
     - inclusion_tag 
     - sorted  
     - 有序字典
     - 循环二级菜单
       - url  正则匹配
       - 匹配成功   二级菜单  class = active   一级菜单  class= ‘hide’ 移除
     - 两层for循环 od.values()

### 动态生成二级菜单(非菜单权限归属     访问子权限后者二级菜单 都让二级菜单选中 )

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_list = [  {  url  id  pid  }]

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   weight  children： [  {  url   title  id }  ]

}

2. 中间件

- 获取当前访问的url路径

- 白名单

- request.current_meni_id  = None

- 登录状态的校验

- 免认证的校验

- 权限的校验

- 从session中获取权限

- 循环权限   正则匹配

- 获取id   pid

- 没有pid  当前访问的是二级菜单    request.current_meni_id = id

- 有pid       当前访问的是子权限      request.current_meni_id = pid

3. 模板

- 母版和继承

- 动态生成二级菜单

- inclusion_tag 
     - sorted  
     - 有序字典
     - 循环二级菜单
       - request.current_meni_id    ==  二级菜单的id 
       - 匹配成功   二级菜单  class = active   一级菜单  class= ‘hide’ 移除
     - 两层for循环 od.values()

### 路径导航

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_dict = {   权限的id ：  {  url  id  pid   title }}

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   weight  children： [  {  url   title  id }  ]

}

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - request.current_meni_id  = None
   - request.breadcrumb_list =   [  {  url： index   title ： 首页  } ]
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限   permission_dict
     - 循环权限   正则匹配  
       - 获取id   pid 
       - 没有pid  
         - 当前访问的是二级菜单  
           - request.current_meni_id = id
           - request.breadcrumb_list.append( {  url  i[url]   title  i[title]  }  )
       - 有pid       
         - 当前访问的是子权限     
           - request.current_meni_id = pid
           - p_permisison = permission_dict[str(pid)]
           - request.breadcrumb_list.append( {  url  p_permisison [url]   title  p_permisison [title]  }  )
           - request.breadcrumb_list.append( {  url  i[url]   title  i[title]  }  )

3. 模板

### 权限控制到按钮级别

1. 登录成功保存权限信息和菜单信息到session中

权限的数据结构：

permission_dict = {   权限的name ：  {  url  id  pid   title  pname }}

菜单的数据结构：

menu_dict = {

一级菜单的ID： {

title   icon   weight  children： [  {  url   title  id }  ]

}

2. 中间件

- 获取当前访问的url路径
   - 白名单
   - request.current_meni_id  = None
   - request.breadcrumb_list =   [  {  url： index   title ： 首页  } ]
   - 登录状态的校验
   - 免认证的校验
   - 权限的校验
     - 从session中获取权限   permission_dict
     - 循环权限   正则匹配  
       - 获取id   pid   pname
       - 没有pid  
         - 当前访问的是二级菜单  
           - request.current_meni_id = id
           - request.breadcrumb_list.append( {  url  i[url]   title  i[title]  }  )
       - 有pid       
         - 当前访问的是子权限     
           - request.current_meni_id = pid
           - p_permisison = permission_dict[pname]
           - request.breadcrumb_list.append( {  url  p_permisison [url]   title  p_permisison [title]  }  )
           - request.breadcrumb_list.append( {  url  i[url]   title  i[title]  }  )

3. 模板

- 母版和继承 
   - 动态生成二级菜单
     - inclusion_tag 
     - sorted  
     - 有序字典
     - 循环二级菜单
       - request.current_meni_id    ==  二级菜单的id 
       - 匹配成功   二级菜单  class = active   一级菜单  class= ‘hide’ 移除
     - 两层for循环 od.values()
   - 路径导航
     - inclusion_tag 
     - 一层for循环 request.breadcrumb_list 
   - 权限控制到按钮级别
     - filter    -  has_permission
     - name  in  permission_dict    在返回True
     - {% if   request|has_permission: name   %}    { % endif %}

## 今日内容

1. 单个权限的新增编辑删除

2. 批量操作权限

待新增的     路由系统中有  数据库中没有

待更新的     路由系统中有  数据库中也有

待删除的     路由系统中没有  数据库中有

3. 分配权限

4. 权限组件的应用

1. 拷贝rbac组件到新项目中，并注册

```
   INSTALLED_APPS = [
   		...
       'rbac.apps.RbacConfig'
   ]
   ```

2. 数据库迁移

1. 修改用户表

```python
      class User(models.Model):
          """用户表"""
          # username = models.CharField('用户名', max_length=32)
          # password = models.CharField('密码', max_length=32)
          roles = models.ManyToManyField(Role, verbose_name='用户所拥有的角色', blank=True)
      	# 多对多关联写成类  不写字符串
          class Meta:
              abstract = True  # 数据库迁移时不生成表  作基类 继承使用
      ```

2. 新项目的用户表继承User

```python
      from rbac.models import User
      class UserProfile(User):
      ```

3. 执行数据库迁移的命令

1. 先删除rbac中migrations中的除了init之外的py文件

2. 执行

python manage.py makemigrations

python manage.py migrate

3. 路由配置

```
   urlpatterns = [
    	....
       url(r'^rbac/', include('rbac.urls')),
   ]
   ```

4. 角色管理

<http://127.0.0.1:8000/rbac/role/list/>

5. 一级菜单管理

<http://127.0.0.1:8000/rbac/menu/list/>

6. 批量操作权限

<http://127.0.0.1:8000/rbac/multi/permissions/>

批量输入标题

给权限分配给一级菜单  给父权限分配子权限

7. 分配权限

如果用的不是rbac的User，替换User为当前使用的用户model

给角色分权限

给用户分角色

8. 应用权限的中间件

```
   MIDDLEWARE = [
   	...
       'rbac.middlewares.middleware.AuthMiddleWare',
   
   ]
   ```

在settings中添加权限的配置

```
   #  白名单
   WHITE_LIST = [
       r'/login/$',
       r'/reg/$',
       r'/admin/.*'
   ]
   
   # 免认证的地址
   NO_PERMISSION_LIST = [
       r'/index/'
   
   ]
   
   # 权限的session的key
   PERMISSION_SESSION_KEY = 'permission'
   
   # 菜单的session的key
   MENU_SESSION_KEY = 'menu'
   ```

登录成功后调用权限信息初始化的函数

9. 动态生成二级菜单

```
   {% load rbac %}
   {% menu request %}
   ```

使用 css js

```
<script src="{% static 'rbac/js/menu.js' %} "></script>
```

10. 路径导航

```
    {% breadcrumb request %}
    
    ```

11. 权限控制到按钮级别

```
    {% load rbac %}
    {% if request|has_permission:'add_consult' %}
           <a href="{% url 'add_consult' customer_id %}" class="btn btn-primary">新增</a>
    {% endif %}
    ```

### day78

文章

类别表

- 列表的名称

文章表

- title 
- categary  外键关联
- create_at  datetime
- summary 摘要

文章详情表

- content textfield

文章表

id    detail_id

3       1

文章表详情表

id   contnet

1      'askjhwqhwqlkhwqlcalkjawehrewlkjaasa'

用户表

博客表

分类

文章表

文章详情

media的配置

settings的配置

```
MEDIA_URL = '/media/'

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
```

url的配置

```python
from django.views.static import serve
from django.conf import settings

urlpatterns = [
 
    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
]
```

富文本编辑框

下载

pip install django-ckeditor

```
INSTALLED_APPS = [
	
    'ckeditor',
    'ckeditor_uploader',
]
```

使用字段：

```
from ckeditor_uploader.fields import RichTextUploadingField

class ArticleDetail(models.Model):
    content = RichTextUploadingField(verbose_name='文章详情')
```

配置URL：

```python
from ckeditor_uploader import views

urlpatterns = [

url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
    # 上传文件
    url(r'^ckeditor/upload/', views.upload),
    url(r'^ckeditor/', include('ckeditor_uploader.urls')),

]
```

模板中：

```
{{ field }}   富文本编辑框的字段

## day79

djangorestframework使用

1. 下载安装

```python
pip install djangorestframework  ## djangorestframework
pip install django-filter  ## 过滤使用
```

2. 注册

```python
INSTALLED_APPS = [
	...
    'rest_framework',
    'django_filters'
]
```

3. model

```python
class Feedback(models.Model):
    type_choice = (
        (0, '未分类'),
        (1, '学习笔记'),
        (2, '学员评价'),
        (3, '入职邀约'),
    )

img = models.ImageField(upload_to='img/feedback/')
    back_type = models.IntegerField(choices=type_choice, default=0)
```

4. 路由

```
url(r'^ajax_feedback/', views.AjaxFeedback.as_view()),
```

5. 视图

```python
from rest_framework import generics
from web.serializers import FeedbackSerializer
from web.pagination import DefaultPagination
from django_filters.rest_framework import DjangoFilterBackend

class AjaxFeedback(generics.ListAPIView):
    queryset = models.Feedback.objects.all()
    serializer_class = FeedbackSerializer
    pagination_class = DefaultPagination
    filter_backends = [DjangoFilterBackend, ]
    filter_fields = ['back_type']
```

6. 序列化器类

```python
from rest_framework import serializers
from repository import models

class FeedbackSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Feedback
        fields = ['img']

```

7. 分页类

```python
from rest_framework.pagination import PageNumberPagination

class DefaultPagination(PageNumberPagination):
    page_size = 8  # 一页多少条数据
    page_query_param = 'page'  # 分页查询条件的key
    page_size_query_param = 'size'
    # max_page_size = 8

```

老男孩Python全栈21期/190326053

简介

发行版

贡献者

近期动态

老男孩Python全栈21期/190326053 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

老男孩Python全栈21期/190326053