CRM系统(第一部分)

 

阅读目录

• 1、需求分析
• 2、数据库表设计
• 3、起步
• 4、录入数据
• 5、知识点

1、需求分析

CRM客户关系管理软件---》 学员管理

用户：企业内部用户

用户量：

业务场景：

2、数据库表设计

1 、表之间的对应关系

from django.db import models
 
class Customer(models.Model):
    '''客户信息表'''
    pass
 
class CustomerFollowUp(models.Model):
    '''客户跟进表'''
    pass
 
class Course(models.Model):
    '''课程表'''
    pass
 
class ClassList(models.Model):
    '''班级表'''
    pass
 
class CourseRecord(models.Model):
    '''上课记录'''
    pass
 
class StudyRecord(models.Model):
    '''学习记录'''
    pass
 
class Enrollment(models.Model):
    '''报名表'''
    pass
 
class UserProfile(models.Model):
    '''账号表'''
    pass
 
class Role(models.Model):
    '''角色表'''
    pass

2、详细表设计models.py

from django.db import models
 
# Create your models here.
class Department(models.Model):
    """
    部门表
    市场部     1000
    销售       1001
 
    """
    title = models.CharField(verbose_name='部门名称', max_length=16)
    code = models.IntegerField(verbose_name='部门编号', unique=True, null=False)
 
    def __str__(self):
        return self.title
 
from rbac.models import User
class UserInfo(models.Model):
    """
    员工表
    """
 
    name = models.CharField(verbose_name='员工姓名', max_length=16)
    email = models.EmailField(verbose_name='邮箱', max_length=64)
    depart = models.ForeignKey(verbose_name='部门', to="Department", to_field="code",on_delete=models.CASCADE)
 
    user = models.OneToOneField(to=User, null=True, on_delete=True)
    def __str__(self):
        return self.name
 
class Course(models.Model):
    """
    课程表
    如：
        Linux基础
        Linux架构师
        Python自动化开发精英班
        Python自动化开发架构师班
        Python基础班
        go基础班
    """
    name = models.CharField(verbose_name='课程名称', max_length=32)
 
    def __str__(self):
        return self.name
 
class School(models.Model):
    """
    校区表
    如：
        北京沙河校区
        上海校区
 
    """
    title = models.CharField(verbose_name='校区名称', max_length=32)
 
    def __str__(self):
        return self.title
 
class ClassList(models.Model):
    """
    班级表
    如：
        Python全栈  面授班  5期  10000  2017-11-11  2018-5-11
    """
    school = models.ForeignKey(verbose_name='校区', to='School',on_delete=models.CASCADE)
    course = models.ForeignKey(verbose_name='课程名称', to='Course',on_delete=models.CASCADE)
 
    semester = models.IntegerField(verbose_name="班级(期)")
    price = models.IntegerField(verbose_name="学费")
    start_date = models.DateField(verbose_name="开班日期")
    graduate_date = models.DateField(verbose_name="结业日期", null=True, blank=True)
    memo = models.CharField(verbose_name='说明', max_length=256, blank=True, null=True, )
    # teachers = models.ManyToManyField(verbose_name='任课老师', to='UserInfo',limit_choices_to={'depart_id__in':[1003,1004],})
    teachers = models.ManyToManyField(verbose_name='任课老师', to='UserInfo',related_name="abc",limit_choices_to={"depart__in":[1001,1005]})
    tutor = models.ForeignKey(verbose_name='班主任', to='UserInfo', related_name='classes',limit_choices_to={"depart":1003},on_delete=models.CASCADE)
 
    def __str__(self):
        return "{0}({1}期)".format(self.course.name, self.semester)
 
class Customer(models.Model):
    """
    客户表
    """
    qq = models.CharField(verbose_name='qq', max_length=64, unique=True, help_text='QQ号必须唯一')
 
    name = models.CharField(verbose_name='学生姓名', max_length=16)
    gender_choices = ((1, '男'), (2, '女'))
    gender = models.SmallIntegerField(verbose_name='性别', choices=gender_choices)
 
    education_choices = (
        (1, '重点大学'),
        (2, '普通本科'),
        (3, '独立院校'),
        (4, '民办本科'),
        (5, '大专'),
        (6, '民办专科'),
        (7, '高中'),
        (8, '其他')
    )
    education = models.IntegerField(verbose_name='学历', choices=education_choices, blank=True, null=True, )
    graduation_school = models.CharField(verbose_name='毕业学校', max_length=64, blank=True, null=True)
    major = models.CharField(verbose_name='所学专业', max_length=64, blank=True, null=True)
 
    experience_choices = [
        (1, '在校生'),
        (2, '应届毕业'),
        (3, '半年以内'),
        (4, '半年至一年'),
        (5, '一年至三年'),
        (6, '三年至五年'),
        (7, '五年以上'),
    ]
    experience = models.IntegerField(verbose_name='工作经验', blank=True, null=True, choices=experience_choices)
    work_status_choices = [
        (1, '在职'),
        (2, '无业')
    ]
    work_status = models.IntegerField(verbose_name="职业状态", choices=work_status_choices, default=1, blank=True,
                                      null=True)
    company = models.CharField(verbose_name="目前就职公司", max_length=64, blank=True, null=True)
    salary = models.CharField(verbose_name="当前薪资", max_length=64, blank=True, null=True)
 
    source_choices = [
        (1, "qq群"),
        (2, "内部转介绍"),
        (3, "官方网站"),
        (4, "百度推广"),
        (5, "360推广"),
        (6, "搜狗推广"),
        (7, "腾讯课堂"),
        (8, "广点通"),
        (9, "高校宣讲"),
        (10, "渠道代理"),
        (11, "51cto"),
        (12, "智汇推"),
        (13, "网盟"),
        (14, "DSP"),
        (15, "SEO"),
        (16, "其它"),
    ]
    source = models.SmallIntegerField('客户来源', choices=source_choices, default=1)
    referral_from = models.ForeignKey(
        'self',
        blank=True,
        null=True,
        verbose_name="转介绍自学员",
        help_text="若此客户是转介绍自内部学员,请在此处选择内部学员姓名",
        related_name="internal_referral"
    ,on_delete=models.CASCADE)
    course = models.ManyToManyField(verbose_name="咨询课程", to="Course")
 
    status_choices = [
        (1, "已报名"),
        (2, "未报名")
    ]
    status = models.IntegerField(
        verbose_name="状态",
        choices=status_choices,
        default=2,
        help_text=u"选择客户此时的状态"
    )
 
    consultant = models.ForeignKey(verbose_name="课程顾问", to='UserInfo', related_name='consultanter',
                                   limit_choices_to={'depart_id': 1001},on_delete=models.CASCADE)
 
    date = models.DateField(verbose_name="咨询日期", auto_now_add=True)
    recv_date = models.DateField(verbose_name="当前课程顾问的接单日期", null=True)
    last_consult_date = models.DateField(verbose_name="最后跟进日期", )
 
    def __str__(self):
        return "姓名:{0},QQ:{1}".format(self.name, self.qq, )
 
class ConsultRecord(models.Model):
    """
    客户跟进记录
    """
    customer = models.ForeignKey(verbose_name="所咨询客户", to='Customer',on_delete=models.CASCADE)
    consultant = models.ForeignKey(verbose_name="跟踪人", to='UserInfo',on_delete=models.CASCADE)
    date = models.DateField(verbose_name="跟进日期", auto_now_add=True)
    note = models.TextField(verbose_name="跟进内容...")
 
    def __str__(self):
        return self.customer.name + ":" + self.consultant.name
 
class Student(models.Model):
    """
    学生表（已报名）
    """
    customer = models.OneToOneField(verbose_name='客户信息', to='Customer',on_delete=models.CASCADE)
 
    username = models.CharField(verbose_name='用户名', max_length=32)
    password = models.CharField(verbose_name='密码', max_length=64)
    emergency_contract = models.CharField(max_length=32, blank=True, null=True, verbose_name='紧急联系人')
 
    class_list = models.ManyToManyField(verbose_name="已报班级", to='ClassList', blank=True)
    company = models.CharField(verbose_name='公司', max_length=128, blank=True, null=True)
    location = models.CharField(max_length=64, verbose_name='所在区域', blank=True, null=True)
    position = models.CharField(verbose_name='岗位', max_length=64, blank=True, null=True)
    salary = models.IntegerField(verbose_name='薪资', blank=True, null=True)
    welfare = models.CharField(verbose_name='福利', max_length=256, blank=True, null=True)
    date = models.DateField(verbose_name='入职时间', help_text='格式yyyy-mm-dd', blank=True, null=True)
    memo = models.CharField(verbose_name='备注', max_length=256, blank=True, null=True)
 
    def __str__(self):
        return self.username
 
class CourseRecord(models.Model):
    """
    上课记录表
    """
    class_obj = models.ForeignKey(verbose_name="班级", to="ClassList",on_delete=models.CASCADE)
    day_num = models.IntegerField(verbose_name="节次", help_text="此处填写第几节课或第几天课程...,必须为数字")
    teacher = models.ForeignKey(verbose_name="讲师", to='UserInfo',limit_choices_to={"depart_id__in":[1001,1005]},on_delete=models.CASCADE)
    date = models.DateField(verbose_name="上课日期", auto_now_add=True)
 
    course_title = models.CharField(verbose_name='本节课程标题', max_length=64, blank=True, null=True)
    course_memo = models.TextField(verbose_name='本节课程内容概要', blank=True, null=True)
    has_homework = models.BooleanField(default=True, verbose_name="本节有作业")
    homework_title = models.CharField(verbose_name='本节作业标题', max_length=64, blank=True, null=True)
    homework_memo = models.TextField(verbose_name='作业描述', max_length=500, blank=True, null=True)
    exam = models.TextField(verbose_name='踩分点', max_length=300, blank=True, null=True)
 
    def __str__(self):
        return "{0} day{1}".format(self.class_obj, self.day_num)
 
class StudyRecord(models.Model):
    course_record = models.ForeignKey(verbose_name="第几天课程", to="CourseRecord",on_delete=models.CASCADE)
    student = models.ForeignKey(verbose_name="学员", to='Student',on_delete=models.CASCADE)
    record_choices = (('checked', "已签到"),
                      ('vacate', "请假"),
                      ('late', "迟到"),
                      ('noshow', "缺勤"),
                      ('leave_early', "早退"),
                      )
    record = models.CharField("上课纪录", choices=record_choices, default="checked", max_length=64)
    score_choices = ((100, 'A+'),
                     (90, 'A'),
                     (85, 'B+'),
                     (80, 'B'),
                     (70, 'B-'),
                     (60, 'C+'),
                     (50, 'C'),
                     (40, 'C-'),
                     (0, ' D'),
                     (-1, 'N/A'),
                     (-100, 'COPY'),
                     (-1000, 'FAIL'),
                     )
    score = models.IntegerField("本节成绩", choices=score_choices, default=-1)
    homework_note = models.CharField(verbose_name='作业评语', max_length=255, blank=True, null=True)
    note = models.CharField(verbose_name="备注", max_length=255, blank=True, null=True)
 
    homework = models.FileField(verbose_name='作业文件', blank=True, null=True, default=None)
    stu_memo = models.TextField(verbose_name='学员备注', blank=True, null=True)
    date = models.DateTimeField(verbose_name='提交作业日期', auto_now_add=True)
 
    def __str__(self):
        return "{0}-{1}".format(self.course_record, self.student)
 
class CustomerDistrbute(models.Model):
    customer = models.ForeignKey("Customer", related_name="customers",on_delete=models.CASCADE)
    consultant = models.ForeignKey(verbose_name="课程顾问", to="UserInfo", limit_choices_to={"depart_id": 1001},on_delete=models.CASCADE)
    date = models.DateField()
    status = (
        (1, "正在跟进"),
        (2, "已报名"),
        (3, "三天未跟进"),
        (4, "15天未成单"),
    )
    status = models.IntegerField(choices=status, default=1)
    memo = models.CharField(max_length=255)
 
    def __str__(self):
        return self.customer.name+":"+self.consultant.name

3、起步

1、urls

from django.conf.urls import url
from django.contrib import admin
 
from stark.service.stark import site
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^stark/', site.urls),
]

2、导入stark组件，配置

　　将组件直接可以复制到CRM系统中，然后在app的setting中进行注册。

3、CRM的Stark配置

from .models import *
    from stark.service.stark import site
 
    site.register(Department)
    site.register(UserInfo)
    site.register(Course)
    site.register(School)
    site.register(ClassList)
    site.register(Customer)
    site.register(ConsultRecord)
    site.register(Student)
    site.register(CourseRecord)
    site.register(StudyRecord)

 

将CRM的所有表全部注册到Stark组件中。

4、录入数据

注册完成开始录入一些测试数据，注册成功会出现下面的URL。

1、School表

2、员工表UserInfo

3、班级表Classlist

4、客户表Customer

5、部门表Department

6、课程表Course

5、知识点

1、limit_choices_to

model与form组件的多对多关系如何渲染的

limit_choices_to

    teachers = models.ManyToManyField(verbose_name='任课老师', to='UserInfo', related_name="abc",
                                      limit_choices_to={"depart__in": [1002, 1005]})
    tutor = models.ForeignKey(verbose_name='班主任', to='UserInfo', related_name='classes',
                              limit_choices_to={"depart": 1001}, on_delete=True)

　　　　#首先有一个limit_choice_to字段：
　　　　teachers = models.ManyToManyField(verbose_name='任课老师', to='UserInfo',related_name="abc",limit_choices_to={"depart__in":[1002,1005]})
　　　　#这样限定他的部门只能是linux和python学部的员工为任课老师，可以把班主任限制在销售部的员工。

如下图：

2、自定制 display_classname

class ClassConfig(ModelStark):
 
    def display_classname(self,obj=None,header=False):
        if header:
            return "班级名称"
        class_name="%s(%s)"%(obj.course.name,str(obj.semester))
        return class_name
 
    list_display = [display_classname,"tutor","teachers"]
 
site.register(ClassList,ClassConfig)

3、obj.get_gender_display()  显示option的值（Django自带方法）

#通过这个方法，可以取到对应的choice的值，而不是序号1或者2
class CusotmerConfig(ModelStark):
 
    def display_gender(self,obj=None,header=False):
        if header:
            return "性别"
        return obj.get_gender_display()
 
    # list_display = ["name",'gender',"consultant",]
    list_display = ["name",display_gender,"consultant",]

对比：

                                          

4.mark_safe()

通过mark_safe()可以让模板不进行转义，渲染成想要的标签等。

from django.utils.safestring import mark_safe
 
class CusotmerConfig(ModelStark):
     def display_course(self,obj=None,header=False):
        #通过这个方法，可以取到对应的choice的值，而不是序号1或者2
        if header:
            return "咨询课程"
        else:
            temp=[]
            #这里的obj是customer表的实例对象，也就是当前记录的对象
            #对象正向查询按字段，直接.字段名.all()取出所有课程对象。
            #然后course.name取到所有的课程。
            for course in obj.course.all():
            #在这里拼一个a标签，url是取消课程用的，应该是某一个人取消某一门课程，
            所以取到谁取消的，（obj.pk）,取消哪一个课程（course.pk） ,课程名字（用于展示）
                s = "<a href='/stark/crm/customer/cancel_course/%s/%s' style='border:1px solid #369;padding:3px 6px'><span>%s</span></a>&nbsp;" %(obj.pk, course.pk, course.name)
                temp.append(s)
 
            return mark_safe("".join(temp))
# list_display = ["name",'course',"consultant"]
list_display = ["name",display_course,"consultant"]

5、extra_url()  额外的url接口

#在stark组件中构建一个空的列表，别的表没有额外URL就是空列表，如果前面定义了extra_url方法，那么就可以添加额外的URL接口。
def extra_url(self):
        return []

    def get_urls_2(self):
        temp = []
        model_name=self.model._meta.model_name
        app_label=self.model._meta.app_label
 
        temp.append(url(r"^add/", self.add_view,name="%s_%s_add"%(app_label,model_name)))
        temp.append(url(r"^(\d+)/delete/", self.delete_view,name="%s_%s_delete"%(app_label,model_name)))
        temp.append(url(r"^(\d+)/change/", self.change_view,name="%s_%s_change"%(app_label,model_name)))
        temp.append(url(r"^$", self.list_view,name="%s_%s_list"%(app_label,model_name)))
　　　　　#在这里调用这个方法，直接加继承一个额外的URL。
        temp.extend(self.extra_url())
 
        return temp
 
#在CRM的Stark里面，这样调用方法，可以额外添加一个URL。

　　def extra_url(self):
　　　　temp=[]
　　　　temp.append(url(r'record_score/(\d+)',self.score))
　　　　return temp

6、课程点击取消

class CusotmerConfig(ModelStark):
 
    def display_course(self,obj=None,header=False):
        if header:
            return "咨询课程"
        temp=[]
        for course in obj.course.all():
　　　　　　　#这里渲染出来课程的a标签。
            s="<a href='/stark/crm/customer/cancel_course/%s/%s' style='border:1px solid #369;padding:3px 6px'><span>%s</span></a>&nbsp;"%(obj.pk,course.pk,course.name,)
            temp.append(s)
        return mark_safe("".join(temp))
 
    # list_display = ["name",'gender','course',"consultant",]
    list_display = ["name",display_gender,display_course,"consultant",]

　　　#点击a标签，从那个接口的url发一个请求，
　　　def cancel_course(self,request,customer_id,course_id):
　　　　 # print(customer_id,course_id)
　　　    obj=self.model.objects.filter(pk=customer_id).first() #取到这个取消课程的客户对象。
　　　　  obj.course.remove(course_id) #这个客户把课程ID为某一个的课程取消掉。 #把对象通过字段找到的课程remove掉，传入remove的课程ID
　　　　  #最后重新定向回来展示页面，这样可以做出一个点击课程就可取消的效果。
　　　　  return redirect(self.get_list_url())

def extra_url(self):
        temp=[]
        temp.append(url(r"cancel_course/(\d+)/(\d+)",self.cancel_course))
        return temp
 
site.register(Customer,CusotmerConfig)

6、代码

1、starkadmin代码

from stark.service.stark import site,ModelStark
 
from .models import *
site.register(School)
 
class UserConfig(ModelStark):
    list_display = ["name","email","depart"]
 
site.register(UserInfo,UserConfig)
 
class ClassConfig(ModelStark):
 
    def display_classname(self,obj=None,header=False):
        if header:
            return "班级名称"
        class_name="%s(%s)"%(obj.course.name,str(obj.semester))
        return class_name
 
    list_display = [display_classname,"tutor","teachers"]
 
site.register(ClassList,ClassConfig)
 
from django.utils.safestring import mark_safe
from django.conf.urls import url
 
from django.shortcuts import HttpResponse,redirect
 
class CusotmerConfig(ModelStark):
 
    def display_gender(self,obj=None,header=False):
        if header:
            return "性别"
        return obj.get_gender_display()
 
    def display_course(self,obj=None,header=False):
        if header:
            return "咨询课程"
        temp=[]
        for course in obj.course.all():
            s="<a href='/stark/crm/customer/cancel_course/%s/%s' style='border:1px solid #369;padding:3px 6px'><span>%s</span></a>&nbsp;"%(obj.pk,course.pk,course.name,)
            temp.append(s)
        return mark_safe("".join(temp))
 
    # list_display = ["name",'gender','course',"consultant",]
    list_display = ["name",display_gender,display_course,"consultant",]
 
    def cancel_course(self,request,customer_id,course_id):
        print(customer_id,course_id)
 
        obj=Customer.objects.filter(pk=customer_id).first()
        obj.course.remove(course_id)
        return redirect(self.get_list_url())
 
    def extra_url(self):
 
        temp=[]
 
        temp.append(url(r"cancel_course/(\d+)/(\d+)",self.cancel_course))
 
        return temp
 
site.register(Customer,CusotmerConfig)
site.register(Department)
site.register(Course)
site.register(ConsultRecord)
site.register(CourseRecord)
site.register(StudyRecord)
site.register(Student)

 

2、stark组件代码：

from django.conf.urls import url
 
from django.shortcuts import HttpResponse,render,redirect
from django.urls import reverse
from django.db.models import Q
from django.utils.safestring import mark_safe
 
from stark.utils.page import  Pagination
from django.db.models.fields.related import ManyToManyField,ForeignKey
 
class ShowList(object):
    def __init__(self,config,data_list,request):
        self.config=config
        self.data_list=data_list
        self.request=request
        #分页
        data_count=self.data_list.count()
        current_page=int(self.request.GET.get("page",1))
        base_path=self.request.path
 
        self.pagination=Pagination(current_page,data_count,base_path,self.request.GET,per_page_num=10, pager_count=11, )
        self.page_data=self.data_list[self.pagination.start:self.pagination.end]
 
        # actions
        self.actions=self.config.new_actions() # [patch_init,]
 
    def get_filter_linktags(self):
        print("list_filter:",self.config.list_filter)
        link_dic={}
        import copy
 
        for filter_field in self.config.list_filter: # ["title","publish","authors",]
            params = copy.deepcopy(self.request.GET)
 
            cid=self.request.GET.get(filter_field,0)
 
            print("filter_field",filter_field) # "publish"
            filter_field_obj=self.config.model._meta.get_field(filter_field)
            print("filter_field_obj",filter_field_obj)
            print(type(filter_field_obj))
            from django.db.models.fields.related import ForeignKey
            from django.db.models.fields.related import ManyToManyField
            print("rel======...",filter_field_obj.rel)
 
            if isinstance(filter_field_obj,ForeignKey) or isinstance(filter_field_obj,ManyToManyField):
                 data_list=filter_field_obj.rel.to.objects.all()# 【publish1,publish2...】
            else:
                 data_list=self.config.model.objects.all().values("pk",filter_field)
                 print("data_list",data_list)
 
            temp=[]
            # 处理 全部标签
            if params.get(filter_field):
                del params[filter_field]
                temp.append("<a href='?%s'>全部</a>"%params.urlencode())
            else:
                temp.append("<a  class='active' href='#'>全部</a>")
 
            # 处理 数据标签
            for obj in data_list:
                if isinstance(filter_field_obj,ForeignKey) or isinstance(filter_field_obj,ManyToManyField):
                    pk=obj.pk
                    text=str(obj)
                    params[filter_field] = pk
                else: # data_list= [{"pk":1,"title":"go"},....]
                    print("========")
                    pk=obj.get("pk")
                    text=obj.get(filter_field)
                    params[filter_field] =text
 
                _url=params.urlencode()
                if cid==str(pk) or cid==text:
                     link_tag="<a class='active' href='?%s'>%s</a>"%(_url,text)
                else:
                    link_tag = "<a href='?%s'>%s</a>" % (_url, text)
                temp.append(link_tag)
 
            link_dic[filter_field]=temp
 
        return link_dic
 
    def get_action_list(self):
        temp=[]
        for action in self.actions:
           temp.append({
               "name":action.__name__,
               "desc":action.short_description
           })  #  [{"name":""patch_init,"desc":"批量初始化"}]
 
        return temp
 
    def get_header(self):
        # 构建表头
        header_list = []
        print("header",
              self.config.new_list_play())  # [checkbox,"pk","name","age",edit ,deletes]     【checkbox ,"__str__", edit ,deletes】
 
        for field in self.config.new_list_play():
 
            if callable(field):
                # header_list.append(field.__name__)
                val = field(self.config, header=True)
                header_list.append(val)
 
            else:
                if field == "__str__":
                    header_list.append(self.config.model._meta.model_name.upper())
                else:
                    # header_list.append(field)
                    val = self.config.model._meta.get_field(field).verbose_name
                    header_list.append(val)
        return header_list
 
    def get_body(self):
        # 构建表单数据
        new_data_list = []
        for obj in self.page_data:
            temp = []
 
            for filed in self.config.new_list_play():  # ["__str__",]      ["pk","name","age",edit]
 
                if callable(filed):
                    print("obj-----:",obj)
                    val = filed(self.config, obj)
                else:
                    try:
                        field_obj=self.config.model._meta.get_field(filed)
                        if isinstance(field_obj,ManyToManyField):
                            ret = getattr(obj,filed).all()
                            t=[]
                            for mobj in ret:
                                t.append(str(mobj))
                            val=",".join(t)
                        else:
 
                            val = getattr(obj, filed)
                            if filed in self.config.list_display_links:
                                # "app01/userinfo/(\d+)/change"
                                _url = self.config.get_change_url(obj)
 
                                val = mark_safe("<a href='%s'>%s</a>" % (_url, val))
 
                    except Exception as e:
                        val = getattr(obj, filed)
 
                temp.append(val)
 
            new_data_list.append(temp)
        return new_data_list
 
'''
        [
            [1,"alex",12],
            [1,"alex",12],
            [1,"alex",12],
            [1,"alex",12],
 
                 ]
 
        '''
 
class ModelStark(object):
 
    list_display=["__str__",]
    list_display_links=[]
    modelform_class=None
    search_fields=[]
    actions = []
    list_filter=[]
 
    def patch_delete(self, request, queryset):
 
        queryset.delete()
 
    patch_delete.short_description = "批量删除"
 
    def __init__(self,model,site):
        self.model=model
        self.site=site
 
    # 删除 编辑，复选框
    def edit(self,obj=None,header=False):
        if header:
            return "操作"
        #return mark_safe("<a href='%s/change'>编辑</a>"%obj.pk)
        _url=self.get_change_url(obj)
 
        return mark_safe("<a href='%s'>编辑</a>"%_url)
 
    def deletes(self,obj=None,header=False):
        if header:
            return "操作"
        # return mark_safe("<a href='%s/change'>编辑</a>"%obj.pk)
 
        _url=self.get_delete_url(obj)
 
        return mark_safe("<a href='%s'>删除</a>" % _url)
 
    def checkbox(self,obj=None,header=False):
        if header:
            return mark_safe('<input id="choice" type="checkbox">')
 
        return mark_safe('<input class="choice_item" type="checkbox" name="selected_pk" value="%s">'%obj.pk)
 
    def get_modelform_class(self):
 
        if not self.modelform_class:
            from django.forms import ModelForm
            from django.forms import widgets as wid
            class ModelFormDemo(ModelForm):
                class Meta:
                    model = self.model
                    fields = "__all__"
                    labels={
                        ""
                    }
            return ModelFormDemo
        else:
            return self.modelform_class
 
    def get_new_form(self,form):
 
        for bfield in form:
            from django.forms.boundfield import BoundField
            print(bfield.field) # 字段对象
            print("name",bfield.name)  # 字段名（字符串）
            print(type(bfield.field)) # 字段类型
            from django.forms.models import ModelChoiceField
            if isinstance(bfield.field,ModelChoiceField):
                bfield.is_pop=True
 
                print("=======>",bfield.field.queryset.model) # 一对多或者多对多字段的关联模型表
 
                related_model_name=bfield.field.queryset.model._meta.model_name
                related_app_label=bfield.field.queryset.model._meta.app_label
 
                _url=reverse("%s_%s_add"%(related_app_label,related_model_name))
                bfield.url=_url+"?pop_res_id=id_%s"%bfield.name
 
        return form
 
    def add_view(self, request):
        ModelFormDemo = self.get_modelform_class()
        form = ModelFormDemo()
 
        form=self.get_new_form(form)
 
        if request.method=="POST":
            form = ModelFormDemo(request.POST)
            if form.is_valid():
                obj=form.save()
 
                pop_res_id=request.GET.get("pop_res_id")
 
                if pop_res_id:
                    res ={"pk":obj.pk,"text":str(obj),"pop_res_id":pop_res_id}
                    import json
                    return render(request, "pop.html", {"res":res})
 
                else:
                    return redirect(self.get_list_url())
 
        return render(request, "add_view.html", locals())
 
    def delete_view(self, request, id):
        url = self.get_list_url()
        if request.method=="POST":
            self.model.objects.filter(pk=id).delete()
            return redirect(url)
 
        return render(request, "delete_view.html", locals())
 
    def change_view(self, request, id):
        ModelFormDemo = self.get_modelform_class()
        print("=====id",id)
        edit_obj = self.model.objects.filter(pk=id).first()
 
        if request.method=="POST":
            form = ModelFormDemo(request.POST,instance=edit_obj)
            if form.is_valid():
                form.save()
                return redirect(self.get_list_url())
 
            return render(request, "add_view.html", locals())
 
        print("***********",edit_obj)
        form = ModelFormDemo(instance=edit_obj)
        form = self.get_new_form(form)
 
        return render(request, "change_view.html", locals())
 
    def new_list_play(self):
        temp=[]
        temp.append(ModelStark.checkbox)
        temp.extend(self.list_display)
        if not self.list_display_links:
            temp.append(ModelStark.edit)
        temp.append(ModelStark.deletes)
        return temp
 
    def new_actions(self):
        temp=[]
        temp.append(ModelStark.patch_delete)
        temp.extend(self.actions)
 
        return temp
 
    def get_change_url(self,obj):
        model_name = self.model._meta.model_name
        app_label = self.model._meta.app_label
        print("obj===========",obj)
        _url = reverse("%s_%s_change" % (app_label, model_name), args=(obj.pk,))
 
        return _url
 
    def get_delete_url(self, obj):
        model_name = self.model._meta.model_name
        app_label = self.model._meta.app_label
 
        _url = reverse("%s_%s_delete" % (app_label, model_name), args=(obj.pk,))
 
        return _url
 
    def get_add_url(self):
 
        model_name = self.model._meta.model_name
        app_label = self.model._meta.app_label
 
        _url = reverse("%s_%s_add" % (app_label, model_name))
 
        return _url
 
    def get_list_url(self):
 
        model_name = self.model._meta.model_name
        app_label = self.model._meta.app_label
 
        _url = reverse("%s_%s_list" % (app_label, model_name))
 
        return _url
 
    def get_serach_conditon(self,request):
        key_word = request.GET.get("q","")
        self.key_word=key_word
 
        search_connection = Q()
        if key_word:
            # self.search_fields # ["title","price"]
            search_connection.connector = "or"
            for search_field in self.search_fields:
                search_connection.children.append((search_field + "__contains", key_word))
        return search_connection
 
    def get_filter_condition(self,request):
        filter_condition=Q()
 
        for filter_field,val in request.GET.items():
            if filter_field in self.list_filter:
                filter_condition.children.append((filter_field,val))
 
        return filter_condition
 
    def list_view(self, request):
        if request.method=="POST":  # action
            print("POST:",request.POST)
            action=request.POST.get("action") # patch_init
            selected_pk=request.POST.getlist("selected_pk")
            action_func=getattr(self,action)
            queryset=self.model.objects.filter(pk__in=selected_pk)
            ret=action_func(request,queryset)
 
            #return ret
 
        # 获取serach的Q对象
        search_connection=self.get_serach_conditon(request)
 
        # 获取filter构建Q对象
 
        filter_condition=self.get_filter_condition(request)
 
        # 筛选获取当前表所有数据
        data_list=self.model.objects.all().filter(search_connection).filter(filter_condition)            # 【obj1,obj2,....】
 
        # 按这ShowList展示页面
        showlist=ShowList(self,data_list,request)
 
        # 构建一个查看URL
        add_url=self.get_add_url()
        return render(request, "list_view.html", locals())
 
    def extra_url(self):
 
        return []
 
    def get_urls_2(self):
 
        temp = []
 
        model_name=self.model._meta.model_name
        app_label=self.model._meta.app_label
 
        temp.append(url(r"^add/", self.add_view,name="%s_%s_add"%(app_label,model_name)))
        temp.append(url(r"^(\d+)/delete/", self.delete_view,name="%s_%s_delete"%(app_label,model_name)))
        temp.append(url(r"^(\d+)/change/", self.change_view,name="%s_%s_change"%(app_label,model_name)))
        temp.append(url(r"^$", self.list_view,name="%s_%s_list"%(app_label,model_name)))
 
        temp.extend(self.extra_url())
 
        return temp
 
    @property
    def urls_2(self):
        print(self.model)
        return self.get_urls_2(), None, None
 
class StarkSite(object):
    def __init__(self):
        self._registry={}
 
    def register(self,model,stark_class=None):
        if not stark_class:
            stark_class=ModelStark
 
        self._registry[model] = stark_class(model, self)
 
    def get_urls(self):
        temp=[]
        for model,stark_class_obj in self._registry.items():
            model_name=model._meta.model_name
            app_label=model._meta.app_label
            # 分发增删改查
            temp.append(url(r"^%s/%s/"%(app_label,model_name),stark_class_obj.urls_2))
 
            '''
            url(r"^app01/userinfo/",UserConfig(Userinfo).urls_2),
            url(r"^app01/book/",ModelStark(Book).urls_2), 
 
            '''
        return temp
 
    @property
    def urls(self):
 
       return self.get_urls(),None,None
 
site=StarkSite()