西游之路——python全栈——CRM用户关系管理

 

 

 

目录

 
 Day1:项目分析
  一：需求分析
  二：CRM角色功能介绍
  三：业务场景分析
  四：表结构设计
 Day2:主要实现功能kingadmin为各个应用实现一个类似于Django自带的数据库管理功能
  kingadmin目录　　　　　　　　
  销售目录
  学员目录
 Day3:对上面的功能添加分页，筛选，排序，搜索功能(功能之间的url需要重组)
  一：分页实现（在Django自带分页组件下进行扩展）
  二：对各个字段筛选（对kingadmin中list_filter字段进行筛选）
  三：对各个字段进行排序（list_display）
  四：对字段进行搜索（search_fields）
Day4:动态生成任意表的CURD
  1.如何在前端动态生成标签？使用form验证可以针对model生成所有的字段控件
  2.如何针对每张表动态生成一个Form类？需要用到type方法去动态生成类
  3.在修改页面中动态创建Form类（需要传递原来数据）
  4.在添加页面动态创建Form类
  5.修改和添加的HTML和公共部分
  6.处理在add和change中对于readonly_fileds字段的不同
  7.对于filter_horizontal字段我们在模板函数中进行获取所有的值，并且判断是否显示在哪一个select标签中
  8.实现js双击option,在两个select之间跳转
  9.实现在点击保存时，form表单自动将右侧select中的数据全部选中。注意：加上name为select标签，name="字段名"
  10.为filter_horizontal完善功能，添加全选，全部移除
Day5:删除功能开发和action方法实现
  1.删除功能开发
  2.action字段功能完善
  3.处理action中的默认行为delete批量删除
  4.实现面包屑导航
 Day6:学员报名流程开发
  一：销售为想报名的学员提供链接
  二：学员获取链接，进行填写信息，查阅合同，同意并上传证件信息
  三：销售审核学员注册信息,审核通过，为其生成账号（密码需要使用Django模块加密），发送邮件
day7:实现讲师和学员作业发布上传功能（其中由于多使用table浏览数据，可以自定义一个类似于form的基类，去统一实现table显示）
  一：讲师功能
  二：学员功能，实现课程显示，作业提交

 总结：学会偷懒，化繁为简，学会总结业务，再去动态处理，而不是一直对数据库的增删改查，和重复一个业务逻辑

 

Day1:项目分析

　　一：需求分析

二：CRM角色功能介绍

 

三：业务场景分析

销售：
    1.销售A 从百度推广获取了一个客户，录入了CRM系统，咨询了Python课程，但是没有报名
    2.销售B 从qq群获取一个客户，成功使他报名Python班，然后给他发送了报名连接，等待用户填写完毕后，将他添加到Python具体的学习班级中
    3.销售C 打电话给之前的一个客户，说服他报名Python课程，但是没有成功，更新了跟踪记录
    4.销售D 获取了一个客户，录入信息时，发现此客户已经存在，不允许重复录入，随后通知相应的原负责人跟进
    5.销售E 从客户库中获取了，超过一个月未跟进的客户，进行再次跟进
    6.销售主管 查看了部门本月的销售报表，包括来源分析，成单率分析，班级报名数量分析，销售额环比，同比

学员：
    1.客户A 填写了销售发来的报名连接，上传了个人的证件信息，提交，之后收到邮件，告知报名成功，并为他开通了学员账号，升级为学员A
    2.学员A 登录学员系统，看到自己的合同，报名的班级，课程大纲
    3.学员A 提交了Python课程当时课时作业
    4.学员A 查看自己的Python课程成绩，排名
    5.学员A 搜索问题，未找到答案，录入一条问题
    6.学员A 转介绍学员，录入其信息

讲师：
    1.讲师A 登录CRM系统，查看自己管理的班级列表
    2.讲师A 进入Python 5期课程，创建第3节的上课记录，填写了本节课内容，作业要求
    3.讲师A 在课程中点名，对点名情况进行录入，标记相关状态
    4.讲师A 批量下载所有学员的课时作业，给每个学员在线批注了成绩+状态
    

管理员：
    1.创建课程 C++，Python..
    2.创建校区 上海，北京..
    3.创建班级 C++35期，Python27期
    4.创建账号 ABCD
    5.创建了销售，讲师，学员角色
    6.为账号分配到对应的角色，将ABCD分配给销售
    7.创建相关权限
    8.为销售角色分配了相关权限

四：表结构设计

　　数据库关联模型（待完善）

 

Django表结构实现

from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _  # 语言国际化
# from django.utils import timezone   # 开发国际软件时
# 395     date_joined = models.DateTimeField( verbose_name="创建时间", default=timezone.now )

from django.utils.safestring import mark_safe
from django.db import models
from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser,PermissionsMixin
)

class UserProFileManager(BaseUserManager):
    def create_user(self, email, name, password=None):
        """
        Creates and saves a User with the given email, name and password.
        """
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            email=self.normalize_email(email),  #验证邮箱格式
            name=name,
        )

        user.set_password(password)  #加密
        user.save(using=self._db)
        return user

    def create_superuser(self, email, name, password):
        """
        Creates and saves a superuser with the given email, name and password.
        """
        user = self.create_user(
            email,
            password=password,
            name=name,
        )
        user.is_superuser = True
        user.save(using=self._db)
        return user

class UserProFile(AbstractBaseUser,PermissionsMixin):
    """
    用户信息表
        含有销售、讲师、管理员人员
    使用自定义用户认证
    """
    email = models.EmailField(
        verbose_name='email address',
        max_length=255,
        unique=True,
        blank=True,
        null=True
    )
    password = models.CharField(  #重写Admin密码，修改
        _('password'),
        max_length=128,
        help_text=mark_safe("<a class='btn-link'href='password'>重置密码</a>"),
    )
    name = models.CharField(max_length=32, verbose_name='姓名')
    role = models.ManyToManyField('Role', null=True, blank=True)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=True)
    is_superuser = models.BooleanField(default=False)

    # ————————60PerfectCRM实现CRM学生上课记录————————
    # stu_account = models.ForeignKey("Customer",
    #                                 verbose_name='关联学员帐号',
    #                                 blank=True,
    #                                 null=True,
    #                                 on_delete=models.CASCADE,
    #                                 help_text = '报名成功后创建关联帐户' )
    # ————————60PerfectCRM实现CRM学生上课记录————————

    objects = UserProFileManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['name']

    def get_full_name(self):
        # The user is identified by their email address
        return self.email

    def get_short_name(self):
        # The user is identified by their email address
        return self.email

    def __str__(self):              # __unicode__ on Python 2
        return self.email

    class Meta:
        # verbose_name = 'CRM账户'
        verbose_name_plural = 'CRM账户'
        permissions = (
            ('crm_table_list', '可以查看kingadmin所有表的数据'),
            ('crm_table_list_view', '可以查看kingadmin所有表里数据的修改页'),
            ('crm_table_list_change', '可以修改kingadmin所有表数据'),
            ('crm_table_list_add_view', '可以查看kingadmin所有表添加页'),
            ('crm_table_list_add', '可以在kingadmin所有表添加数据'),
            ('crm_personal_password_reset_view', '可以在kingadmin查看自己的秘密修改页'),
            ('crm_personal_password_reset', '可以在kingadmin修改自己的密码'),
        )

# ————————74PerfectCRM实现CRM权限和权限组限制URL————————
"""
    class Meta:
        verbose_name_plural = '10CRM账户表'
        permissions = (
            ('crm_010101_all_table_data_list_GET', '010101_全部查看数据_GET'),
            ('crm_010102_all_table_data_list_POST', '010102_全部查看数据_POST'),
            ('crm_010103_all_table_add_GET', '010103_全部添加数据_GET'),
            ('crm_010104_all_table_add_POST', '010104_全部添加数据_POST'),
            ('crm_010105_all_table_change_GET', '010105_全部修改数据_GET'),
            ('crm_010106_all_table_change_POST', '010106_全部修改数据_POST'),
            ('crm_010107_all_table_delete_GET', '010107_全部删除数据_GET'),
            ('crm_010108_all_table_delete_POST', '010108_全部删除数据_POST'),
            ('crm_010109_all_password_reset_GET', '010109_全部密码重置_GET'),
            ('crm_010110_all_password_reset_POST', '010110_全部密码重置_POST'),

            ('crm_010201_only_view_Branch_GET', '010201_只能查看校区表_GET'),
            ('crm_010202_only_view_Branch_POST', '010202_只能查看校区表_POST'),
            ('crm_010203_only_add_Branch_GET', '010203_只能添加校区表_GET'),
            ('crm_010204_only_add_Branch_POST', '010204_只能添加校区表_POST'),
            ('crm_010205_only_change_Branch_GET', '010205_只能修改校区表_GET'),
            ('crm_010206_only_change_Branch_POST', '010206_只能修改校区表_POST'),
            ('crm_010207_only_delete_Branch_GET', '010207_只能删除校区表_GET'),
            ('crm_010208_only_delete_Branch_POST', '010208_只能删除校区表_POST'),

            ('crm_010301_only_view_ClassList_GET', '010301_只能查看班级表_GET'),
            ('crm_010302_only_view_ClassList_POST', '010302_只能查看班级表_POST'),
            ('crm_010303_only_add_ClassList_GET', '010303_只能添加班级表_GET'),
            ('crm_010304_only_add_ClassList_POST', '010304_只能添加班级表_POST'),
            ('crm_010305_only_change_ClassList_GET', '010305_只能修改班级表_GET'),
            ('crm_010306_only_change_ClassList_POST', '010306_只能修改班级表_POST'),
            ('crm_010307_only_delete_ClassList_GET', '010307_只能删除班级表_GET'),
            ('crm_010308_only_delete_ClassList_POST', '010308_只能删除班级表_POST'),

            ('crm_010401_only_view_Course_GET', '010401_只能查看课程表_GET'),
            ('crm_010402_only_view_Course_POST', '010402_只能查看课程表_POST'),
            ('crm_010403_only_add_Course_GET', '010403_只能添加课程表_GET'),
            ('crm_010404_only_add_Course_POST', '010404_只能添加课程表_POST'),
            ('crm_010405_only_change_Course_GET', '010405_只能修改课程表_GET'),
            ('crm_010406_only_change_Course_POST', '010406_只能修改课程表_POST'),
            ('crm_010407_only_delete_Course_GET', '010407_只能删除课程表_GET'),
            ('crm_010408_only_delete_Course_POST', '010408_只能删除课程表_POST'),

            ('crm_010501_only_view_Customer_GET', '010501_只能查看客户表_GET'),
            ('crm_010502_only_view_Customer_POST', '010502_只能查看客户表_POST'),
            ('crm_010503_only_add_Customer_GET', '010503_只能添加客户表_GET'),
            ('crm_010504_only_add_Customer_POST', '010504_只能添加客户表_POST'),
            ('crm_010505_only_change_Customer_GET', '010505_只能修改客户表_GET'),
            ('crm_010506_only_change_Customer_POST', '010506_只能修改客户表_POST'),
            ('crm_010507_only_delete_Customer_GET', '010507_只能删除客户表_GET'),
            ('crm_010508_only_delete_Customer_POST', '010508_只能删除客户表_POST'),

            ('crm_010601_only_view_CustomerFollowUp_GET', '010601_只能查看跟进表_GET'),
            ('crm_010602_only_view_CustomerFollowUp_POST', '010602_只能查看跟进表_POST'),
            ('crm_010603_only_add_CustomerFollowUp_GET', '010603_只能添加跟进表_GET'),
            ('crm_010604_only_add_CustomerFollowUp_POST', '010604_只能添加跟进表_POST'),
            ('crm_010605_only_change_CustomerFollowUp_GET', '010605_只能修改跟进表_GET'),
            ('crm_010606_only_change_CustomerFollowUp_POST', '010606_只能修改跟进表_POST'),
            ('crm_010607_only_delete_CustomerFollowUp_GET', '010607_只能删除跟进表_GET'),
            ('crm_010608_only_delete_CustomerFollowUp_POST', '010608_只能删除跟进表_POST'),

            ('crm_010701_only_view_Enrollment_GET', '010701_只能查看报名表_GET'),
            ('crm_010702_only_view_Enrollment_POST', '010702_只能查看报名表_POST'),
            ('crm_010703_only_add_Enrollment_GET', '010703_只能添加报名表_GET'),
            ('crm_010704_only_add_Enrollment_POST', '010704_只能添加报名表_POST'),
            ('crm_010705_only_change_Enrollment_GET', '010705_只能修改报名表_GET'),
            ('crm_010706_only_change_Enrollment_POST', '010706_只能修改报名表_POST'),
            ('crm_010707_only_delete_Enrollment_GET', '010707_只能删除报名表_GET'),
            ('crm_010708_only_delete_Enrollment_POST', '010708_只能删除报名表_POST'),

            ('crm_010801_only_view_Payment_GET', '010801_只能查看缴费表_GET'),
            ('crm_010802_only_view_Payment_POST', '010802_只能查看缴费表_POST'),
            ('crm_010803_only_add_Payment_GET', '010803_只能添加缴费表_GET'),
            ('crm_010804_only_add_Payment_POST', '010804_只能添加缴费表_POST'),
            ('crm_010805_only_change_Payment_GET', '010805_只能修改缴费表_GET'),
            ('crm_010806_only_change_Payment_POST', '010806_只能修改缴费表_POST'),
            ('crm_010807_only_delete_Payment_GET', '010807_只能删除缴费表_GET'),
            ('crm_010808_only_delete_Payment_POST', '010808_只能删除缴费表_POST'),

            ('crm_010901_only_view_CourseRecord_GET', '010901_只能查看上课表_GET'),
            ('crm_010902_only_view_CourseRecord_POST', '010902_只能查看上课表_POST'),
            ('crm_010903_only_add_CourseRecord_GET', '010903_只能添加上课表_GET'),
            ('crm_010904_only_add_CourseRecord_POST', '010904_只能添加上课表_POST'),
            ('crm_010905_only_change_CourseRecord_GET', '010905_只能修改上课表_GET'),
            ('crm_010906_only_change_CourseRecord_POST', '010906_只能修改上课表_POST'),
            ('crm_010907_only_delete_CourseRecord_GET', '010907_只能删除上课表_GET'),
            ('crm_010908_only_delete_CourseRecord_POST', '010908_只能删除上课表_POST'),

            ('crm_011001_only_view_StudyRecord_GET', '011001_只能查看学习表_GET'),
            ('crm_011002_only_view_StudyRecord_POST', '011002_只能查看学习表_POST'),
            ('crm_011003_only_add_StudyRecord_GET', '011003_只能添加学习表_GET'),
            ('crm_011004_only_add_StudyRecord_POST', '011004_只能添加学习表_POST'),
            ('crm_011005_only_change_StudyRecord_GET', '011005_只能修改学习表_GET'),
            ('crm_011006_only_change_StudyRecord_POST', '011006_只能修改学习表_POST'),
            ('crm_011007_only_delete_StudyRecord_GET', '011007_只能删除学习表_GET'),
            ('crm_011008_only_delete_StudyRecord_POST', '011008_只能删除学习表_POST'),

            ('crm_011101_only_view_UserProfile_GET', '011101_只能查看账号表_GET'),
            ('crm_011102_only_view_UserProfile_POST', '011102_只能查看账号表_POST'),
            ('crm_011103_only_add_UserProfile_GET', '011103_只能添加账号表_GET'),
            ('crm_011104_only_add_UserProfile_POST', '011104_只能添加账号表_POST'),
            ('crm_011105_only_change_UserProfile_GET', '011105_只能修改账号表_GET'),
            ('crm_011106_only_change_UserProfile_POST', '011106_只能修改账号表_POST'),
            ('crm_011107_only_delete_UserProfile_GET', '011107_只能删除账号表_GET'),
            ('crm_011108_only_delete_UserProfile_POST', '011108_只能删除账号表_POST'),

            ('crm_011201_only_view_Role_GET', '011201_只能查看角色表_GET'),
            ('crm_011202_only_view_Role_POST', '011202_只能查看角色表_POST'),
            ('crm_011203_only_add_Role_GET', '011203_只能添加角色表_GET'),
            ('crm_011204_only_add_Role_POST', '011204_只能添加角色表_POST'),
            ('crm_011205_only_change_Role_GET', '011205_只能修改角色表_GET'),
            ('crm_011206_only_change_Role_POST', '011206_只能修改角色表_POST'),
            ('crm_011207_only_delete_Role_GET', '011207_只能删除角色表_GET'),
            ('crm_011208_only_delete_Role_POST', '011208_只能删除角色表_POST'),

            ('crm_011301_only_view_Tag_GET', '011301_只能查看标签表_GET'),
            ('crm_011302_only_view_Tag_POST', '011302_只能查看标签表_POST'),
            ('crm_011303_only_add_Tag_GET', '011303_只能添加标签表_GET'),
            ('crm_011304_only_add_Tag_POST', '011304_只能添加标签表_POST'),
            ('crm_011305_only_change_Tag_GET', '011305_只能修改标签表_GET'),
            ('crm_011306_only_change_Tag_POST', '011306_只能修改标签表_POST'),
            ('crm_011307_only_delete_Tag_GET', '011307_只能删除标签表_GET'),
            ('crm_011308_only_delete_Tag_POST', '011308_只能删除标签表_POST'),

            ('crm_011401_only_view_FirstLayerMenu_GET', '011401_只能查看一层菜单_GET'),
            ('crm_011402_only_view_FirstLayerMenu_POST', '011402_只能查看一层菜单_POST'),
            ('crm_011403_only_add_FirstLayerMenu_GET', '011403_只能添加一层菜单_GET'),
            ('crm_011404_only_add_FirstLayerMenu_POST', '011404_只能添加一层菜单_POST'),
            ('crm_011405_only_change_FirstLayerMenu_GET', '011405_只能修改一层菜单_GET'),
            ('crm_011406_only_change_FirstLayerMenu_POST', '011406_只能修改一层菜单_POST'),
            ('crm_011407_only_delete_FirstLayerMenu_GET', '011407_只能删除一层菜单_GET'),
            ('crm_011408_only_delete_FirstLayerMenu_POST', '011408_只能删除一层菜单_POST'),

            ('crm_011501_only_view_SubMenu_GET', '011501_只能查看二层菜单_GET'),
            ('crm_011502_only_view_SubMenu_POST', '011502_只能查看二层菜单_POST'),
            ('crm_011503_only_add_SubMenu_GET', '011503_只能添加二层菜单_GET'),
            ('crm_011504_only_add_SubMenu_POST', '011504_只能添加二层菜单_POST'),
            ('crm_011505_only_change_SubMenu_GET', '011505_只能修改二层菜单_GET'),
            ('crm_011506_only_change_SubMenu_POST', '011506_只能修改二层菜单_POST'),
            ('crm_011507_only_delete_SubMenu_GET', '011507_只能删除二层菜单_GET'),
            ('crm_011508_only_delete_SubMenu_POST', '011508_只能删除二层菜单_POST'),

            ('crm_011601_only_view_Groups_GET', '011601_只能查看权限组_GET'),
            ('crm_011602_only_view_Groups_POST', '011602_只能查看权限组_POST'),
            ('crm_011603_only_add_Groups_GET', '011603_只能添加权限组_GET'),
            ('crm_011604_only_add_Groups_POST', '011604_只能添加权限组_POST'),
            ('crm_011605_only_change_Groups_GET', '011605_只能修改权限组_GET'),
            ('crm_011606_only_change_Groups_POST', '011606_只能修改权限组_POST'),
            ('crm_011607_only_delete_Groups_GET', '011607_只能删除权限组_GET'),
            ('crm_011608_only_delete_Groups_POST', '011608_只能删除权限组_POST'),

            ('crm_011701_own_password_reset_GET', '011701_自己密码重置_GET'),
            ('crm_011702_own_password_reset_POST', '011702_自己密码重置_POST'),

            ('crm_020101_all_not_audit_GET', '020101_销售查看全部的客户未审核_GET'),
            ('crm_020103_all_enrollment_GET', '020103_销售给全部的客户报名课程_GET'),
            ('crm_020104_all_enrollment_POST', '020104_销售给全部的客户报名课程_POST'),
            ('crm_020105_all_contract_review_GET', '020105_销售给全部的客户审核合同_GET'),
            ('crm_020116_all_contract_review_POST', '020116_销售给全部的客户审核合同_POST'),

            ('crm_020201_own_enrollment_GET', '020201_销售给自己的客户报名课程_GET'),
            ('crm_020202_own_enrollment_POST', '020202_销售给自己的客户报名课程_POST'),
            ('crm_020203_own_contract_review_GET', '020203_销售给自己的客户审核合同_GET'),
            ('crm_020204_own_contract_review_POST', '020204_销售给自己的客户审核合同_POST'),

            ('crm_030101_all_not_payment_GET', '030101_财务查看全部的客户未缴费_GET'),
            ('crm_030102_all_not_payment_POST', '030102_财务查看全部的客户未缴费_POST'),
            ('crm_030103_all_already_payment_GET', '030103_财务查看全部的客户已缴费_GET'),
            ('crm_030104_all_already_payment_POST', '030104_财务查看全部的客户已缴费_POST'),
            ('crm_030105_all_payment_GET', '030105_财务进行全部的客户缴费_GET'),
            ('crm_030106_all_payment_POST', '030106_财务进行全部的客户缴费_POST'),

            ('crm_040101_own_student_course_GET', '040101_学生查看自己的课程_GET'),
            ('crm_040102_own_student_course_POST', '040102_学生查看自己的课程_POST'),
            ('crm_040103_own_studyrecords_GET', '040103_学生自己的上课记录_GET'),
            ('crm_040104_own_studyrecords_POST', '040104_学生自己的上课记录_POST'),
            ('crm_040105_own_homework_detail_GET', '040105_学生自己的作业详情_GET'),
            ('crm_040106_own_homework_detail_POST', '040106_学生自己的作业详情_POST'),

            ('crm_050101_own_teacher_class_GET', '050101_讲师查看自己的班级_GET'),
            ('crm_050102_own_teacher_class_POST', '050102_讲师查看自己的班级_POST'),
            ('crm_050103_own_teacher_class_detail_GET', '050103_讲师查看自己的课节详情_GET'),
            ('crm_050104_own_teacher_class_detail_POST', '050104_讲师查看自己的课节详情_POST'),
            ('crm_050105_own_teacher_lesson_detail_GET', '050105_讲师查看自己的课节学员_GET'),
            ('crm_050106_own_teacher_lesson_detail_POST', '050106_讲师查看自己的课节学员_POST'),
            ('crm_050107_own_howk_down_GET', '050107_讲师自己的学员作业下载_GET'),
            ('crm_050108_own_howk_down_POST', '050108_讲师自己的学员作业下载_POST'),

            ('crm_060101_own_coursetop_details_GET', '060101_讲师查看自己的班级排名详情_GET'),
            ('crm_060102_own_coursetop_details_POST', '060102_讲师查看自己的班级排名详情_POST'),
            ('crm_060103_own_coursetop_score_GET', '060103_讲师查看自己的班级分数排行_GET'),
            ('crm_060104_own_coursetop_score_POST', '060104_讲师查看自己的班级排分数排行_POST'),
            ('crm_060105_own_coursetop_homework_GET', '060105_讲师查看自己的班级作业排行_GET'),
            ('crm_060106_own_coursetop_homework_POST', '060106_讲师查看自己的班级作业排行_POST'),
            ('crm_060107_own_coursetop_attendance_GET', '060107_讲师查看自己的班级出勤排行_GET'),
            ('crm_060108_own_coursetop_attendance_POST', '060108_讲师查看自己的班级出勤排行_POST'),

        )
# ————————74PerfectCRM实现CRM权限和权限组限制URL————————
# ————————74PerfectCRM实现CRM权限和权限组限制URL————————
'''15权限组'''
from django.contrib.auth.models import Group
class Groups(Group):
    class Meta:
        verbose_name_plural = '15权限组'
# ————————74PerfectCRM实现CRM权限和权限组限制URL————————
# ————————75PerfectCRM实现CRM扩展权限————————
from django.contrib.auth.models import Permission
class Permissions(Permission):
    dic_name = models.CharField(_('dic_name'), max_length=255)
    class Meta:
        verbose_name_plural = "16扩展权限"
# ————————75PerfectCRM实现CRM扩展权限————————
"""


"""自带验证"""
# class UserProFile(models.Model):
#     """用户信息表"""
#     user = models.OneToOneField(User,on_delete=models.CASCADE)
#     name = models.CharField(max_length=32, verbose_name='姓名')
#     role = models.ManyToManyField('Role',null=True,blank=True)
#
#     class Meta:
#         verbose_name = '用户信息表'
#         verbose_name_plural = '用户信息表'
#
#     def __str__(self):  # __unicode__
#         return self.name

class Role(models.Model):
    """角色表"""
    name = models.CharField(max_length=64,unique=True)
    menus = models.ManyToManyField('Menus', verbose_name='菜单',blank=True)

    class Meta:
        verbose_name = '角色表'
        verbose_name_plural = '角色表'

    def __str__(self):
        return self.name

class CustomerInfo(models.Model):
    """客户信息"""
    name = models.CharField(max_length=32,default=None)  #CharField定长文本
    contact_type_choices = (
        (0,'qq'),
        (1,'微信'),
        (2,'手机'),
    )
    contact_type = models.SmallIntegerField(choices=contact_type_choices,default=0)
    contact = models.CharField(max_length=64,unique=True)
    source_choices = (
        (0,'QQ群'),
        (1,'51CTO'),
        (2,'百度推广'),
        (3,'知乎'),
        (4,'转介绍'),
        (5,'其他'),
    )
    source = models.SmallIntegerField(choices=source_choices)
    referral_from = models.ForeignKey('self',null=True,blank=True,verbose_name='转介绍',on_delete=models.CASCADE)

    consult_courses = models.ManyToManyField('Course',verbose_name='咨询课程')
    consult_content = models.TextField(verbose_name='咨询内容')   #TextField无限制长度的文本
    status_choices = (
        (0,'未报名'),
        (1,'已报名'),
        (2,'已退学'),
    )
    status = models.SmallIntegerField(choices=status_choices)
    consultant = models.ForeignKey('UserProFile',verbose_name='课程顾问',on_delete=models.CASCADE)
    id_num = models.CharField(max_length=128,blank=True,null=True)
    emergency_contact = models.PositiveIntegerField(blank=True,null=True)
    sex_choice = (
        (0,'Man'),
        (1,'Woman'),
    )
    sex = models.SmallIntegerField(choices=sex_choice)
    date = models.DateField(auto_now_add=True)

    class Meta:
        verbose_name = '客户信息表'
        verbose_name_plural = '客户信息表'

    def __str__(self):
        return self.name

class Student(models.Model):
    """学员表（已报名的客户）"""
    customer = models.OneToOneField('CustomerInfo',on_delete=models.CASCADE)
    class_grade = models.ManyToManyField('ClassList')

    class Meta:
        verbose_name = '学员表'
        verbose_name_plural = '学员表'

    def __str__(self):
        return self.customer.name

class CustomerFollowUp(models.Model):
    """客户跟踪记录表"""
    customer = models.ForeignKey('CustomerInfo',on_delete=models.CASCADE)
    content = models.TextField(verbose_name='跟踪内容')
    user = models.ForeignKey('UserProFile',verbose_name='跟进人',on_delete=models.CASCADE)
    status_choices = (
        (0,'近期无报名计划'),
        (1,'一个月内报名'),
        (2,'2周内报名'),
        (3,'已报名'),
    )
    status = models.SmallIntegerField(choices=status_choices)
    date = models.DateField(auto_now_add=True)

    class Meta:
        verbose_name = '客户跟踪记录表'
        verbose_name_plural = '客户跟踪记录表'

    def __str__(self):
        return self.content

class Course(models.Model):
    """课程表"""
    name = models.CharField(verbose_name='课程名称',max_length=64,unique=True)
    price = models.PositiveSmallIntegerField()   # 必须为正
    period = models.PositiveSmallIntegerField(verbose_name='课程周期（月）',default=5)
    outline = models.TextField(verbose_name='大纲')

    class Meta:
        verbose_name = '课程表'
        verbose_name_plural = '课程表'

    def __str__(self):
        return self.name

class ClassList(models.Model):
    """班级列表"""
    branch = models.ForeignKey('Branch',on_delete=models.CASCADE)
    # CASCADE从父表删除或更新且自动删除或更新子表中匹配的行
    course = models.ForeignKey('Course',on_delete=models.CASCADE)
    contract = models.ForeignKey('ContractTemplate',blank=True,null=True,on_delete=models.CASCADE)
    class_type_choices = (  #choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
        (0,'脱产'),
        (1,'周末'),
        (2,'网络班')
    )
    class_type = models.SmallIntegerField(choices=class_type_choices)
    semester = models.SmallIntegerField(verbose_name='学期')
    teachers = models.ManyToManyField('UserProFile',verbose_name='讲师')
    start_date = models.DateField('开班日期')
    graduate_date = models.DateField('毕业日期',blank=True,null=True)

    class Meta:
        verbose_name = '班级列表'
        verbose_name_plural = '班级列表'
        unique_together = (
            'course',
            'semester',
            'branch',
            'class_type',
        )

    def __str__(self):
        return '%s(%s)期' %(self.course.name, self.semester)

class CourseRecord(models.Model):
    """上课记录"""
    class_grade = models.ForeignKey('ClassList',verbose_name='上课班级',on_delete=models.CASCADE)
    day_num = models.PositiveSmallIntegerField('课程节次')
    teacher = models.ForeignKey('UserProFile',on_delete=models.CASCADE)
    title = models.CharField('本节主题',max_length=64)
    content = models.TextField('本节内容')
    has_homework = models.BooleanField('本节有作业',default=True)
    homework = models.TextField('作业需求',blank=True,null=True)
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name = '上课记录'
        verbose_name_plural = '上课记录'
        unique_together = (
            'class_grade',
            'day_num',
        )

    def __str__(self):
        return '%s第(%s)节' %(self.class_grade, self.day_num)

class StudyRecord(models.Model):
    """学习记录"""
    course_record = models.ForeignKey('CourseRecord',on_delete=models.CASCADE)
    student = models.ForeignKey('Student',on_delete=models.CASCADE)

    score_choices = (
        (100,'A+'),
        (90,'A'),
        (85,'B+'),
        (80,'B'),
        (75,'B-'),
        (70,'C+'),
        (60,'C'),
        (40,'C-'),
        (-50,'D'),
        (0,'N/A'), # not avaliable
        (-100,'COPY'),
    )
    score = models.SmallIntegerField(verbose_name='成绩',choices=score_choices,default=0)
    show_choices = (
        (0,'缺勤'),
        (1,'已签到'),
        (2,'迟到'),
        (3,'早退'),
    )
    show_status = models.SmallIntegerField(choices=show_choices)
    note = models.TextField('成绩备注',blank=True,null=True)
    date = models.DateTimeField(auto_now_add=True)

    # ————————63PerfectCRM实现CRM讲师下载作业————————
    # delivery = models.BooleanField(default=False, verbose_name="交作业")  # 有没有交付作业
    # ————————63PerfectCRM实现CRM讲师下载作业————————
    # ————————61PerfectCRM实现CRM学生上传作业————————
    #  作业链接 #TextField无限制长度的文本#Django可空#数据库可以为空
    # homework_link = models.TextField(blank=True, null=True)
    # ————————61PerfectCRM实现CRM学生上传作业————————

    class Meta:
        verbose_name = '学习记录'
        verbose_name_plural = '学习记录'

    def __str__(self):
        return '%s %s %s'  %(self.course_record,self.student,self.score)

class Branch(models.Model):
    """校区"""
    name = models.CharField(max_length=64,unique=True)
    addr = models.CharField(max_length=128,blank=True,null=True)

    class Meta:  #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name = '校区'
        verbose_name_plural = '校区'  #verbose_name_plural给你的模型类起一个更可读的名字

    # __str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值
    def __str__(self):
        return self.name

class Menus(models.Model):
    """动态菜单"""
    name = models.CharField('菜单名',max_length=32)
    url_type_choices = (
        (0,'absolute'),
        (1,'dynamic'),
    )
    url_type = models.SmallIntegerField(choices=url_type_choices,default=0)
    url_name = models.CharField('连接',max_length=128)


    class Meta:
        verbose_name = '菜单'
        verbose_name_plural = '菜单'
        unique_together = ('name','url_name')

    def __str__(self):
        return self.name

# ————————72PerfectCRM实现CRM动态菜单和角色————————
'''
"""13一层菜单名"""
class FirstLayerMenu(models.Model):
    """第一层侧边栏菜单"""
    name = models.CharField('一层菜单名',max_length=64)
    url_type_choices = ((0,'相关的名字'),(1,'固定的URL'))
    url_type = models.SmallIntegerField(choices=url_type_choices,default=0)
    url_name = models.CharField(max_length=64,verbose_name='一层菜单路径')
    order = models.SmallIntegerField(default=0,verbose_name='菜单排序')
    sub_menus = models.ManyToManyField('SubMenu',blank=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = "13第一层菜单"

"""14二层菜单名"""
class SubMenu(models.Model):
    """第二层侧边栏菜单"""
    name = models.CharField('二层菜单名', max_length=64)
    url_type_choices = ((0,'相关的名字'),(1,'固定的URL'))
    url_type = models.SmallIntegerField(choices=url_type_choices,default=0)
    url_name = models.CharField(max_length=64, verbose_name='二层菜单路径')
    order = models.SmallIntegerField(default=0, verbose_name='菜单排序')

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = "14第二层菜单"
'''
# ————————72PerfectCRM实现CRM动态菜单和角色————————

class ContractTemplate(models.Model):
    """存储合同模板"""
    name = models.CharField(max_length=64)
    content = models.TextField()
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name = '合同'
        verbose_name_plural = '合同'

    def __str__(self):
        return self.name

class StudentEnrollment(models.Model):
    """学员报名表"""
    customer = models.ForeignKey('CustomerInfo',on_delete=models.CASCADE)
    consultant = models.ForeignKey('UserProFile',on_delete=models.CASCADE)
    class_grade = models.ForeignKey('ClassList',on_delete=models.CASCADE)

    contract_agreed = models.BooleanField(default=False,verbose_name="学员已经同意合同")  #学员看合同
    contract_signed_date = models.DateTimeField('合同签订时间',blank=True,null=True)
    contract_approved = models.BooleanField(default=False,verbose_name="合同已经审核")  #谁审核
    contract_approved_date = models.DateTimeField('合同审核时间',blank=True, null=True)

    # ————————53PerfectCRM实现CRM客户报名流程缴费————————
    # Pay_cost = models.BooleanField(default=False, verbose_name="缴费")  # 缴费状态#是不是交定金
    # ————————53PerfectCRM实现CRM客户报名流程缴费————————

    class Meta:
        verbose_name = '学员报名表'
        verbose_name_plural = '学员报名表'
        unique_together = ('customer','class_grade')

    def __str__(self):
        return self.customer.name

class PaymentRecord(models.Model):
    """存储学员缴费记录"""
    enrollment = models.ForeignKey('StudentEnrollment',on_delete=models.CASCADE)
    payment_type_choice = (
        (0,'报名费'),
        (1,'学费'),
        (2,'退费'),
    )
    payment_type = models.SmallIntegerField(choices=payment_type_choice,default=0)
    amount = models.IntegerField('费用',default=500)
    consultant = models.ForeignKey('UserProFile', on_delete=models.CASCADE)
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name = '学员缴费记录'
        verbose_name_plural = '学员缴费记录'

    def __str__(self):
        return self.enrollment
    

 Day2:主要实现功能kingadmin为各个应用实现一个类似于Django自带的数据库管理功能　　　　　

　　kingadmin目录　　　　　　　　

　　　　销售目录

　　　　学员目录

1.首先我们需要在项目启动后（进入Kingadmin模块中view视图后，能够自动采集所有的应用中需要我们采集的数据库信息）

 （1）先设置采集方法：在每个需要我们采集的应用模块中添加上kingadmin.py文件（类似于后台admin会在应用模块的admin.py中采集信息一样）。如上面目录结构，在其中添加了kingadmin.py

from crm import models
"""
虽然说，每个APP：
    sale，student都去导入了一次site，
    但是在python项目中对于同一个模块只会导入一次，
    所以这本身就是单例模式（使用的是内存中存在的那个）
"""
from kingadmin.sites import site
from kingadmin.admin_base import BaseKingAdmin
from crm.forms import UserChangeForm,UserCreationForm

# 1
print("Sale.kingadmin")

class UserProFileAdmin(BaseKingAdmin):
    # The forms to add and change user instances
    form = UserChangeForm
    add_form = UserCreationForm

    # The fields to be used in displaying the User model.
    # These override the definitions on the base UserAdmin
    # that reference specific fields on auth.User.
    list_display = ('email', 'name', 'is_superuser')
    list_filter = ('is_superuser',)
    fieldsets = (
        (None, {'fields': ('email', 'password')}),
        ('Personal info', {'fields': ('name',)}),
        ('Permissions', {'fields': ('is_active','is_staff','is_superuser','role','user_permissions','groups',)}),
    )
    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
    # overrides get_fieldsets to use this attribute when creating a user.
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'name', 'password1', 'password2')}
        ),
    )
    search_fields = ('email',)
    ordering = ('email',)
    filter_horizontal = ('role','groups','user_permissions')
    readonly_fields = ['password']

class CustomerAdmin(BaseKingAdmin):
    list_display = ['name', 'source', 'contact_type', 'contact', 'consultant', 'consult_content', 'status', 'date']
    list_filter = ['source', 'consultant', 'status', 'date']
    search_fields = ['name','contact','source']
    readonly_fields = ['contact','status']
    filter_horizontal = ['consult_courses']
    actions = ['change_status', ]

    def change_status(self, request, querysets):
        print(self, request, querysets)
        querysets.update(status=0)

site.register(models.CustomerInfo,CustomerAdmin)
site.register(models.Menus)
site.register(models.UserProFile,UserProFileAdmin)
site.register(models.StudyRecord)
site.register(models.CustomerFollowUp)
site.register(models.Course)
site.register(models.ClassList)
site.register(models.CourseRecord)

===================

from student import models
from kingadmin.sites import site
from kingadmin.admin_base import BaseKingAdmin

print("Student.kingadmin")

class TestAdmin(BaseKingAdmin):
    list_display = ['name']

site.register(models.Test,TestAdmin)

从中发现需要用到一个基类BaseKingAdmin来自于kingadmin模块：是为了防止注册事件时出现为空的现象，而且在基类中添加功能更加方便

 

from django.shortcuts import render
import json

class BaseKingAdmin(object):
    def __init__(self):
        self.actions.extend(self.default_action)
    list_display = []
    list_filter = []
    search_fields = []
    readonly_fields = []
    filter_horizontal = []
    list_per_page = 10
    default_action = ['delete_selected_objs']
    actions = []

    def delete_selected_objs(self,request,querysets):
        print('delete_selected_objs',self,request,querysets)

        queryset_ids = json.dumps([i.id for i in querysets])  # 获取所有id
        return render(request, 'kingadmin/table_obj_delete.html',{
            'selected_objs':querysets,
            'admin_class':self,
            'queryset_ids':queryset_ids,
        })

还需要from kingadmin.sites import site，使用到site方法（类似于admin.site.register(模型，自定义模型显示类)）：功能是将各个模块中的数据模型统一添加在一个数据结构中，方便调用

from kingadmin.admin_base import BaseKingAdmin

class AdminSite(object):
    def __init__(self):
        self.enabled_admins = {}

    def register(self,model_class,admin_class=None):
        """注册admin表"""
        # 根据model中类名获取APP名
        app_name = model_class._meta.app_label
        # 根据model中类名获取表名，类名的小写
        model_name = model_class._meta.model_name

        # 不传值时默认BaseKingAdmin，并实例化
        if not admin_class:
            admin_class = BaseKingAdmin()
        else:
            # 每次实例化，防止使用同一内存地址
            admin_class = admin_class()
        # admin_class为对象才能 .model添加存入对象
        admin_class.model = model_class  # 把model_class赋值给admin_class为了能关联起来
        if app_name not in self.enabled_admins:
            self.enabled_admins[app_name] = {}
        self.enabled_admins[app_name][model_name] = admin_class

        # 2
        # print(model_class,admin_class)

site = AdminSite()   # 只实例化一次，后面的导入为调用对象

将数据统一放入self.enabled_admins{}中，形式为self.enabled_admins[模块][表名] = 自定义模型显示类（默认BaseKingAdmin）

注意：虽然在每个模块中都导入了一次sites模块，使用一次site对象，实际上使用的是同一个site对象

可以使用id(site)查看内存，因为python机制中将一个模块导入后，会将其保存在内存中，下次导入数据的时候，会直接从内存中获取数据（所以大家使用的是一个site对象）
所以说：python模块本身就是单例模式

 （2）从settings.py中获取各个模块。创建app_setup.py文件，在项目进入view时去调用该文件，并执行，获取到所有模块的信息

进入views.py自动调用app_setup.kingadmin_auto_discover()方法

from kingadmin.sites import site  #发现只导入模块一次，site对象只有一个

from kingadmin import app_setup
#用来导入所有含Kingadmin的模块，模块中会去调用相应的Kingadmin文件去注册事件
app_setup.kingadmin_auto_discover()

# 测试是否site只实例化一次
for k,v in site.enabled_admins.items():
    for model_name,admin_class in v.items():
        pass
        # print(model_name,id(admin_class))

看如何采集各个模块信息：从配置文件中settings的INSTALLED_APPS中获取所有模块信息

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'repository.apps.RepositoryConfig',
    'kingadmin',
    'Student',
    'Sale',
]

views调用了app_setup中的kingadmin_auto_discover()方法自动采集信息，下面看看app_setup文件：实现方法。反向查找 

from django import conf　　#实现动态获取配置文件，而不是以目录形式
import importlib

def kingadmin_auto_discover():
    for module in conf.settings.INSTALLED_APPS:
        try:
            # md = importlib.import_module('.kingadmin',module)　　#这个也可以
            md = __import__('%s.kingadmin'%module)  #导入Kingadmin，然后回去执行该文件中的数据，去注册事件（模块导入后，会自动使用site.register方法注册事件）
        except ImportError as e:
            pass

（3）上面将数据采集完毕，把site对象传入模板中，使用app_index视图方法，可以实现后台管理admin首页功能

def app_index(request):return render(request,"kingadmin/app_index.html",{'site':site})

=====================================

{% extends 'kingadmin/index.html' %}
{% load kingadmin_tag %}
{% block right-content-container %}
    <h1 class="page-header">Site Administration</h1>

    <div>
        {% for app_name,app_tables in site.enabled_admins.items %}
        <table class="table table-striped">
            <thead>
                <tr class="info">
                    <th>{{app_name.upper}}</th>
                </tr>
            </thead>
            <tbody>
                {% for model_name,admin_class in app_tables.items %}
                <tr>
                    <td><a href="{% url 'table_obj_list' app_name model_name %}">{% get_model_verbose_name admin_class %}</a></td>
                    <td>
                        <a href="{{app_name}}/{{model_name}}/add">
                            <span class="glyphicon glyphicon-plus-sign" aria-hidden="true"></span>
                            增加
                        </a>
                        |
                        <a href="{{app_name}}/{{model_name}}">
                            <span class="glyphicon glyphicon-edit" aria-hidden="true"></span>
                            修改
                        </a>
                    </td>
                </tr>
                {% endfor %}
            </tbody>
        </table>
        {% endfor %}
    </div>

{% endblock %}

（4）实现点击表名，查看数据的功能

 

@check_permission
@login_required()
def table_obj_list(request,app_name,model_name):
    """取出指定model里的数据返回给前端"""
    admin_class = site.enabled_admins[app_name][model_name]

    if request.method == "POST":
        # print(request.POST)
        selected_action = request.POST.get('action')
        selected_ids = json.loads(request.POST.get('selected_ids'))

        if selected_action: # 如果有action参数代表为正常的action
            selected_objs = admin_class.model.objects.filter(id__in=selected_ids).all()
            admin_action_func = getattr(admin_class, selected_action)
            # print(admin_action_func,selected_objs)
            return admin_action_func(request,selected_objs)
        elif not selected_action:  # 如果没有action，代表可以是一个删除动作
            if selected_ids:  # 选中的数据都被删除
                admin_class.model.objects.filter(id__in=selected_ids).delete()

    # 调用函数过滤处理，并返回数据跟需过滤字段（用于选中）
    querysets,filter_conditions = get_filter_result(admin_class, request)
    # 把filter_conditions存入admin_class对象
    admin_class.filter_conditions = filter_conditions

    # 搜索，searched querysets
    querysets = get_search_result(request,admin_class,querysets)
    admin_class.search_key = request.GET.get('_q','')

    # 全局排序,分页前,sorted_querysets
    querysets, sorted_column = get_orderby_result(request, admin_class, querysets)

    paginator = Paginator(querysets, admin_class.list_per_page)  # Show 2 contacts per page
    page = request.GET.get('_page')
    querysets = paginator.get_page(page)

    return render(request, 'kingadmin/table_obj_list.html',{
        'querysets':querysets,
        'admin_class':admin_class,
        'sorted_column':sorted_column,
        'app_name':app_name,
        'model_name':model_name,
    })

 =====================

{% extends 'kingadmin/index.html' %}
{# 导入标签模块 #}
{% load kingadmin_tag %}  {# build_table_row' is not a registered tag library 重启即可 #}

{% block right-content-container %}
    <ol class="breadcrumb">
      <li><a href="/kingadmin/">Home</a></li>
      <li><a href="/kingadmin/{{app_name}}/">{{app_name.title}}</a></li>
      <li class="active">{% get_model_verbose_name admin_class %}</li>
    </ol>

    <h4 class="page-header">{{app_name.upper}} Administration</h4>

    <div class="row">
        <form>
            <div class="row">
              <div class="col-md-6">
                <div class="input-group">
                  <span class="input-group-btn">
                    <button class="btn btn-default" type="button">
                        <span class="glyphicon glyphicon-search" aria-hidden="true"></span>
                    </button>
                  </span>
                  <input type="search" class="form-control" name="_q" value="{{admin_class.search_key}}"
                       placeholder="{% for s in admin_class.search_fields %}{{s}}，{% endfor %}">
                </div>
              </div>
            <input class="btn btn-success" type="submit" value="Search">
            {% for k,v in admin_class.filter_conditions.items %}
                <input type="hidden" name="{{k}}" value="{{v}}">
            {% endfor %}
            </div>
        </form>
    </div>
<hr>
<div class="pull right">
    <h2><a href="add">ADD</a></h2>
</div>
<hr>
    <div class="row">
        {% if admin_class.list_filter %}
            <form class="navbar-form navbar-left">
                {% for filter_column in admin_class.list_filter %}
                    {% build_filter_ele filter_column admin_class %}
                {% endfor %}
                <input type="hidden" name="_o" value="{% get_current_sorted_column_index sorted_column %}">
                <input class="btn btn-success" type="submit" value="过滤">
            </form>
        {% endif %}
    </div>

    <form onsubmit="return ActionCheck(this);" method="post"> {% csrf_token %}
        <div class="row">
            <div class="col-lg-3">
                <select class="form-control" name="action">
                    <!--若无value则默认为值-&#45;&#45;&#45;&#45;，只有value=""值才为空 -->
                    <option value="">------------</option>
                    {% for action in admin_class.actions %}
                        <option value="{{action}}">{{action}}</option>
                    {% endfor %}
                </select>
           </div>
            <div class="col-lg-2">
                <input class="btn btn-success" type="submit" value="GO">
            </div>
        </div>
    </form>

    <div>
        <table class="table table-striped">
            <thead>
                <tr>
                    <th><input onclick="SelectAllObjs(this);" type="checkbox"></th>
                    {% if admin_class.list_display %}
                        {% for column in admin_class.list_display %}
                            {# counter0 从0开始，方便后台取列表数据 #}
                            <th>
                                <a href="?_o={% get_sorted_column column sorted_column forloop.counter0 %}{% render_filtered_args admin_class %}">
                                    {{column}}
                                    {% render_sorted_arrow column sorted_column %}
                                </a>
                            </th>
                        {% endfor %}
                    {% else %}
                        <!--还可以直接后台传入model_name-->
                        <th>{% get_model_name admin_class %}</th>
                    {% endif %}
                    <th>报名连接</th>
                </tr>
            </thead>
            <tbody>
                {% for obj in querysets %}
                    <tr>
                        <td><input row-select='true' type="checkbox" value="{{obj.id}}"></td>
                        {% build_table_row obj admin_class %}
                        <td><a href="{% url 'stu_enrollment' %}">连接</a></td>
                    </tr>
                {% endfor %}
            </tbody>
        </table>

        {% render_paginator querysets admin_class sorted_column %}

    </div>

<script>
    function ActionCheck(ele) {
        var selected_action = $("select[name='action']").val();
        var selected_objs = $('input[row-select]').filter(':checked');
        console.log(selected_action);
        if(!selected_action) {
            alert('no action selected!');
            // ?????
            return false
        }
        if(selected_objs.length == 0) {
            alert('no object selected!');
            return false
        }else{
            var selected_ids = [];
            $.each(selected_objs,function() {
                console.log($(this));
                selected_ids.push($(this).val());
            });
            console.log(selected_ids);
            // JSON.stringify(selected_ids)之后为字符串，无需再加引号
            var input_ele = '<input type="hidden" name="selected_ids" value=' + JSON.stringify(selected_ids) + '>'
            $(ele).append(input_ele);
        }
        // 返回则不提交数据
        //return false
    }


    function SelectAllObjs(ele) {
        if($(ele).prop('checked')) {
            $('input[row-select]').prop('checked',true);
        }else{
            $('input[row-select]').prop('checked',false);
        }
    }
</script>

{% endblock %}

前端使用了自定义模板函数

from django.template import Library
from django.utils.safestring import mark_safe
import datetime

register = Library()

@register.simple_tag
def build_table_row(obj,admin_class):
    """生成一条记录html element"""
    ele = ''
    if admin_class.list_display:
        for index,column_name in enumerate(admin_class.list_display):
            column_obj = admin_class.model._meta.get_field(column_name)
            if column_obj.choices:  # 判断字段是否为choice
                column_data = getattr(obj, 'get_%s_display' %column_name)()   # 获取choice的值
            else:
                column_data = getattr(obj, column_name)  # 反射
            if index == 0:
                ele += '<td><a href="%s/change">%s</a></td>' % (obj.id,column_data)
            else:
                ele += '<td>%s</td>' % column_data
    else:
        ele += '<td><a href="%s/change">%s</a></td>' % (obj.id,obj)   # 执行obj对象中的__str__方法
    return mark_safe(ele)

@register.simple_tag
def get_model_name(admin_class):
    """获取表名"""
    return admin_class.model._meta.model_name.upper()

@register.simple_tag
def build_filter_ele(filter_column,admin_class):
    """过滤"""
    #获取字段对象
    column_obj = admin_class.model._meta.get_field(filter_column)
    filter_column_ele = "<span>%s：</span>" % filter_column
    try:
        filter_select = '<div class="form-group">%s<select class="form-control" name=%s>' % (filter_column_ele,filter_column)
        for choice in column_obj.get_choices():
            selected = ''
            # if filter_column in admin_class.filter_conditions:  # 当前字段被过滤了
            if str(choice[0]) == admin_class.filter_conditions.get(filter_column):  # 当前值被选中
                selected = 'selected'
            option = "<option value='%s' %s>%s</option>" % (choice[0],selected,choice[1])
            filter_select += option
    except AttributeError as e:
        print('err',e)
        filter_select = '<div class="form-group">%s<select class="form-control" name=%s__gte>' % (filter_column_ele,filter_column)
        # 判断字段属性
        if column_obj.get_internal_type() in ('DateField','DateTimeField'):
            time_obj = datetime.datetime.now()
            time_list = [
                ['--------------',''],
                ['Today',time_obj],
                ['Past 7 day',time_obj-datetime.timedelta(7)],
                ['This month',time_obj.replace(day=1)],
                ['Past 3 month',time_obj-datetime.timedelta(90)],
                ['This year',time_obj.replace(month=1,day=1)],
                ['Any day',''],
            ]
            for i in time_list:
                selected = ''
                time_to_str = '' if not i[1] else '%s-%s-%s' %(i[1].year,i[1].month,i[1].day)
                if time_to_str == admin_class.filter_conditions.get('%s__gte' %filter_column):  # 当前值被选中
                    selected = 'selected'
                option = '<option value=%s %s>%s</option>' % (time_to_str,selected,i[0])
                filter_select += option

    filter_select += '</select></div>'
    return mark_safe(filter_select)

@register.simple_tag
def render_filtered_args(admin_class,render_html=True):
    """拼接筛选的字段"""
    ele = ''
    if admin_class.filter_conditions:
        for k,v in admin_class.filter_conditions.items():
            ele += '&%s=%s' %(k,v)
    return mark_safe(ele) if render_html else ele

@register.simple_tag
def render_paginator(querysets,admin_class,sorted_column):
    """分页"""
    # 保存排序状态
    sorted_column_ele = ''
    if sorted_column:
        sorted_column_ele = '&_o=%s' % list(sorted_column.values())[0]

    ele = """
        <nav aria-label="Page navigation">
          <ul class="pagination">
            <li>
              <a href="#" aria-label="Previous">
                <span aria-hidden="true">&laquo;</span>
              </a>
            </li>
    """
    for page in querysets.paginator.page_range:
        if abs(page - querysets.number) < 2:   # 展示1*1+1页
            active = ''
            if page == querysets.number:
                active = 'active'
            # 分页时保存筛选状态
            filtered_ele = render_filtered_args(admin_class)
            ele += '<li class="%s"><a href="?_page=%s%s%s">%s</a></li>' % (active,page,sorted_column_ele,filtered_ele,page)

    ele += """
        <li>
              <a href="#" aria-label="Next">
                <span aria-hidden="true">&raquo;</span>
              </a>
            </li>
          </ul>
        </nav>
    """
    return mark_safe(ele)

@register.simple_tag
def get_sorted_column(column,sorted_column,forloop):
    this_time_sort_index = forloop
    if column in sorted_column:  # 这一列被排序了
        # 判断上次排序方式，本次取反
        last_sorted_index = sorted_column[column]
        if last_sorted_index.startswith('-'):
            this_time_sort_index = last_sorted_index.strip('-')
        else:
            this_time_sort_index = '-%s' %last_sorted_index
    return this_time_sort_index

@register.simple_tag
def render_sorted_arrow(column,sorted_column):
    ele = ''
    if column in sorted_column:
        last_sorted_index = sorted_column[column]
        if last_sorted_index.startswith('-'):
            arrow_direction = 'top'
        else:
            arrow_direction = 'bottom'
        ele += """<span class="glyphicon glyphicon-triangle-%s" aria-hidden="true"></span>""" % arrow_direction
    return mark_safe(ele)

@register.simple_tag
def get_current_sorted_column_index(sorted_column):
    """过滤时保存排序状态"""
    return list(sorted_column.values())[0] if sorted_column else ''

@register.simple_tag
def get_field_val(admin_class,form_obj,field):
    """返回具体字段的值"""
    field_obj = admin_class.model._meta.get_field(field)
    if field_obj.choices:  # 判断字段是否为choice
        field_val = getattr(form_obj.instance, 'get_%s_display' % field)()  # 获取choice的值
    else:
        field_val = getattr(form_obj.instance, field)
    return field_val

@register.simple_tag
def get_available_m2m_data(field_name,admin_class,form_obj):
    """返回m2m字段关联表的未选中的数据"""
    field_obj = admin_class.model._meta.get_field(field_name)  # 获取该字段字段对象
    obj_all_list = set(field_obj.related_model.objects.all())
    obj_selected_list = []
    try:
        obj_selected_list = getattr(form_obj.instance, field_name).all()
    except TypeError:
        pass
    obj_available_list = obj_all_list - set(obj_selected_list)
    return obj_available_list

@register.simple_tag
def get_selected_m2m_data(field_name,form_obj):
    """返回m2m字段关联表的选中数据"""
    obj_selected_list = []
    try:
        obj_selected_list = set(getattr(form_obj.instance,field_name).all())
    except TypeError:
        pass
    return obj_selected_list

@register.simple_tag
def get_display_all_related_objs(obj):
    """显示被删除对象的所有关联对象"""
    ele = '<ul>'

    M2M_obj_list = obj._meta.many_to_many
    for M2M in M2M_obj_list:
        # 该字段关联的所有对象
        for i in getattr(obj,M2M.name).all():
            ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                   % (M2M.name, i._meta.app_label, i._meta.model_name, i.id, i, obj)
    reversed_fk_list = obj._meta.related_objects
    for reversed_fk_obj in reversed_fk_list:
        reversed_table_name = reversed_fk_obj.name
        if reversed_fk_obj.one_to_one:  # OneToOne关系
            related_lookup_key = reversed_table_name
        else:
            related_lookup_key = '%s_set' %reversed_table_name
        related_objs = getattr(obj,related_lookup_key).all()  # 反向关联的所有数据
        if reversed_fk_obj.many_to_many:  # M2M则不深入
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
        elif reversed_fk_obj.one_to_many:  # reversed_fk关系
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被删除</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
                ele += get_display_all_related_objs(i)

    ele += '</ul>'
    return ele

@register.simple_tag
def get_model_verbose_name(admin_class):
    """显示中文"""
    return admin_class.model._meta.verbose_name

@register.simple_tag
def get_field_objs(stu_rec_objs):
    """返回字段对象"""
    return stu_rec_objs[0]._meta.fields

 Day3:对上面的功能添加分页，筛选，排序，搜索功能(功能之间的url需要重组)

一：分页实现（在Django自带分页组件下进行扩展）

from django.core.paginator import Paginator

# Django内置分页拓展
class CustomPaginator(Paginator):  # 修改类
    def __init__(self,current_page, per_page_num,*args,**kwargs):
        # 当前页
        self.current_page = int(current_page)
        # 最多显示页码数 11
        self.per_page_num = int(per_page_num)
        super(CustomPaginator, self).__init__(*args,**kwargs)

    @property
    def pager_num_range(self):
        # 当前页
        # self.current_page
        # 最多显示页码数 11
        # self.per_page_num
        # 总页数
        # self.num_pages
        if self.per_page_num > self.num_pages:  # 显示页码个数大于总页数时
            # 根据当前页动态生成，设置页面显示数
            return range(1, self.num_pages + 1)  # 全部显示
        # 总页数特别多时
        part = int(self.per_page_num/2)

        if part >= self.current_page:
            return range(1, self.per_page_num + 1)
        # 判断最大极值
        if (self.current_page + part) >= self.num_pages:
            return range(self.num_pages - self.per_page_num + 1, self.num_pages + 1)
        return range(self.current_page - part, self.current_page + part +1)

===========

# 使用Django自带分页，可进行拓展
    querysets = get_paghinator_result(request,admin_class,querysets)
    print('queryset.paginator:',querysets.paginator)  # CustomPaginator object



def get_paghinator_result(request,admin_class,querysets):
    current_page = request.GET.get('_page',1)  # 加 1 防止报错
    # per_page: 每页显示条目数量
    # count：数据总个数
    # num_pages: 总页数
    # page_range: 总页数的索引范围，页码范围，如：（1,10），（1,200）
    # page：page对象(是否具有上一页，是否有下一页)
    list_per_page = admin_class.list_per_page  # 显示页码个数
    per_page_num = admin_class.per_page_num    # 每页显示条目
    # 当前页 显示页码个数 总数据 每页显示条目
    paginator = CustomPaginator(current_page,list_per_page ,querysets,per_page_num)
    try:
        posts = paginator.page(current_page)
        # has_next              是否有下一页
        # next_page_number      下一页页码
        # has_previous          是否有上一页
        # previous_page_number  上一页页码
        # object_list           分页之后的数据列表
        # number                当前页
        # paginator             paginator对象
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)
    return posts

===========

<div>
      {% render_paginator querysets admin_class sorted_column %}
 </div>

===========

@register.simple_tag
def render_filtered_args(admin_class,render_html=True):
    """拼接筛选的字段"""
    ele = ''
    if admin_class.filter_conditions:
        for k,v in admin_class.filter_conditions.items():
            ele += '&%s=%s' %(k,v)
    return mark_safe(ele) if render_html else ele

==================

@register.simple_tag
def render_paginator(querysets,admin_class,sorted_column):
    """分页"""
    filter_conditions = ''
    # 生成排序条件
    if sorted_column:
        filter_conditions += '&_o=%s' % list(sorted_column.values())[0]
    # 生成筛选条件
        filter_conditions += render_filtered_args(admin_class)

    # 生成搜索条件
    if admin_class.search_condition:
        filter_conditions += "&_q=%s" %admin_class.search_condition

    page_str = """
        <nav aria-label="Page navigation">
          <ul class="pagination">
    """
    # 为什么可以用d？？？
    page_str += '<li><a href="?_page=%d%s">首页</a></li>' % (1,filter_conditions)

    if querysets.has_previous():
        previous_page = querysets.previous_page_number()
        page_str += """<li>
                            <a href="?_page=%d%s" aria-label="Previous">
                                <span aria-hidden="true">&laquo;</span>
                            </a>
                        </li>
            """ % (previous_page,filter_conditions)

    for page in querysets.paginator.pager_num_range:
        active = ''
        if page == querysets.number:
            active = 'active'
        page_str += '<li class="%s"><a href="?_page=%d%s">%d</a></li>' % (active,page,filter_conditions,page)


    if querysets.has_next():
        next_page = querysets.next_page_number()
        page_str += """<li>
                            <a href="?_page=%d%s" aria-label="Next">
                                <span aria-hidden="true">&raquo;</span>
                            </a>
                        </li>
            """ % (next_page, filter_conditions)

    page_str += '<li><a href="?_page=%d%s">尾页</a></li>' % (querysets.paginator.num_pages,filter_conditions)

    page_str += """ 
                <li><a>第%s页/共%s页</a></li>     
              </ul>
            </nav>
        """  %(querysets.number,querysets.paginator.num_pages)
    return mark_safe(page_str)

二：对各个字段筛选（对kingadmin中list_filter字段进行筛选）

1：前端显示

<div class="row">
        {% if admin_class.list_filter %}
            <form class="navbar-form navbar-left">
                {% for filter_column in admin_class.list_filter %}
                    {% build_filter_ele filter_column admin_class %}
                {% endfor %}
                <input type="hidden" name="_o" value="{% get_current_sorted_column_index sorted_column %}">
                <input class="btn btn-success" type="submit" value="过滤">
            </form>
        {% endif %}
    </div>

2.模板函数去定制标签，在form表单中加入隐藏标签（表示排序和搜索条件）

"""过滤处理"""
@register.simple_tag
def build_filter_ele(filter_column,admin_class):
    #获取字段对象
    column_obj = admin_class.model._meta.get_field(filter_column)
    label = "<label class='control-label'>%s：</label>" % filter_column
    try:
        # 第一种（更全面，逻辑更清晰）
        filter_select = '<div class="form-group">%s<select class="form-control" name=%s>' % (label,filter_column)
        data_list = column_obj.get_choices()  # choices或外键字段

        # 第二种方式
        # for choice in column_obj.get_choices():  #获取choices选项和外键
        #     selected = ''
        #     # if filter_column in admin_class.filter_conditions:  # 当前字段被过滤了
        #     if str(choice[0]) == admin_class.filter_conditions.get(filter_column):  # 当前值被选中
        #         selected = 'selected'
        #     option = "<option value='%s' %s>%s</option>" % (choice[0],selected,choice[1])
        #     filter_select += option
    except AttributeError as e:
        print('err',e)
        # filter_select = '<div class="form-group">%s<select class="form-control" name=%s__gte>' % (label,filter_column)
        # 判断字段属性
        if column_obj.get_internal_type() in ('DateField','DateTimeField'):  # 处理date字段

            filter_column = '%s__gte' % filter_column  # 特殊处理，方便日后选中

            filter_select = '<div class="form-group">%s<select class="form-control" name=%s>' % (label, filter_column)
            time_obj = datetime.datetime.now()
            time_list = [
                ['','--------------'],
                [time_obj,'Today'],
                [time_obj-datetime.timedelta(7),'Past 7 day'],
                [time_obj.replace(day=1),'This month'],
                [time_obj-datetime.timedelta(90),'Past 3 month'],
                [time_obj.replace(month=1,day=1),'This year'],
                ['','Any day'],
            ]

            def turn_date(date_list):
                if date_list[0]:
                    date_list[0] = date_list[0].strftime("%Y-%m-%d")
                return date_list

            # 不修改原来的列表，对表里的值逐一处理，并返回，形成新列表，Python3需list
            data_list = map(turn_date,time_list)

            # for i in time_list:
            #     selected = ''
            #     time_to_str = '' if not i[0] else '%s-%s-%s' %(i[0].year,i[0].month,i[0].day)
            #     if time_to_str == admin_class.filter_conditions.get('%s__gte' %filter_column):  # 当前值被选中
            #         selected = 'selected'
            #     option = '<option value=%s %s>%s</option>' % (time_to_str,selected,i[1])
            #     filter_select += option
        else:  # 处理布尔值或其他字段
            filter_select = '<div class="form-group">%s<select class="form-control" name=%s>' % (label, filter_column)
            data_list = admin_class.model.objects.values_list('id',filter_column)
            data_list_filtered = [('','-------'),]
            for item in data_list:
                if column_obj.get_internal_type() == 'BooleanField':  # 处理布尔值
                    if item[1] == True:   # 为什么item[0] == True也可以？
                        list_filtered = (1,True)
                    else:
                        list_filtered = (0, False)
                else:  # 处理其他字段
                    list_filtered = (item[1],item[1])  # 提交值  显示值
                if list_filtered in data_list_filtered:continue
                data_list_filtered.append(list_filtered)
            data_list = data_list_filtered

    for item in data_list:
        selected = ''
        if str(item[0]) == admin_class.filter_conditions.get(filter_column, None):
            selected = 'selected'
        option = "<option value='%s' %s>%s</option>" % (str(item[0]),selected,item[1])

        filter_select += option

    filter_select += '</select></div>'
    return mark_safe(filter_select)

3.在views中将url中的各个条件，放置到admin_class中，方便模板标签的使用

# @check_permission
@login_required()
def table_obj_list(request,app_name,model_name):
    """取出指定model里的数据返回给前端"""
    admin_class = site.enabled_admins[app_name][model_name]

    if request.method == "POST":
        # print(request.POST)
        selected_action = request.POST.get('action')
        selected_ids = json.loads(request.POST.get('selected_ids'))

        if selected_action: # 如果有action参数代表为正常的action
            selected_objs = admin_class.model.objects.filter(id__in=selected_ids).all()
            admin_action_func = getattr(admin_class, selected_action)
            # print(admin_action_func,selected_objs)
            return admin_action_func(request,selected_objs)
        elif not selected_action:  # 如果没有action，代表可以是一个删除动作
            if selected_ids:  # 选中的数据都被删除
                admin_class.model.objects.filter(id__in=selected_ids).delete()

    # 调用函数过滤处理，并返回数据跟需过滤字段（用于选中）
    querysets,filter_conditions = get_filter_result(admin_class, request)  # 过滤后的数据
    # 把filter_conditions存入admin_class对象
    admin_class.filter_conditions = filter_conditions    #也可以传值给前端，但是这样也不错

    # 搜索，searched querysets
    querysets = get_search_result(request,admin_class,querysets)   # 搜索后的数据

    # 全局排序,分页前,sorted_querysets
    querysets, sorted_column = get_orderby_result(request, admin_class, querysets)  # 排序后的数据

    # 使用Django自带分页，可进行拓展
    querysets = get_paghinator_result(request,admin_class,querysets)  # 分页后的数据
    print('queryset.paginator:',querysets.paginator)  # CustomPaginator object

    return render(request, 'kingadmin/table_obj_list.html',{
        'querysets':querysets,
        'admin_class':admin_class,
        'sorted_column':sorted_column,
        'app_name':app_name,
        'model_name':model_name,
    })

4.在views中的url数据获取时将其他_q搜索，o排序，_p分页数据过滤，获取所有数据

def get_filter_result(admin_class,request):
    filter_conditions = {}
    for key,val in request.GET.items():
        # 排除与过滤关键字的干扰
        if key in ('_page','_o','_q'):continue
        # val为空时不过滤
        if val:
            filter_conditions[key] = val
    filtered_querysets = admin_class.model.objects.filter(**filter_conditions).all().order_by('-id')
    return filtered_querysets,filter_conditions

推文：python---Django中模型类中Meta元对象了解，可以知道数据模型中的字段对象或者其他所需要的内容

 三：对各个字段进行排序（list_display）

1.前端传递排序数据，对于table中的th加上url

<th>
                                <a href="?_q={{admin_class.search_key}}&_o={% get_sorted_column column sorted_column forloop.counter0 %}
                                             {% render_filtered_args admin_class %}">
                                    {{column}}
                                    {% render_sorted_arrow column sorted_column %}
                                </a>
                            </th>

2.模板函数get_sorted_column去生成value值

========第一种方式================

@register.simple_tag
def get_sorted_column(column,sorted_column,forloop):
    this_time_sort_index = forloop
    if column in sorted_column:  # 这一列被排序了
        # 判断上次排序方式，本次取反
        last_sorted_index = sorted_column[column]
        if last_sorted_index.startswith('-'):
            this_time_sort_index = last_sorted_index.strip('-')
        else:
            this_time_sort_index = '-%s' %last_sorted_index
    return this_time_sort_index

"""生成箭头"""
@register.simple_tag
def render_sorted_arrow(column,sorted_column):
    ele = ''
    if column in sorted_column:
        last_sorted_index = sorted_column[column]
        if last_sorted_index.startswith('-'):
            arrow_direction = 'top'
        else:
            arrow_direction = 'bottom'
        ele += """<span class="glyphicon glyphicon-triangle-%s" aria-hidden="true"></span>""" % arrow_direction
    return mark_safe(ele)

========第二种方式================

@register.simple_tag
def build_title_row(admin_class):
    #先生成过滤条件
    filter_conditions = ''
    for k, v in admin_class.filter_conditions.items():
        filter_conditions += "&" + k + '=' + v;

    #再生成搜索条件
    if admin_class.search_conditions:
        filter_conditions += "&_q="+admin_class.search_conditions

    icon = """<span class="glyphicon glyphicon-triangle-%s" aria-hidden="true"></span>"""
    title = ''
    th = "<th><a href='?o=%s%s'>%s%s</a></th>"

    try:
        sort_cond = list(admin_class.sort_conditions.keys())[0]
        sort_val = list(admin_class.sort_conditions.values())[0]
    except IndexError:
        sort_cond = None
        sort_val = None
    for counter,field in enumerate(admin_class.list_display):
        if field == sort_cond:
            if sort_val.startswith("-"):
                title += th%(sort_val.strip("-"),filter_conditions,field,icon%"top")
            else:
                title += th%("-"+sort_val,filter_conditions,field,icon%"bottom")
        else:
            title += th%(counter,filter_conditions,field,"")

    return mark_safe(title)

build_title_row中先将过滤和搜索条件组合，再生成排序url（符号倒序，数字代表在admin_class中list_display字段中的索引顺序）

3.views中对我们获取的所有数据，根据前端传递的排序方法进行排序处理

def get_orderby_result(request,admin_class,querysets):
    """排序"""
    orderby_index = request.GET.get('_o')
    current_sorted_column = {}
    # 如果有则进行排序，没有则直接返回querysets
    if orderby_index:
        orderby_column = admin_class.list_display[abs(int(orderby_index))]  # 取绝对值，确保取相同值
        current_sorted_column[orderby_column] = orderby_index   # 为了让前端知道当前排序的列
        # 判断显示方式
        if orderby_index.startswith('-'):  # 判断排序方式，字段索引为负，则倒序
            orderby_column = '-%s' % orderby_column
        querysets = querysets.order_by(orderby_column)
    return querysets,current_sorted_column

四：对字段进行搜索（search_fields）

1.前端生成标签时，form表单中需要一起传递其他条件的input隐藏框

<!--关键字搜索-->
    <div class="row">
        <form>
            <div class="row">
              <div class="col-md-6">
                <div class="input-group">
                  <span class="input-group-btn">
                    <button class="btn btn-default" type="button">
                        <span class="glyphicon glyphicon-search" aria-hidden="true"></span>
                    </button>
                  </span>
                  <input type="search" class="form-control" name="_q" value="{{admin_class.search_key}}"
                       placeholder="{% for s in admin_class.search_fields %}{{s}}，{% endfor %}">
                </div>
              </div>
            <input class="btn btn-success" type="submit" value="Search">

            <!--其他条件impute隐藏框-->
            {% for k,v in admin_class.filter_conditions.items %}
                <input type="hidden" name="{{k}}" value="{{v}}">
            {% endfor %}
            {% for k,v in admin_class.sorted_column.items %}
                <input type="hidden" name="_o" value="{{v}}">
            {% endfor %}
            </div>
        </form>
    </div>

2.后端处理搜索条件，生成querysets数据

"""返回搜索结果数据"""
def get_search_result(request,admin_class,querysets):
    search_key = request.GET.get('_q','')
    admin_class.search_condition = search_key
    admin_class.search_key = search_key
    if search_key:
        q = Q()
        q.connector = 'OR'
        for search in admin_class.search_fields:
            # 添加搜索条件
            q.children.append(('%s__contains' % search, search_key))
        querysets = querysets.filter(q)
    return querysets

 推文：python---django中orm的使用（2）

Day4:动态生成任意表的CURD

1.如何在前端动态生成标签？使用form验证可以针对model生成所有的字段控件

推文：python---django中form组件（2）自定制属性以及表单的各种验证,以及数据源的实时更新,以及和数据库关联使用ModelForm和元类

from django.forms import ModelForm
from repository import models

class CustomerForm(ModelForm):
    class Meta:
        model = models.CustumerInfo #将表与元类中的数据关联
        fields = "__all__"

    def __new__(cls, *args, **kwargs):
        print(cls.base_fields)
        #OrderedDict([('name', <django.forms.fields.CharField object at 0x00000000047FE9E8>), ('contact_type', <django.forms.fields.TypedChoiceField object at 0x00000000047FEBA8>), ('contact', <django.forms.fields.CharField object at 0x00000000047FECC0>), ('source', <django.forms.fields.TypedChoiceField object at 0x00000000047FEE10>), ('referral_from', <django.forms.models.ModelChoiceField object at 0x00000000047FEEF0>), ('consult_courses', <django.forms.models.ModelMultipleChoiceField object at 0x000000000480B048>), ('consult_content', <django.forms.fields.CharField object at 0x000000000480B0B8>), ('status', <django.forms.fields.TypedChoiceField object at 0x000000000480B208>), ('consultant', <django.forms.models.ModelChoiceField object at 0x000000000480B2E8>)])
        #这张表中的所有字段对象
        for field_name,field_obj in dict(cls.base_fields).items():
            field_obj.widget.attrs.update({'class':"form-control"})

        return ModelForm.__new__(cls)

实验：使用固定的数据模型去生成对应的form验证类，可以用来在前端之间生成控件

2.如何针对每张表动态生成一个Form类？需要用到type方法去动态生成类

推文：python---基础知识回顾（三）（面向对象）

 

from django.forms import ModelForm,ValidationError

def create_dynamic_model_form(admin_class,request,flag=False):
    """动态生成modelform"""
    class Meta:
        # 绑定model_class
        model = admin_class.model
        # 所有字段
        fields = '__all__'
        # 判断操作方式，默认false为change，true为添加
        if not flag:  # change
            # 排除只读字段
            # exclude = admin_class.readonly_fields
            # 由于admin_class实例一直未变，当修改值时会一直保持状态不变，所以需改变状态需重新赋值
            admin_class.form_add = False
        else: # add
            if request.user.__class__ == admin_class.model:
               exclude = ['password']
            admin_class.form_add = True

    def __new__(cls,*args,**kwargs):
        for field_name in cls.base_fields:
            field_obj = cls.base_fields[field_name]
            field_obj.widget.attrs.update({'class':'form-control'})
            if not flag:  # change
                if field_name in admin_class.readonly_fields:
                    # 当属性disabled为True时，form表单提交时不会在提交数据
                    field_obj.widget.attrs.update({'disabled': 'true'})
        return ModelForm.__new__(cls)

    def clean(self):
        """from default clean method"""
        print('cleaned_data',self.cleaned_data)
        if self.errors:  # 表单级错误
            raise ValidationError(('Please fix errors before re-submit.'))
        if self.instance.id is not None: # means this is a change form, should check the readonly fields
            for field in admin_class.readonly_fields:
                old_field_val = getattr(self.instance,field)  # 数据库里的数据
                form_val = self.cleaned_data.get(field)
                print('old_field_val',old_field_val,'form_val',form_val)
                if old_field_val != form_val:  # 添加字段错误
                    self.add_error(field,"Readonly Field: field should be '{value}' ,not'{new_value}'".format(**{'value':old_field_val,'new_value':form_val}))

    # 动态生成model_class相关form类
    dynamic_form = type('DynamicModelForm',(ModelForm,),{'Meta':Meta, '__new__':__new__,'clean':clean})

    return dynamic_form

3.在修改页面中动态创建Form类（需要传递原来数据）

"""kingadmin数据修改页"""
# @check_permission
@login_required
def table_obj_change(request,app_name,model_name,obj_id):
    # from crm.forms import CustomerInfoForm
    # form = CustomerInfoForm()
    admin_class = site.enabled_admins[app_name][model_name]

    # 调用函数，并传入model_class动态生成form类
    model_form = create_dynamic_model_form(admin_class,request)
    obj = admin_class.model.objects.get(id=obj_id)

    if request.method == "GET":
        form_obj = model_form(instance=obj)
    elif request.method == "POST":
        form_obj = model_form(instance=obj,data=request.POST)
        if form_obj.is_valid():
            # ModelForm自动更新
            form_obj.save()
            return redirect('/kingadmin/%s/%s' %(app_name,model_name))
    return render(request, 'kingadmin/table_obj_change.html',{
        'form_obj':form_obj,
        'admin_class':admin_class,
        'app_name':app_name,
        'model_name':model_name,
    })

 =================================

re_path('^(\w+)/(\w+)/(\d+)/change/$', views.table_obj_change,name='table_obj_change'),

4.在添加页面动态创建Form类

"""kingadmin数据增加页"""
# @check_permission
@login_required
def table_obj_add(request,app_name,model_name):
    admin_class = site.enabled_admins[app_name][model_name]
    model_form = create_dynamic_model_form(admin_class,request,flag=True)
    if request.method == "GET":
        form_obj = model_form()
    elif request.method == "POST":
        form_obj = model_form(data=request.POST)
        if form_obj.is_valid():
            form_obj.save()
            return redirect('/kingadmin/%s/%s' % (app_name, model_name))
    return render(request, 'kingadmin/table_obj_add.html', {
        'form_obj': form_obj,
        'admin_class': admin_class,
    })

==================

 re_path('^(\w+)/(\w+)/add', views.table_obj_add,name='table_obj_add'),

添加的url

5.修改和添加的HTML和公共部分

{% extends 'kingadmin/index.html' %}
{# 导入标签模块 #}
{% load kingadmin_tag %}  {# build_table_row' is not a registered tag library 重启即可 #}

{% block right-content-container %}
    <h1 class="page-header">{% get_model_name admin_class %}</h1>
    <h4 class="page-header">ADD {% get_model_name admin_class %}</h4>

{% include 'kingadmin/table_obj_component.html' %}

{% endblock %}

===================

{% extends 'kingadmin/index.html' %}
{# 导入标签模块 #}
{% load kingadmin_tag %}  {# build_table_row' is not a registered tag library 重启即可 #}

{% block right-content-container %}
    <h1 class="page-header">{% get_model_name admin_class %}</h1>
    <ol class="breadcrumb">
      <li><a href="/kingadmin/">Home</a></li>
      <li><a href="/kingadmin/{{app_name}}/">{{app_name}}</a></li>
      <li><a href="/kingadmin/{{app_name}}/{{model_name}}/">{% get_model_verbose_name admin_class %}</a></li>
      <li class="active">{{form_obj.instance}}</li>
    </ol>
    <h4 class="page-header">CHANGE {{form_obj.instance.name.upper}}</h4>

{% include 'kingadmin/table_obj_component.html' %}

{% endblock %}

========================

 {% load kingadmin_tag %}

<form class="form-horizontal" method="post" onsubmit="VerificationBeforeFormSubmit()" novalidate>{% csrf_token %}

    {% for field in form_obj %}
        <div class="form-group">
            <label class="col-sm-2 control-label">{{field.label}}：</label>
            <div class="col-sm-6">
                <!--处理horizontal字段-->
                {% if field.name in admin_class.filter_horizontal %}
                    <!--左选框-->
                    <div class="col-lg-5">

                        <!--模糊匹配-->
                        <input type="search" class="form-control" oninput="FuzzSearch(this);">

                        <!--使用动态字段，保证跳转唯一ID-->
                        <select id="id_{{field.name}}_from"  class="form-control" multiple>
                            <!--调用并返回available_m2m_data-->
                            {% get_available_m2m_data field.name admin_class form_obj as available_m2m_data %}
                                {% for obj in available_m2m_data %}
                                    <!--双击事件，传入this跟目标ID-->
                                    <option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_to');" value="{{obj.id}}">{{obj}}</option>
                                {% endfor %}
                        </select>

                        <!--实现一键全选-->
                        <a onclick="MoveAllOption('id_{{field.name}}_from','id_{{field.name}}_to');" href="#">Choose All</a>
                    </div>

                    <!--右选框-->
                    <div class="col-lg-5">
                        <select tag="selected_m2m" id="id_{{field.name}}_to" name="{{field.name}}" class="form-control" multiple>
                            {% get_selected_m2m_data field.name form_obj as selected_m2m_data %}
                            {% for obj in selected_m2m_data %}
                                <option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_from');" value="{{obj.id}}">{{obj}}</option>
                            {% endfor %}
                        </select>
                        <a onclick="MoveAllOption('id_{{field.name}}_to','id_{{field.name}}_from');" href="#">Remove All</a>
                    </div>

                <!--一般字段-->
                {% else %}
                    {{field}}
                {% endif %}

                <!--错误提醒-->
                <span style="color:red;">{{field.errors.0}}</span>
            </div>
        </div>
    {% endfor %}

    <div class="form-group">
        <!--判断是否为修改页面，删除按钮显示与否-->
        {% if form_obj.instance.id %}
            <div class="col-sm-10">
                <a href="{% url 'table_obj_delete' app_name model_name form_obj.instance.id %}" class="btn btn-danger">Delete</a>
            </div>
        {% endif %}
        <div class="col-sm-offset-7 col-sm-10">
            <button type="submit" class="btn btn-info">Save</button>
        </div>
    </div>
 </form>

 <script>
    // 双击事件
     function MoveSelectedOption(this_ele,target_id) {
        // 获取跳转目标的ID
        var new_target_id = $(this_ele).parent().attr('id');
        var new_val = $(this_ele).val();
        var new_text = $(this_ele).text();

        // 创建option标签,ondbclick=MoveSelectedOption 无需引号，有引号时则无法返回
        var option = "<option ondblclick=MoveSelectedOption(this,'" + new_target_id + "'); value='" + new_val + "'>"
                            + new_text + "</option>";

        // 添加，为什么$("#target_id").append(option)不行？？？？，因为target_id为传的字符串参数，而不是属性名
        $("#" + target_id).append(option);

        // 删除
        $(this_ele).remove();
     }

     // form表单提交前的检测
     function VerificationBeforeFormSubmit() {
        // 移除所有‘disabled’属性
        $(':disabled').removeAttr('disabled');

        // 选中有tag属性的select下所有option标签
        $("select[tag] option").prop('selected',true);
     }

     // 一键全选
     function MoveAllOption(from_id,to_id) {
            $('#' + from_id).children().each(function() {
            MoveSelectedOption(this,to_id);
        });
     }

     // 模糊匹配
     function FuzzSearch(ele) {
        var search_text = $(ele).val().toUpperCase();

        // ‘ele’标签后一个的所有孩子标签循环
        $(ele).next().children().each(function() {
            if($(this).text().toUpperCase().search(search_text) != -1) {
                // 匹配有则显示
                $(this).show();
            }else{
                $(this).hide();
            }
        });
     }
 </script>

6.处理在add和change中对于readonly_fileds字段的不同（使用其他方式处理readonly_fields可跳过）

{% if not admin_class.add_flag %}
                {% for field_name in admin_class.readonly_fields %}
                     <div class="form-group">
                        <label class="col-sm-2 control-label">{{ field_name }}</label>
                        <div class="col-sm-10">
                                <p class="text-left">{% get_field_value_p field_name form_obj %}</p>
                        </div>
                     </div>
                {% endfor %}
            {% endif %}

在动态生成ModelForm修改，并且向admin_class.add_flag加入标识，前端进行判别，决定是否去显示只读字段

7.对于filter_horizontal字段我们在模板函数中进行获取选中值与未选中值，分别显示在不同的选择框

<!--处理horizontal字段-->
                {% if field.name in admin_class.filter_horizontal %}
                    <!--左选框-->
                    <div class="col-lg-5">

                        <!--模糊匹配-->
                        <input type="search" class="form-control" oninput="FuzzSearch(this);">

                        <!--使用动态字段，保证跳转唯一ID-->
                        <select id="id_{{field.name}}_from"  class="form-control" multiple>
                            <!--调用并返回available_m2m_data-->
                            {% get_available_m2m_data field.name admin_class form_obj as available_m2m_data %}
                                {% for obj in available_m2m_data %}
                                    <!--双击事件，传入this跟目标ID-->
                                    <option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_to');" value="{{obj.id}}">{{obj}}</option>
                                {% endfor %}
                        </select>

                        <!--实现一键全选-->
                        <a onclick="MoveAllOption('id_{{field.name}}_from','id_{{field.name}}_to');" href="#">Choose All</a>
                    </div>

                    <!--右选框-->
                    <div class="col-lg-5">
                        <select tag="selected_m2m" id="id_{{field.name}}_to" name="{{field.name}}" class="form-control" multiple>
                            {% get_selected_m2m_data field.name form_obj as selected_m2m_data %}
                            {% for obj in selected_m2m_data %}
                                <option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_from');" value="{{obj.id}}">{{obj}}</option>
                            {% endfor %}
                        </select>
                        <a onclick="MoveAllOption('id_{{field.name}}_to','id_{{field.name}}_from');" href="#">Remove All</a>
                    </div>

============================

"""返回m2m字段关联表的未选中的数据"""
@register.simple_tag
def get_available_m2m_data(field_name,admin_class,form_obj):
    field_obj = admin_class.model._meta.get_field(field_name)  # 获取该字段字段对象
    # 通过字段对象，退出关联model，并获取该字段关联的所有数据
    obj_all_list = set(field_obj.related_model.objects.all())
    obj_selected_list = []
    try:
        obj_selected_list = getattr(form_obj.instance, field_name).all()
    except TypeError:  # 异常处理
        pass
    obj_available_list = obj_all_list - set(obj_selected_list)   # 求差集
    return obj_available_list

===========================

"""返回m2m字段关联表的选中数据"""
@register.simple_tag
def get_selected_m2m_data(field_name,form_obj):
    obj_selected_list = []
    try:
        obj_selected_list = set(getattr(form_obj.instance,field_name).all())
    except TypeError:
        pass
    return obj_selected_list

8.实现js双击option,在两个select之间跳转

           

 

<option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_to');" value="{{obj.id}}">{{obj}}</option>

<option ondblclick="MoveSelectedOption(this,'id_{{field.name}}_from');" value="{{obj.id}}">{{obj}}</option>

==========================

// 双击事件
     function MoveSelectedOption(this_ele,target_id) {
        // 获取跳转目标的ID
        var new_target_id = $(this_ele).parent().attr('id');
        var new_val = $(this_ele).val();
        var new_text = $(this_ele).text();

        // 创建option标签,ondbclick=MoveSelectedOption 无需引号，有引号时则无法返回
        var option = "<option ondblclick=MoveSelectedOption(this,'" + new_target_id + "'); value='" + new_val + "'>"
                            + new_text + "</option>";

        // 添加，为什么$("#target_id").append(option)不行？？？？，因为target_id为传的字符串参数，而不是属性名
        $("#" + target_id).append(option);

        // 删除
        $(this_ele).remove();
     }

9.实现在点击保存时，form表单自动将右侧select中的数据全部选中。注意：加上name为select标签，name="字段名" 

<form class="form-horizontal" method="post" onsubmit="VerificationBeforeFormSubmit()" novalidate>{% csrf_token %}

==================

// form表单提交前的检测
     function VerificationBeforeFormSubmit() {
        // 移除所有‘disabled’属性
        $(':disabled').removeAttr('disabled');

        // 选中有tag属性的select下所有option标签
        $("select[tag] option").prop('selected',true);
     }

10.为filter_horizontal完善功能，添加全选，全部移除，模糊匹配

<!--实现一键全选-->
                        <a onclick="MoveAllOption('id_{{field.name}}_from','id_{{field.name}}_to');" href="#">Choose All</a>

                        <a onclick="MoveAllOption('id_{{field.name}}_to','id_{{field.name}}_from');" href="#">Remove All</a>

===============

// 一键全选
     function MoveAllOption(from_id,to_id) {
            $('#' + from_id).children().each(function() {
            MoveSelectedOption(this,to_id);
        });
     }

11.为filter_horizontal完善功能之模糊匹配

<!--模糊匹配-->
<input type="search" class="form-control" oninput="FuzzSearch(this);">

================

// 模糊匹配
     function FuzzSearch(ele) {
        var search_text = $(ele).val().toUpperCase();

        // ‘ele’标签后一个的所有孩子标签循环
        $(ele).next().children().each(function() {
            if($(this).text().toUpperCase().search(search_text) != -1) {
                // 匹配有则显示
                $(this).show();
            }else{
                $(this).hide();
            }
        });
     }

 

Day5:删除功能开发和action方法实现

1.删除功能开发

{% extends 'kingadmin/index.html' %}
{# 导入标签模块 #}
{% load kingadmin_tag %}  {# 'build_table_row' is not a registered tag library 重启即可 #}

{% block right-content-container %}
    <!--app_name and model_name可传可求-->
    <span>{% get_model_name admin_class as model_name%}</span>
    <h1 class="page-header">{{model_name.upper}}</h1>

    <!--展示提醒删除信息-->
    {% for obj in selected_objs %}
        <div>
            <h4 class="page-header alert-danger">注意：以下与{{obj}}相关的将被删除</h4>
                {% get_display_all_related_objs obj as all_related_eles %}
                {{ all_related_eles|safe }}
        </div>
    {% endfor %}
<hr>
    <form method="post">{% csrf_token %}
        <input type="submit" class="btn btn-danger" value="Yes,I'm sure">
        <!--判断是否为批量删除-->
        {% if queryset_ids %}
            <!--隐藏input标签，用于区别是否为批量删除，传递数据-->
            <input type="hidden" name="selected_ids" value="{{queryset_ids}}">
            <a class="btn btn-info" href="">No,take me back</a>
        {% else %}
            <a class="btn btn-info" href="/kingadmin/{{app_name}}/{{model_name}}/{{selected_objs.0.id}}/change">No,take me back</a>
        {% endif %}
    </form>

{% endblock %}

============

"""显示被删除对象的所有关联对象"""
@register.simple_tag
def get_display_all_related_objs(obj):
    """
    关联：只需列出M2M
    反向关联：
        M2M   列出，影响
        O2O   列出，删除，递归
        FK    列出，删除，递归
    :param obj:
    :return:
    """
    ele = '<ul>'

    # M2M只列出，不递归，只影响，不删除
    M2M_obj_list = obj._meta.many_to_many
    for M2M in M2M_obj_list:
        # 该字段关联的所有对象
        for i in getattr(obj,M2M.name).all():
            ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                   % (M2M.name, i._meta.app_label, i._meta.model_name, i.id, i, obj)

    # 反向关联数据
    reversed_fk_list = obj._meta.related_objects
    for reversed_fk_obj in reversed_fk_list:
        reversed_table_name = reversed_fk_obj.name

        # 区别M2M、FK和O2O的反向查找
        if reversed_fk_obj.one_to_one:  # OneToOne关系，删除，并递归
            # 如果没有对象赋值给这个关联关系,Django 将引发一个DoesNotExist异常
            related_objs = [getattr(obj, reversed_table_name),]
        else:
            related_lookup_key = '%s_set' %reversed_table_name
            related_objs = getattr(obj,related_lookup_key).all()  # 反向关联的所有数据

        # 区别M2M和O2O、FK的反向查找后是否递归
        if reversed_fk_obj.many_to_many:  # M2M则不深入
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
        else:  # reversed_fk(one_to_many) or reversed_o2o 关系
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被删除</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
                ele += get_display_all_related_objs(i)

    ele += '</ul>'
    return ele

============

"""kingadmin数据删除页"""
# @check_permission
@login_required
def table_obj_delete(request,app_name,model_name,obj_id):
    admin_class = site.enabled_admins[app_name][model_name]
    obj = admin_class.model.objects.get(id=obj_id)
    if request.method == "POST":
        obj.delete()
        return redirect('/kingadmin/{app_name}/{model_name}/'.format(app_name=app_name,model_name=model_name))
    return render(request, 'kingadmin/table_obj_delete.html',{
        'admin_class':admin_class,
        'app_name':app_name,
        'selected_objs':[obj,],

    })

 

2.action字段功能完善

class CustomerAdmin(BaseKingAdmin):
    list_display = ['name', 'source', 'contact_type', 'contact', 'consultant', 'consult_content', 'status', 'date']
    list_filter = ['source', 'consultant', 'status', 'date']
    search_fields = ['name','contact','source']
    readonly_fields = ['contact','status']
    filter_horizontal = ['consult_courses']
    actions = ['change_status', ]
    list_per_page = 2
    per_page_num = 2

    def change_status(self, request, querysets):
        print(self, request, querysets)
        querysets.update(status=0)

==============================

class BaseKingAdmin(object):
    def __init__(self):
        self.actions.extend(self.default_action)
    list_display = []
    list_filter = []
    search_fields = []
    readonly_fields = []
    filter_horizontal = []
    list_per_page = 10
    per_page_num = 10
    default_action = ['delete_selected_objs']
    actions = []

    def delete_selected_objs(self,request,querysets):
        print('delete_selected_objs',self,request,querysets)

        queryset_ids = json.dumps([i.id for i in querysets])  # 获取所有id
        return render(request, 'kingadmin/table_obj_delete.html',{
            'selected_objs':querysets,
            'admin_class':self,
            'queryset_ids':queryset_ids,
        })

 

（1）设置form表单布局

    <!--action批量操作-->
    <form onsubmit="return ActionCheck(this);" method="post"> {% csrf_token %}
        <div class="row">
            <div class="col-lg-3">
                <select class="form-control" name="action">
                    <!--若无value则默认为值-&#45;&#45;&#45;&#45;，只有value=""值才为空 -->
                    <option value="">------------</option>
                    {% for action in admin_class.actions %}
                        <option value="{{action}}">{{action}}</option>
                    {% endfor %}
                </select>
           </div>
            <div class="col-lg-2">
                <input class="btn btn-success" type="submit" value="GO">
            </div>
        </div>
    </form>

（2）设置复选框完成全选功能

<th><input onclick="SelectAllObjs(this);" type="checkbox"></th>


<td><input row-select='true' type="checkbox" value="{{obj.id}}"></td>

===========

// 实现一键CheckBox全选
    function SelectAllObjs(ele) {
        if($(ele).prop('checked')) {
            $('input[row-select]').prop('checked',true);
        }else{
            $('input[row-select]').prop('checked',false);
        }
    }

（3）提交表单前先生成隐藏表单去获取数据集

// form表单提交前检测
    function ActionCheck(ele) {
        var selected_action = $("select[name='action']").val();
        var selected_objs = $('input[row-select]').filter(':checked');
        console.log(selected_action);
        // 未选中action
        if(!selected_action) {
            alert('no action selected!');
            // ?????
            return false
        }

        if(selected_objs.length == 0) {
            // 未选中CheckBox
            alert('no object selected!');
            return false
        }else{
            // 把所有选中行的ID打包
            var selected_ids = [];
            $.each(selected_objs,function() {
                selected_ids.push($(this).val());
            });
            /*
                创建input隐藏标签
                JSON.stringify(selected_ids)之后为字符串，无需再加引号
            */
            var input_ele = '<input type="hidden" name="selected_ids" value=' + JSON.stringify(selected_ids) + '>'
            $(ele).append(input_ele);
        }
        // 返回则不提交数据
        //return false
    }

（4）传递到后端进行处理

"""取出指定model里的数据返回给前端"""
# @check_permission
@login_required()
def table_obj_list(request,app_name,model_name):
    admin_class = site.enabled_admins[app_name][model_name]

    # print('before action', admin_class.actions)
    """
        1.去重
            因为实例化admin_class就会在actions中加一个默认值
        2.为什么未定制actions时会添加？而且实例化的类都不一样？
            因为自定义的类都继承了KingAdminBase基类
        3.定制时也一样都会添加，为什么最后只有一个默认值呢？
            原因是会被定制的actions里的值覆盖，
            然后在添加自己实例化的那个默认值
    """
    admin_class.actions = list(set(admin_class.actions))
    # print('after action',admin_class.actions)

    if request.method == "POST":
        # print(request.POST)
        selected_action = request.POST.get('action')
        selected_ids = json.loads(request.POST.get('selected_ids'))

        """
            判断为action时可以跳转到其他视图操作会更简洁
        """

        if selected_action: # 如果有action参数代表为正常的action
            selected_objs = admin_class.model.objects.filter(id__in=selected_ids).all()
            admin_action_func = getattr(admin_class, selected_action)
            # print(admin_action_func,selected_objs)
            # 必须要return返回，不然无法渲染
            return admin_action_func(request,selected_objs)  # 第一次POST提交
        elif not selected_action:  # 如果没有action，代表可以是一个删除动作
            if selected_ids:  # 选中的数据都被删除
                admin_class.model.objects.filter(id__in=selected_ids).delete()  # 第二次POST提交

 3.处理action中的默认行为delete批量删除

（1）提交的url不是上面的table_obj_delete，而是本页面和change_status一起作为action传递入当前url

 def delete_selected_objs(self,request,querysets):
        print('delete_selected_objs',self,request,querysets)

        queryset_ids = json.dumps([i.id for i in querysets])  # 获取所有id
        return render(request, 'kingadmin/table_obj_delete.html',{
            'selected_objs':querysets,
            'admin_class':self,
            'queryset_ids':queryset_ids,
        })

（2）获取delete_selected_objs在table_obj_list方法中返回

    if request.method == "POST":
        # print(request.POST)
        selected_action = request.POST.get('action')
        selected_ids = json.loads(request.POST.get('selected_ids'))

        """
            判断为action时可以跳转到其他视图操作会更简洁
        """

        if selected_action: # 如果有action参数代表为正常的action
            selected_objs = admin_class.model.objects.filter(id__in=selected_ids).all()
            admin_action_func = getattr(admin_class, selected_action)
            # print(admin_action_func,selected_objs)
            # 必须要return返回，不然无法渲染
            return admin_action_func(request,selected_objs)  # 第一次POST提交
        elif not selected_action:  # 如果没有action，代表可以是一个删除动作
            if selected_ids:  # 选中的数据都被删除
                admin_class.model.objects.filter(id__in=selected_ids).delete()  # 第二次POST提交

若是执行完action方法后没有返回值则是正常执行，如果有返回值，则是代表我们接下来是执行删除操作。需要返回

（3）我们还是调用的上面的table_obj_delete.html页面，但是其中的模板标签函数，是针对一个数据对象，而现在是一个数据集，我们需要再次处理

"""显示被删除对象的所有关联对象"""
@register.simple_tag
def get_display_all_related_objs(obj):
    """
    关联：只需列出M2M
    反向关联：
        M2M   列出，影响
        O2O   列出，删除，递归
        FK    列出，删除，递归
    :param obj:
    :return:
    """
    ele = '<ul>'

    # M2M只列出，不递归，只影响，不删除
    M2M_obj_list = obj._meta.many_to_many
    for M2M in M2M_obj_list:
        # 该字段关联的所有对象
        for i in getattr(obj,M2M.name).all():
            ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                   % (M2M.name, i._meta.app_label, i._meta.model_name, i.id, i, obj)

    # 反向关联数据
    reversed_fk_list = obj._meta.related_objects
    for reversed_fk_obj in reversed_fk_list:
        reversed_table_name = reversed_fk_obj.name

        # 区别M2M、FK和O2O的反向查找
        if reversed_fk_obj.one_to_one:  # OneToOne关系，删除，并递归
            # 如果没有对象赋值给这个关联关系,Django 将引发一个DoesNotExist异常
            related_objs = [getattr(obj, reversed_table_name),]
        else:
            related_lookup_key = '%s_set' %reversed_table_name
            related_objs = getattr(obj,related_lookup_key).all()  # 反向关联的所有数据

        # 区别M2M和O2O、FK的反向查找后是否递归
        if reversed_fk_obj.many_to_many:  # M2M则不深入
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被影响</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
        else:  # reversed_fk(one_to_many) or reversed_o2o 关系
            for i in related_objs:
                ele += '<li>%s：<a href="/kingadmin/%s/%s/%s/change">%s</a>——记录里与[%s]相关的数据将被删除</li>' \
                       % (reversed_table_name,i._meta.app_label,i._meta.model_name,i.id,i,obj)
                ele += get_display_all_related_objs(i)

    ele += '</ul>'
    return ele

（4）我们提交数据，也不再是table_obj_delete方法，而是table_obj_list方法，所以我们需要传递一个数据代表要删除的数据id集合，同时一个一个标识

=======  方式一 =======

<!--隐藏input标签，用于区别是否为批量删除，传递数据-->
            <input type="hidden" name="selected_ids" value="{{queryset_ids}}">

======= 方式二 ========

<input type="hidden" name="delete_ids" value="{% get_del_objs_id obj %}">

@register.simple_tag
def get_del_objs_id(objs):
    obj_ser = []
    for obj in objs:
        obj_ser.append(obj.id)
    return json.dumps(obj_ser)

get_del_objs_id模板函数收集所有的数据对象的id,json序列化返回给前端

（5）views页面根据post传递过来的隐藏标签的name，判断是不是执行删除数据操作

        if selected_action: # 如果有action参数代表为正常的action
            selected_objs = admin_class.model.objects.filter(id__in=selected_ids).all()
            admin_action_func = getattr(admin_class, selected_action)
            # print(admin_action_func,selected_objs)
            # 必须要return返回，不然无法渲染
            return admin_action_func(request,selected_objs)  # 第一次POST提交
        elif not selected_action:  # 如果没有action，代表可以是一个删除动作
            if selected_ids:  # 选中的数据都被删除
                admin_class.model.objects.filter(id__in=selected_ids).delete()  # 第二次POST提交

 4.实现面包屑导航

 

 

 <h1 class="page-header">Django administration</h1>
        <ol class="breadcrumb">
          <li><a href="/kingadmin/">Home</a></li>
          <li><a href="/kingadmin/{{app_name}}/">{{app_name}}</a></li>
          <li><a href="/kingadmin/{{app_name}}/{{model_name}}/">{% get_model_verbose_name admin_class %}</a></li>
          <li class="active">Add {% get_model_name admin_class %}</li>
        </ol>
    <h1 class="page-header">Add {% get_model_name admin_class %}</h1>

============

<!--面包屑-->
    <h1 class="page-header">Django administration</h1>
        <ol class="breadcrumb">
          <li><a href="/kingadmin/">Home</a></li>
          <li><a href="/kingadmin/{{app_name}}/">{{app_name.title}}</a></li>
          <li class="active">{% get_model_verbose_name admin_class %}</li>
        </ol>
    <h4 class="page-header">Select {% get_model_verbose_name admin_class %} to change</h4>

===========

 <h1 class="page-header">Django administration</h1>
        <ol class="breadcrumb">
          <li><a href="/kingadmin/">Home</a></li>
          <li><a href="/kingadmin/{{app_name}}/">{{app_name}}</a></li>
          <li><a href="/kingadmin/{{app_name}}/{{model_name}}/">{% get_model_verbose_name admin_class %}</a></li>
          <li class="active">{{form_obj.instance}}</li>
        </ol>
    <h4 class="page-header">Change {% get_model_verbose_name admin_class %}</h4>

===========

"""显示中文"""
@register.simple_tag
def get_model_verbose_name(admin_class):
    return admin_class.model._meta.verbose_name

===========

<h1 class="page-header">Django administration</h1>
        <ol class="breadcrumb">
          <li><a href="/kingadmin/">Home</a></li>
          <li><a href="/kingadmin/{{app_name}}/">{{app_name}}</a></li>
          <li><a href="/kingadmin/{{app_name}}/{{model_name}}/">{% get_model_verbose_name admin_class %}</a></li>
          <li class="active">{% get_selected_del selected_objs %}</li>
          <li class="active">Delete</li>
        </ol>

==========

"""返回删除组合对象名列表"""
@register.simple_tag
def get_selected_del(selected_objs):
    obj_names = []
    for obj in selected_objs:
        obj_names.append(obj.name)
    print('obj_names',obj_names)
    return ' | '.join(obj_names)

 5.左侧菜单状态

          <!--左侧菜单栏-->
        <div class="col-sm-3 col-md-2 sidebar">
          <ul class="nav nav-sidebar">
              {% for role in request.user.role.select_related %}
                {% for menu in role.menus.select_related %}
                    {% url menu.url_name as dynamic_url %}
                    <!--高亮显示，刷新页面的情况用request.path判断，否则可以js-->
                    {% if menu.url_name == request.path %}
                        <li class="active"><a href="{% if menu.url_type == 0 %}{{menu.url_name}}{% else %}{{dynamic_url}}{% endif %}">{{menu.name}}</a></li>
                    {% elif dynamic_url == request.path %}
                        <li class="active"><a href="{% if menu.url_type == 0 %}{{menu.url_name}}{% else %}{{dynamic_url}}{% endif %}">{{menu.name}}</a></li>
                    {% else %}
                        <li><a href="{% if menu.url_type == 0 %}{{menu.url_name}}{% else %}{{dynamic_url}}{% endif %}">{{menu.name}}</a></li>
                    {% endif %}
                {% endfor %}
              {% endfor %}
          </ul>
        </div>

Day6:学员报名流程开发

class ContractTemplate(models.Model):
    """存储合同模板"""
    name = models.CharField(max_length=64)
    content = models.TextField()
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name = '合同'
        verbose_name_plural = '合同'

    def __str__(self):
        return self.name

class StudentEnrollment(models.Model):
    """学员报名表"""
    customer = models.ForeignKey('CustomerInfo',on_delete=models.CASCADE)
    consultant = models.ForeignKey('UserProFile',on_delete=models.CASCADE)
    class_grade = models.ForeignKey('ClassList',on_delete=models.CASCADE)

    contract_agreed = models.BooleanField(default=False,verbose_name="学员已经同意合同")  #学员看合同
    contract_signed_date = models.DateTimeField('合同签订时间',blank=True,null=True)
    contract_approved = models.BooleanField(default=False,verbose_name="合同已经审核")  #谁审核
    contract_approved_date = models.DateTimeField('合同审核时间',blank=True, null=True)

    # ————————53PerfectCRM实现CRM客户报名流程缴费————————
    # Pay_cost = models.BooleanField(default=False, verbose_name="缴费")  # 缴费状态#是不是交定金
    # ————————53PerfectCRM实现CRM客户报名流程缴费————————

    class Meta:
        verbose_name = '学员报名表'
        verbose_name_plural = '学员报名表'
        unique_together = ('customer','class_grade')

    def __str__(self):
        return self.customer.name

class PaymentRecord(models.Model):
    """存储学员缴费记录"""
    enrollment = models.ForeignKey('StudentEnrollment',on_delete=models.CASCADE)
    payment_type_choice = (
        (0,'报名费'),
        (1,'学费'),
        (2,'退费'),
    )
    payment_type = models.SmallIntegerField(choices=payment_type_choice,default=0)
    amount = models.IntegerField('费用',default=500)
    consultant = models.ForeignKey('UserProFile', on_delete=models.CASCADE)  #费用缴给谁
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name = '学员缴费记录'
        verbose_name_plural = '学员缴费记录'

    def __str__(self):
        return self.enrollment

一：销售为想报名的学员提供链接

@login_required
def stu_enrollment(request):
    # 通过前端传来的id默认选中
    customer_id = int(request.GET.get('stu_id'))

    customer_objs = models.CustomerInfo.objects.all()
    class_objs = models.ClassList.objects.all()
    if request.method == "POST":
        customer_id = int(request.POST.get('customer_id'))
        class_grade_id = int(request.POST.get('class_grade_id'))
        # 顾问为当前用户
        try:
            enrollment_obj = models.StudentEnrollment.objects.create(
                customer_id = customer_id,
                class_grade_id = class_grade_id,
                consultant_id = request.user.id,
            )
        except IntegrityError as e:   # 已经生成过报名表
            enrollment_obj = models.StudentEnrollment.objects.get(customer_id = customer_id,class_grade_id=class_grade_id)
            if enrollment_obj.contract_agreed:
                return redirect('/crm/stu_enrollment/%s/contract_audit/' % enrollment_obj.id)
        enrollment_link = "http://localhost:8888/crm/enrollment/%s/" % enrollment_obj.id
    return render(request, 'crm/stu_enrollment.html',locals())

二：学员获取链接，进行填写信息，查阅合同，同意并上传证件信息

def enrollment(request,enrollment_id):
    """学员在线报名表"""
    enrollment_obj = models.StudentEnrollment.objects.get(id=enrollment_id)

    if enrollment_obj.contract_agreed:
        return HttpResponse('正在审核中，请耐心等待！')

    if enrollment_obj.contract_approved:
        return HttpResponse('审核已通过，请进行缴费操作')

    if request.method == "POST":
        print('POST',request.POST)
        # 为什么加instance=enrollment_obj.customer？？？
        customer_form = forms.CustomerInfoForm(instance=enrollment_obj.customer,data=request.POST)
        if customer_form.is_valid():
            customer_form.save()
            enrollment_obj.contract_agreed = True
            enrollment_obj.contract_signed_date = datetime.now()
            enrollment_obj.save()
            return HttpResponse('您已成功提交报名信息，请等待审核通过，欢迎加入打死都不退费的组织！')
        print('err',customer_form.errors)
    else:
        customer_form = forms.CustomerInfoForm(instance=enrollment_obj.customer)

    # 列出已上传文件
    uploaded_files = []
    enroolment_upload_dir = os.path.join(conf.settings.CRM_UPLOAD_FILE_DIR, enrollment_id)
    if os.path.isdir(enroolment_upload_dir):
        uploaded_files = os.listdir(enroolment_upload_dir)


    return render(request, 'crm/enrollment.html',locals())

==================

{% extends 'index.html' %}

{% block extra-css %}
    <link href="/static/plugins/dropzone/basic.css" rel="stylesheet">
    <link href="/static/plugins/dropzone/dropzone.css" rel="stylesheet">
{% endblock %}

{% block body %}
<div class="container">
    <div class="panel panel-success">
        <div class="panel-heading">
            <h3 class="panel-title">学员报名表</h3>
        </div>

        <div class="panel-body">
            <div>
               <form onsubmit="return BeforeFormSubmit(this);" class="form" method="post" novalidate>{% csrf_token %}
                    <!--循环field进行样式定制-->
                    {% for field in customer_form %}
                        <div class="form-group col-lg-6">
                            <label class="col-sm-2 control-label">{{field.label}}</label>
                            <div class="col-sm-10">
                                {{field}}
                                <span style="color:red;">{{field.errors.0}}</span>
                            </div>
                        </div>
                    {% endfor %}
                    <div class="form-group col-lg-6">
                        <label class="col-sm-2 control-label">班级</label>
                        <div class="col-sm-10">
                            <input type="text" class="form-control" value="{{enrollment_obj.class_grade}}" disabled="true">
                        </div>
                    </div>
                    <div class="form-group col-lg-6">
                        <label class="col-sm-2 control-label">学费</label>
                        <div class="col-sm-10">
                            <input type="text" class="form-control" value="{{enrollment_obj.class_grade.course.price}}" disabled="true">
                        </div>
                    </div>
                    <div class="form-group col-lg-12">
                        <div>
                            <pre style="height:200px;">{{enrollment_obj.class_grade.contract.content}}</pre>
                        </div>
                        <div>
                            <input type="checkbox" name="contract_agreed">
                            我已认真阅读，无条件同意
                        </div>
                    </div>

                    <div>
                        <input type="submit" class="btn btn-success pull-right" value="提交">
                    </div>

                </form>
            </div>

        </div>
        <div class="panel-body">
            <p>已上传文件列表：</p>
            <ul id="uploaded_file">
                {% for file in uploaded_files %}
                    <li>{{file}}</li>
                {% endfor %}
            </ul>


            <form action="{% url 'enrollment_fileupload' enrollment_obj.id %}" class="dropzone" id="myAwesomeDropzone">
              <div class="fallback">
                <input name="file" type="file" multiple />
              </div>
            </form>
        </div>
        <div class="panel-footer">Panel footer</div>
    </div>
</div>

<script>
    function BeforeFormSubmit(ele) {
        $(':disabled').removeAttr('disabled');
        if (!$('input[name="contract_agreed"]').prop('checked')){
            alert('请仔细阅读合同后再提交');
            return false;
        }
        if(!$('#uploaded_file').children().length){
            alert('请上传文件');
            return false;
        }
    }
</script>

{% endblock %}


{% block extra-js %}
    <script src="/static/plugins/dropzone/dropzone.js"></script>
    <script>
        // "myAwesomeDropzone" is the camelized version of the HTML element's ID
        Dropzone.options.myAwesomeDropzone = {
          paramName: "file", // The name that will be used to transfer the file
          maxFilesize: 2, // MB
          maxFiles:2,
          paralleUploads:1,
          accept: function(file, done) {
            if (file.name == "justinbieber.jpg") {
              done("Naha, you don't.");
            }
            else { done(); }
          }
        };


        $(function() {
          // Now that the DOM is fully loaded, create the dropzone, and setup the
          // event listeners
          // Prevent Dropzone from auto discovering this element:
          Dropzone.options.myAwesomeDropzone = false;
          var myDropzone = new Dropzone("#myAwesomeDropzone");
          myDropzone.on("success", function(file,response) {
            /* Maybe display some more file information on your page */
            console.log('complete',file,response);
            var response = JSON.parse(response);
            if (!response.status) {
                alert(response.err_msg);
            }else{
                $('#uploaded_file').append('<li>' + file.name + '</li>');
            }
          });
        })

    </script>

{% endblock %}

==================

from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def enrollment_fileupload(request,enrollment_id):
    enroolment_upload_dir = os.path.join(conf.settings.CRM_UPLOAD_FILE_DIR,enrollment_id)

    # 判断是否有目录
    if not os.path.isdir(enroolment_upload_dir):
        os.mkdir(enroolment_upload_dir)
    # 为什么要放if外边？？？？
    file_obj = request.FILES.get('file')
    # 最多两张
    if len(os.listdir(enroolment_upload_dir)) < 2:
        # 获取文件对象
        with open(os.path.join(enroolment_upload_dir,file_obj.name),'wb') as f:
            # 分块写入
            for chunks in file_obj.chunks():
                f.write(chunks)
    else:
        return HttpResponse(json.dumps({'status': False,'err_msg':'max upload limit 2'}))

    return HttpResponse(json.dumps({'status':True}))

三：销售审核学员注册信息,审核通过，为其生成账号（密码需要使用Django模块加密），发送邮件

from django.contrib.auth.hashers import make_password　　#用于生成密码

def create_stu_user(enrollment_obj):
    # 生成一个随机字符串
    account = "%s@qq.com" % enrollment_obj.customer.contact
    pwd = ''.join(random.sample(string.ascii_letters + string.digits, 8))
    ret_data_list = {'create_user':None,'add_stu':None,'send_email':None}
    # 创建一个账号
    # user = models.User.objects.create(
    #     username=account,
    #     password=make_password(pwd),
    # )

    try:
        # 创建一个用户
        userprofile = models.UserProFile.objects.get_or_create(email=account)[0]
        userprofile.name = enrollment_obj.customer.name
        userprofile.password = make_password(pwd)
        userprofile.last_login = datetime.now()
        userprofile.save()
        ret_data_list['create_user'] = "成功创建学员用户"
        print("创建用户",userprofile)
    except Exception as e:
        ret_data_list['create_user'] = "创建学员用户失败：%s" % e

    # 为用户绑定一个角色
    userprofile.role.add(models.Role.objects.get(name="学员"))
    print('绑定角色',userprofile.role.all())

    try:
        # 学员表，没有就创建，因为一个学生可以报多个班
        student_obj = models.Student.objects.get_or_create(customer=enrollment_obj.customer)[0]
        # 多对多添加数据
        student_obj.class_grade.add(enrollment_obj.class_grade_id)   # 实现一个学员多个班级
        student_obj.account = userprofile  # 实现一个学员一个用户
        student_obj.save()
        ret_data_list['add_stu'] = "成功添加学员"
        print('学员表账号',student_obj.account,'对象',student_obj)
    except Exception as e:
        ret_data_list['add_stu'] = "添加学员失败：%s" % e

    # 保存到学员表
    # models.Student.objects.create(
    #     customer=enrollment_obj.customer,
    #     class_grades=enrollment_obj.class_grade,
    #     account=userprofile,
    # )

    send_info = "账号：%s\n密码:%s" % (account, pwd)
    ret = auto_send_email(send_info,enrollment_obj)
    if ret['status']:
        ret_data_list['send_email'] = "邮件发送成功！"
    else:
        ret_data_list['add_stu'] = "邮件发送失败：%s" % ret['err_msg']

    return ret_data_list

@login_required
def contract_audit(request,enrollment_id):
    enrollment_obj = models.StudentEnrollment.objects.get(id=enrollment_id)

    if not enrollment_obj.contract_agreed:
        return HttpResponse('该学员还未提交报名表......')

    if enrollment_obj.contract_approved:
        return HttpResponse("审核已通过，等待学员缴费")

    if request.method == "POST":
        enrollment_form = forms.EnrollmentForm(instance=enrollment_obj,data=request.POST)
        if enrollment_form.is_valid():
            # 完善学生报名表信息
            enrollment_form.save()
            enrollment_obj.contract_approved = True
            enrollment_obj.contract_approved_date = datetime.now()
            enrollment_obj.customer.status = 1
            enrollment_obj.customer.save()
            enrollment_obj.save()

            # try:
            #     stu_obj = enrollment_obj.customer.student
            # except Exception:
            #     pass
            # else:
            #     return HttpResponse(
            #         "用户%s已添加--->账号为：%s" % (enrollment_obj.customer.name, enrollment_obj.customer.student.account.name))


            ret = create_stu_user(enrollment_obj)

            return HttpResponse("%s 审核通过，等待缴费" % ret)



            # return redirect('/kingadmin/crm/customerinfo/%s/change/' % enrollment_obj.customer.id)

    else:
        enrollment_form = forms.EnrollmentForm(instance=enrollment_obj)
    customer_form = forms.CustomerInfoForm(instance=enrollment_obj.customer)

    return render(request, 'crm/contract_audit.html',locals())

四、自动发送邮件

　　方式一：写Python脚本

import smtplib
from email.mime.text import MIMEText

def SendEmail(send_info,email_to):
    email = email_to   #设置收件地址
    mailto_list=[email]
    mail_host="smtp.qq.com"  #设置服务器
    mail_user="2430190125@qq.com"    #用户名
    mail_pass="xsickvzytoqtechd"   #口令
    msg = send_info     #Email内容
    msssageg = MIMEText(msg, _subtype='html', _charset='gb2312')    #创建一个实例，这里设置为html格式邮件
    msssageg['Subject'] = "python123"    #设置主题
    msssageg['From'] = "lujun<2430190125@qq.com>"   #发件地址
    msssageg['To'] = ";".join(mailto_list)
    try:
        s = smtplib.SMTP()
        s.connect(mail_host)  #连接smtp服务器
        s.login(mail_user,mail_pass)  #登陆服务器
        s.sendmail(mail_user, mailto_list, msssageg.as_string())  #发送邮件
        s.close()
        return {'status':True}
    except Exception as e:
        print(str(e))
        return {'status':False,'err_msg':e}

if __name__ == "__main__":
    SendEmail();

================

# python 脚本
    from crm import sendEmail
    email_to = "%s@qq.com" % enrollment_obj.customer.contact
    # 调用自定义发送函数
    ret = sendEmail.SendEmail(send_info,email_to)

　　方式二：Django自带邮件发送模块

　　　　（1）settings中配置

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.qq.com'
EMAIL_PORT = 25
EMAIL_HOST_USER = '2430190125@qq.com'
EMAIL_HOST_PASSWORD = '密码'
DEFAULT_FROM_EMAIL = 'lujun<2430190125@qq.com>'

EMAIL_TITLE = "欢迎加入"
EMAIL_CONTENT = "哈哈哈哈哈"
EMAIL_FROM = DEFAULT_FROM_EMAIL
EMAIL_TO = "123456789@qq.com"

　　　　（2）导入模块发送邮件

# django email 发送邮件,需要在settings中配置参数？？？？
    # from django.core.mail import send_mail
    # from django.conf import settings
    # email_title = settings.EMAIL_TITLE
    # email_content = settings.EMAIL_CONTENT
    # email_from = settings.EMAIL_FROM
    # email_to = settings.EMAIL_TO
    # send_status = send_mail(
    #     email_title,
    #     email_content,
    #     email_from,
    #     [email_to],
    #     fail_silently=False
    # )

day7:实现讲师和学员作业发布上传功能（其中由于多使用table浏览数据，可以自定义一个类似于form的基类，去统一实现table显示）

一：讲师功能

（1）可以看出上面多是table显示信息，下面自定义table_form类似于forms

import re

"""CustomBaseForm实现通过表数据显示table"""
class CustomBaseForm(object):
    display_list = []
    field_tag = {}
    attrs = {}
    extra_field = []

    def __init__(self,model,querysets):
        self.instance = model
        self.querysets = querysets
        self.th = []
        self.tr = []


    def register(self):
        for field in self.display_list:
            if field == "self":
                self.th.append(self.instance._meta.verbose_name)
                continue
            field_obj = self.instance._meta.get_field(field)
            self.th.append(field_obj.verbose_name)

        #自定义额外字段
        for item in self.extra_field:
            for k,v in item.items():
                if v.get("verbose_name"):
                    self.th.append(v.get("verbose_name"))
                else:
                    self.th.append(k)

        for query in self.querysets:
            tds = []
            for th in self.display_list:
                if th == "self":
                    field_val = "%s" % query
                elif len(self.instance._meta.get_field(th).choices) > 0:
                    field_val = "%s"%getattr(query,"get_%s_display"%th)()
                else:
                    field_val = "%s"%getattr(query,th)
                if self.field_tag.get(th):
                    # {"self": {"a": {"href": "127.0.0.1:8000","href": "127.0.0.1:8000"},"a": {"href": "127.0.0.1:8000"}}}
                    tags = self.field_tag.get(th)
                    # {"a": {"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}, "a": {"href": "127.0.0.1:8000"}}    #前面是内层，后面是外层
                    for k,v in tags.items():
                        # "a": {"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}
                        new_attr = []
                        for k1,v1 in v.items(): #{"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}
                            pat = re.compile("\{(.*?)\}")
                            res = pat.search(v1)
                            while res:
                                v1 = pat.sub(str(getattr(query,res.group(1))),v1,1)
                                res = pat.search(v1)

                            new_attr.append("%s='%s'"%(k1,v1))  #获取到所有的属性放在列表中
                        field_val = "<%s %s>%s</%s>"%(k," ".join(new_attr),field_val,k)
                tds.append(field_val)

            for item in self.extra_field:
                for e_k,e_v in item.items():
                    if e_v.get("value"):
                        field_val = "%s" % e_v.get("value")
                    else:
                        if hasattr(e_v.get("function"), "__call__"):  # 执行自定义方法
                            field_val = e_v.get("function")\
                                        (   # 参数
                                            getattr(query,e_v.get("model_attr")),
                                            *e_v.get("args",()),
                                            **e_v.get("kwargs",{})
                                        )
                        else:  # 执行内置方法
                            field_val = getattr(getattr(query,e_v.get("model_attr")),e_v.get("function"))\
                                                                                    (   # 参数
                                                                                        *e_v.get("args",()),
                                                                                        **e_v.get("kwargs",{})
                                                                                    )
                    if self.field_tag.get(e_k):
                        # {"self": {"a": {"href": "127.0.0.1:8000","href": "127.0.0.1:8000"},"a": {"href": "127.0.0.1:8000"}}}
                        tags = self.field_tag.get(e_k)
                        # {"a": {"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}, "a": {"href": "127.0.0.1:8000"}}    #前面是内层，后面是外层
                        for k,v in tags.items():
                            # "a": {"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}
                            new_attr = []
                            for k1,v1 in v.items(): #{"href": "127.0.0.1:8000", "href": "127.0.0.1:8000"}
                                pat = re.compile("\{(.*?)\}")
                                res = pat.search(v1)
                                while res:
                                    v1 = pat.sub(str(getattr(query, res.group(1))), v1, 1)
                                    res = pat.search(v1)
                                new_attr.append("%s='%s'"%(k1,v1))  #获取到所有的属性放在列表中
                            field_val = "<%s %s>%s</%s>"%(k," ".join(new_attr),field_val,k)
                    tds.append(field_val)

            self.tr.append(tds)

    def __str__(self):
        cls_attr = []
        if len(self.attrs):
            for item in self.attrs.items():
                cls_attr.append("%s='%s'"%(item[0],item[1]))

        tb = "<table %s>"%(" ".join(cls_attr))

        tr = "<thead><tr>"
        for th_data in self.th:
            th = "<th>%s</th>"%th_data
            tr += th
        tr += "</tr></thead><tbody>"

        tb += tr

        for tr_data in self.tr:
            tr = "<tr>"
            for td_data in tr_data:
                td = "<td>%s</td>"%td_data
                tr += td
            tr += "</tr>"
            tb += tr
        tb += "</tbody></table>"
        return tb

（2）使用方法

from kingadmin.custom_base_form import CustomBaseForm
from teacher.custom_form_func import student_score

class ClassListForm(CustomBaseForm):
    def __init__(self, model, querysets):
        super(ClassListForm, self).__init__(model, querysets)

    # self代表直接显示本条数据__str__
    display_list = ["self", "branch", "class_type", "start_date", "graduate_date"]
    # 在前面的标签会显示在内层,在显示的数据外面加上标签
    field_tag = {"self": {"a": {"href": "/kingadmin/crm/classlist/{id}/change/"}, },
                 "course_record": {"a": {"href": "/teacher/classlist/{id}/course_record.html"}},
                 "student": {"a": {"href": "/teacher/classlist/{id}/student_list.html"}}}
    attrs = {"class": "table table-hover"}   # 为table设置属性
    extra_field = [{"student": {'verbose_name': "学员数量", "model_attr": "student_set", "function": "count"}},
                   {"course_record": {"verbose_name": "上课记录", "value": "上课记录"}}]
    """
        额外自定义字段，若是有值value，会直接输出，
        否则会去当前实例集self.querysets的每一个实例中去获取相关的数据，
        使用函数去执行。字符串是调用自己的内置方法，function是调用自定义方法，
        同时可以使用"args"传递元组，"kwargs":传递字典作为参数
    """

===============

class StudentForm(CustomBaseForm):
    def __init__(self, model, querysets):
        super(StudentForm, self).__init__(model, querysets)

    display_list = ["self"]  # ,"couser","semester"
    field_tag = {"self": {"a": {"href": "/kingadmin/crm/student/{id}/change/"}, }, }  # 在前面的标签会显示在内层
    attrs = {"class": "table table-hover"}
    extra_field = [{"score": {'verbose_name': "学员成绩", "model_attr": "studyrecord_set",'args':'', "function": student_score}},
                   {"study_status": {"verbose_name": "出勤状况", "value": "N/A"}}]
    """
        额外自定义字段，若是有值value，会直接输出，
        否则会去当前实例集self.querysets的每一个实例中去获取相关的数据，
        使用函数去执行。字符串是调用自己的内置方法，function是调用自定义方法
    """

=================

class CourseRecordForm(CustomBaseForm):
    def __init__(self,model,querysets):
        super(CourseRecordForm, self).__init__(model,querysets)

    display_list = ["self","title","content","has_homework","homework","date"]   #,"couser","semester"
    field_tag = {"self":{"a":{"href":"/kingadmin/crm/courserecord/{id}/change/"},},}   #在前面的标签会显示在内层
    attrs = {"class":"table table-hover"}
    extra_field = []

（3）在views中调用各个tableform

from . import forms
from django.contrib.auth.decorators import login_required

def dashboard(request):
    return render(request, 'teacher/dashboard.html')

@login_required
def course_list(request):
    course_querysets = models.ClassList.objects.filter(
        teachers=request.user
    )

    #自定义form，用于table
    form = forms.ClassListForm(models.ClassList,course_querysets)
    form.register()

    return render(request,"teacher/course_list.html",locals())

@login_required
def student_list(request,c_id):
    student_querysets = models.ClassList.objects.filter(
        teachers = request.user,
        id = c_id
    ).get().student_set.all()

    form = forms.StudentForm(models.Student,student_querysets)
    form.register()

    return render(request,"teacher/student_list.html",locals())

@login_required
def course_record_list(request,c_id):
    course_querysets = models.ClassList.objects.filter(
        teachers = request.user,
        id= c_id
    ).get().courserecord_set.all()

    form = forms.CourseRecordForm(models.CourseRecord,course_querysets)
    form.register()

    return render(request, "teacher/course_record.html", locals())

（4）前端调用{{ form|safe }}，form是定义的tableform变量,实现简单显示页面

{% extends 'index.html' %}

{% load kingadmin_tag %}

{% block right-content-container %}

<div class="panel panel-primary">
    <div class="panel-heading">
        <h3 class="panel-title">课程列表</h3>
    </div>
    <div class="panel-body">
        {{ form|safe }}
    </div>
</div>
{% endblock %}

=================

{% extends 'index.html' %}

{% load kingadmin_tag %}

{% block right-content-container %}

<div class="panel panel-primary">
    <div class="panel-heading">
        <h3 class="panel-title">课程记录</h3>
    </div>
    <div class="panel-body">
        {{ form|safe }}
        <a href="{% url 'course_record_add' c_id %}" class="btn btn-primary">添加记录</a>
    </div>
</div>
{% endblock %}

=================

{% extends 'index.html' %}

{% load kingadmin_tag %}

{% block right-content-container %}

<div class="panel panel-primary">
    <div class="panel-heading">
        <h3 class="panel-title">学生列表</h3>
    </div>
    <div class="panel-body">
        {{ form|safe }}
    </div>
</div>
{% endblock %}

（5）添加记录

class CourseRecordForm(ModelForm):
    class Meta:
        model = models.CourseRecord #将表与元类中的数据关联
        fields = "__all__"
        checkbox_fields = []
        readonly_fields = []
        # exclude = ["teacher"]

    # 表单样式定制
    def __new__(cls, *args, **kwargs):
        return forms_handle.class_form(cls, cls.Meta, *args, **kwargs)

================

@login_required
def course_record_add(request, c_id):
    print(c_id)
    if request.method == "POST":
        form = crm_forms.CourseRecordForm(data=request.POST)
        if form.is_valid():
            form.save()
            return redirect('/teacher/classlist/%s/course_record.html/' % c_id)
    else:
        form = crm_forms.CourseRecordForm()
    print(form.errors)
    return render(request, 'teacher/course_record_add.html',locals())

==================

{% extends "index.html" %}
{% load kingadmin_tag %}

{% block right-content-container %}

<div class="panel panel-primary">
    <div class="panel-heading">
        <h3 class="panel-title">课程记录添加</h3>
    </div>
    <div class="panel-body">
        <form action="" method="post" class="form-group form-horizontal" novalidate>
        {% csrf_token %}
            {% for field in form %}
            <div class="col-sm-6">
                <div class="col-lg-6">
                    <label class="control-label">{{ field.label }}</label>
                </div>
                <div class="col-lg-12">
                    {{ field }}
                    <span style="color:red;">{{field.errors.0}}</span>
                </div>
            </div>
            {% endfor %}
            <div>
                <input type="submit" class="btn btn-primary" value="添加">
            </div>
        </form>
    </div>
</div>
{% endblock %}

二：学员功能，实现课程显示，作业提交

（一）根据邮件中的账号密码登录

（二）实现查看班级，查看课程记录，提交作业

 

（1）由于这里也是table多使用，可以继续使用tableform

from kingadmin.custom_base_form import CustomBaseForm

class CourseListForm(CustomBaseForm):
    display_list = ["self","class_type","start_date","graduate_date",]   #,"couser","semester"
    field_tag = {   #在前面的标签会显示在内层
                    "self":{"a":{"href":"127.0.0.1:8000"},},
                     'score':{"a":{"href":"127.0.0.1:8080"},},
                    'mng_homework':{"a":{"href":"/student/course.html"}}
                 }
    attrs = {"class":"table table-hover"}
    extra_field = [
                      {"score":{"verbose_name":"成绩","value":"成绩排名"}},
                      {"mng_homework":{'verbose_name':"作业管理","value":"作业管理"}},
                   ]

class CourseRecordForm(CustomBaseForm):
    def __init__(self,model,querysets):
        super(CourseRecordForm, self).__init__(model,querysets)

    display_list = ["self","title","teacher","content","has_homework","homework"]   #,"couser","semester"
    field_tag = {
                    "self":{"a":{"href":"127.0.0.1:8000"},},
                    'fin_homework':{"a":{"href":"/stu/homework/{id}.html"}}
                 }
    attrs = {"class":"table table-hover"}
    extra_field = [
                      {"date":{"verbose_name":"日期","model_attr":"date","function":"strftime","args":("%Y-%m-%d %H:%M:%S",)}},
                      {"fin_homework":{'verbose_name':"我的作业","value":"提交作业"}},
                   ]

（2）view中调用，显示班级和课程，前端也是{{form|safe}}

@login_required
def all_course(request):
    course_list = models.ClassList.objects.filter(
        student__customer__name = request.user.name
    ).all()
    form = table_forms.CourseListForm(models.ClassList, course_list)
    form.register()

    return render(request,"stu/course_list.html",locals())

@login_required
def course_record_list(request):
    # 必须优化为id，表结构设计时student与userProfile关联
    course_record = models.CourseRecord.objects.filter(
        class_grade__student__customer__name=request.user.name
    ).all()

    form = table_forms.CourseRecordForm(models.CourseRecord, course_record)
    form.register()

    return render(request,"stu/course_record.html",locals())

（3）使用form表单显示数据，使用Dropzone添加作业

from django.forms import ModelForm,forms
from crm import models

class CourseRecordForm(ModelForm):
    class Meta:
        model = models.CourseRecord #将表与元类中的数据关联
        fields = "__all__"
        exclude = ["has_homework"]

    def __new__(cls, *args, **kwargs):
        #这张表中的所有字段对象
        for field_name,field_obj in dict(cls.base_fields).items():
            field_obj.widget.attrs.update({'class':"form-control","disabled":"true"})

        return ModelForm.__new__(cls)

==================

@login_required
def homework(request, course_record_id):
    course_record_models = models.CourseRecord.objects.filter(id=course_record_id, has_homework=True)

    if not course_record_models.exists():
        return HttpResponse("无作业")

    course_record_info = course_record_models.get()
    course_dir = os.path.join(conf.settings.STUDENT_HOMEWORK_DIR, str(course_record_id), str(request.user.id))
    if not os.path.isdir(course_dir):
        os.makedirs(course_dir)

    file_info = []
    file_names = os.listdir(course_dir)
    for filename in file_names:
        file_info.append(os.stat(os.path.join(course_dir, filename)))

    if request.method == "GET":
        form = MyForms.CourseRecordForm(instance=course_record_info)
    else:
        status = {
            'status': True,
            "message": None
        }
        print(request.FILES)  # 需要去接收文件，前端状态才会是true
        if len(os.listdir(course_dir)) >= 2:
            status['status'] = False
            status['message'] = "文件超出上传个数"
            return HttpResponse(json.dumps(status))

        file_obj = request.FILES.get("file")

        with open(os.path.join(course_dir, file_obj.name), "wb") as fp:
            for chunks in file_obj.chunks():
                fp.write(chunks)

        return HttpResponse(json.dumps(status))

    return render(request, "stu/homework.html", locals())

（4）前端代码,使用Dropzone处理数据，以及ajax删除数据

{% extends "index.html" %}
{% load kingadmin_tag %}

{% block extra-link %}
<link rel="stylesheet" href="/static/plugins/dropzone/dropzone.css">
{% endblock %}


{% block right-content-container %}

<div class="panel panel-primary">
    <div class="panel-heading">
        <h3 class="panel-title">作业提交</h3>
    </div>
    <div class="panel-body">
        {{ form }}
        <div class="col-sm-12">
        <table class="table table-hover" id="file_table">
          <caption><label class="control-label" style="padding-top: 0px;">已上传的文件目录</label></caption>
          <thead>
            <tr>
              <th>文件名</th>
              <th>大小(KB)</th>
              <th>上传时间</th>
              <th>删除</th>
            </tr>
          </thead>
          <tbody>
            {% for file in file_info %}
                <tr>
                    <td>{% get_list_value file_names forloop.counter0  %}</td>
                    <td>{{ file.st_size }}</td>
                    <td>{% get_date_str file %}</td>
                    <td><span style="color: red;" class="glyphicon glyphicon-remove" onclick="deleteFile(this);"></span></td>
                </tr>
            {% endfor %}
          </tbody>
        </table>
        <form action="{% url 'homework' course_record_info.id %}" id="myAwesomeDropzone" class="dropzone">
            {% csrf_token %}
          <div class="fallback">
            <input name="file" type="file" multiple />
          </div>
        </form>
  </div>
    </div>
</div>
{% endblock %}

{% block extra-js %}
<script src="/static/plugins/dropzone/dropzone.js"></script>
<script>
$(function () {
    Dropzone.options.myAwesomeDropzone = {
      paramName: "file", // The name that will be used to transfer the file
      maxFilesize: 2, // MB
      maxFiles:2,
      parallelChunkUploads:true,
      accept: function(file, done) {
        if (file.name == "justinbieber.jpg") {
          done("Naha, you don't.");
        }
        else { done(); }
      },
      init: function() {
        this.on("success", function(file,respone) {
            /* Maybe display some more file information on your page */
            var rep = JSON.parse(respone)
            if(!rep.status){
                alert(rep.message);
                return;
            }else{
                var myDate = new Date();
                var str_tm = myDate.toLocaleString();
                str_tm = str_tm.replace(/\//g, "-");
                str_tm = str_tm.replace(/[\u4e00-\u9fa5]+/g, "");
                var tr = "<tr><td>"+file.name+"</td><td>"+file.size+"</td><td>"+str_tm+"</td><td>"+'<span style="color: red;"  onclick="deleteFile(this);" class="glyphicon glyphicon-remove"></span></td></tr>'
                $("#file_table").append(tr);
            }
        });
      }
    };
});


function deleteFile(ths){
    var filename = $($(ths).parents("tr").children()[0]).text()
    $.ajax({
        url:"/stu/delete_file.html",
        data:{'c':'{{ course_record_id }}','f':filename,'csrfmiddlewaretoken':'{{ csrf_token }}'},
        dataType:"json",
        type:"post",
        success:function(data){
            if(data.status){
                $(ths).parents("tr").remove()
            }else{
                alert(data.message)
            }
        }
    })
}

</script>

{% endblock %}

homework.html

（5）后台处理数据删除

@login_required
def delete_file(request):
    if request.method == "POST":
        status = {
            'status':True,
            'message':""
        }
        c_id = request.POST['c']
        filename = request.POST['f']
        print(c_id,filename)
        current_path = os.path.join(conf.settings.STUDENT_HOMEWORK_DIR, str(c_id), str(request.user.id))
        file_path = os.path.join(current_path,filename)
        print('文件路径',file_path)
        if not os.path.isfile(file_path):
            status['status']=False
            status['message'] = "没有权限"
            return HttpResponse(json.dumps(status))
        else:
            os.remove(file_path)

        return HttpResponse(json.dumps(status))

 总结：学会偷懒，化繁为简，学会总结业务，再去动态处理，而不是一直对数据库的增删改查，和重复一个业务逻辑