Django项目：CRM(客户关系管理系统)--67--57PerfectCRM实现admin批量生成上课记录

#admin.py
# ————————01PerfectCRM基本配置ADMIN————————
from django.contrib import admin
# Register your models here.
from crm import models #从crm导入models

# ————————24PerfectCRM实现King_admin自定义操作数据————————
from django.shortcuts import render
# ————————24PerfectCRM实现King_admin自定义操作数据————————

# ————————35PerfectCRM实现CRM重写Admin密码修改————————
from django import forms
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField
from crm.models import UserProfile
#重写admin
class UserCreationForm(forms.ModelForm):
    """　　一个表单来创建新用户。包括所有必需的
　　字段,加上重复密码。"""
    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)
    class Meta:
        model = UserProfile
        fields = ('email', 'name')
    def clean_password2(self):
        # 检查两个密码条目匹配
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError("密码不匹配")
        return password2
    def save(self, commit=True):
        #保存密码散列的格式提供
        user = super(UserCreationForm, self).save(commit=False)
        user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
        return user
#重写admin
class UserChangeForm(forms.ModelForm):
    """更新用户的一种形式。包括所有字段
　　用户,但取代了管理员的密码字段
　　密码散列显示领域。
    """
    password = ReadOnlyPasswordHashField(label="Password",
        help_text=("原始密码不存储,所以没有办法看到"
                    "这个用户的密码,但是你可以改变密码 "
                    "使用 <a href="../password/">修改密码</a>."))#哈值
    class Meta:
        model = UserProfile
        fields = ('email', 'password', 'name', 'is_active', 'is_superuser')
    def clean_password(self):
        # 不管用户提供什么,返回初始值。
        # 这是在这里,而不是在球场上,因为
        # 字段没有对初始值的访问
        return self.initial["password"]
#重写admin
class UserProfileAdmin(UserAdmin):#用户类,继承上一个类 UserAdmin
    # 单添加和更改用户实例
    form = UserChangeForm
    add_form = UserCreationForm

    # 字段用于显示用户模型。
    # 这些覆盖定义UserAdmin固定在底座上
    # auth.User引用特定字段。
    list_display = ('email', 'name','is_active', 'is_superuser', ) #显示字段表头
    list_filter = ('is_superuser',) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
    fieldsets = (                 #自定义显示字段
        (None, {'fields': ('email','name', 'password')}),
        ('个人信息', {'fields': ( 'email','name')}),
        ('用户权限', {'fields': ('is_active','is_superuser','groups','user_permissions')}),#后台显示配置
    )
    #添加自定义字段
    # 覆盖get_fieldsets时使用这个属性创建一个用户。
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'name', 'password1', 'password2')}
        ),
    )
    search_fields = ('email',) #搜索(不能包含CharField)（注意加 逗号 , ）
    ordering = ('email',) #自定义排序，默认'-id'
    filter_horizontal = ('groups','user_permissions', ) #复选框

# 现在注册这个新UserAdmin ,因为我们不在使用Django的内置权限
admin.site.register(UserProfile, UserProfileAdmin)
#注销 原来的  # admin.site.register(models.UserProfile)   #10账号表
# ————————35PerfectCRM实现CRM重写Admin密码修改————————

# ————————04PerfectCRM实现King_admin注册功能————————
class CustomerAdmin(admin.ModelAdmin):#定制Djanago admin
    list_display = ('id','qq','source','consultant','content','date')#显示字段表头
    # ————————11PerfectCRM实现King_admin分页显示条数————————
    list_per_page = 2  #分页条数
    # ————————11PerfectCRM实现King_admin分页显示条数————————
    # ————————16PerfectCRM实现King_admin日期过滤————————
    # ————————15PerfectCRM实现King_admin多条件过滤————————
    # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
    # list_filter = ('source','consultant','consult_courses',)
    list_filter = ('date','source','consultant','consult_courses',)
    # ————————15PerfectCRM实现King_admin多条件过滤————————
    # ————————16PerfectCRM实现King_admin日期过滤————————
    # ————————18PerfectCRM实现King_admin搜索关键字————————
    #搜索(不能包含CharField)（注意加 逗号 , ）
    search_fields = ('name','qq',)
    # ————————18PerfectCRM实现King_admin搜索关键字————————

    # ————————26PerfectCRM实现King_admin自定义排序————————
    ordering = ['-qq'] #自定义排序，默认'-id'
    # ————————26PerfectCRM实现King_admin自定义排序————————

    # ————————27PerfectCRM实现King_admin编辑复选框————————
    filter_horizontal = ('tags',) #复选框
    # ————————27PerfectCRM实现King_admin编辑复选框————————

    # ————————28PerfectCRM实现King_admin编辑限制————————
    readonly_fields = ('qq','consultant',) # 不可修改
    # ————————28PerfectCRM实现King_admin编辑限制————————



    # ————————24PerfectCRM实现King_admin自定义操作数据————————
    # from django.shortcuts import render
    actions = ['test_actions',]#定制功能    #测试返回到一个新页面
    def test_actions(self,request,arg2):#对应的函数 #request类自己的请求  #arg2类的内容
        return render(request,"king_admin/table_index.html")
    test_actions.short_description = "测试显示中文"
    # ————————24PerfectCRM实现King_admin自定义操作数据————————
# ————————04PerfectCRM实现King_admin注册功能————————

#注册到 Django Admin里
admin.site.register(models.Branch)                  #01校区表
admin.site.register(models.ClassList)               #02班级表
admin.site.register(models.Course)                  #03课程表，可以报名那些课程

# ————————04PerfectCRM实现King_admin注册功能————————
# admin.site.register(models.Customer)                #04客户信息表
admin.site.register(models.Customer,CustomerAdmin)                #04客户信息表
# ————————04PerfectCRM实现King_admin注册功能————————

# ————————48PerfectCRM实现CRM客户报名流程学生合同————————
admin.site.register(models.ContractTemplate)            #合同模版
# ————————48PerfectCRM实现CRM客户报名流程学生合同————————

admin.site.register(models.CustomerFollowUp)        #05客户跟进表

# ————————57PerfectCRM实现admin批量生成上课记录————————
# admin.site.register(models.Enrollment)              #06学员报名信息表
# admin.site.register(models.Payment)                 #07缴费记录表
# admin.site.register(models.CourseRecord)            #08每节课上课纪录表
# admin.site.register(models.StudyRecord)             #09学习纪录

# 06学员报名信息表
class EnrollmentAdmin(admin.ModelAdmin):
    list_display = ['id', 'customer', 'enrolled_class', 'consultant', 'Pay_cost', 'date']  # 显示字段表头
    list_filter = ('enrolled_class','consultant', 'Pay_cost',) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）

#07缴费记录表
class PaymentAdmin(admin.ModelAdmin):
    list_display = ['id', 'customer','course', 'amount', 'consultant', 'date']  # 显示字段表头
    list_filter = ('customer','course',  'consultant', ) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）

from django.shortcuts import render,HttpResponse,redirect
#08每节课上课纪录表
class CourseRecordAdmin(admin.ModelAdmin):
    list_display = ['id','from_class','day_num','teacher','has_homework','homework_title','homework_content','outline','date']  #显示字段表头
    list_filter = ('from_class','teacher','date') # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
    def initialize_studyrecords(self,request,queryset):#制定功能
        print('initialize_studyrecords',self,request,queryset)
        if len(queryset)>1:
            return HttpResponse("同时只能选择一个班级！")
        print('获取对应的学员',queryset[0].from_class.enrollment_set.all()) # _set反向查询
        new_obj_list=[]#用于批量创建事务  #防止数据库事物回滚
        for enrll_obj in queryset[0].from_class.enrollment_set.all():#创建学习记录
        #     models.StudyRecord.objects.get_or_create(       #get_or_ #防止报错
        #         student=enrll_obj,#对应学员
        #         course_record=queryset[0],
        #         attendance=0,#签到状态,默认签到,
        #         score=0,#成绩
        #     )
                #防止数据库事物回滚    #"""09学习纪录"""
            new_obj_list.append(models.StudyRecord(
                student=enrll_obj,#对应学员
                course_record=queryset[0],  #班级#节课
                attendance=0,#签到状态,默认签到,
                score=0,#成绩
            ))


        try:
            course_record_id_list= models.StudyRecord.objects.values_list('course_record_id')#每节课上课纪录表ID列表
            queryset_id=(int(queryset[0].id),)#数字转元组
            if queryset_id not in course_record_id_list: #列表是元组
                models.StudyRecord.objects.bulk_create(new_obj_list)  # bulk_create批量创建数据库事物 #统一最后保存
                print('批量创建成功！')
        except Exception as e:
            return HttpResponse('批量创建失败,本节课可能有相应的上课记录')
        return redirect("/admin/crm/studyrecord/?course_record__id__exact=%s"%queryset[0].id)#学习记录 #加上过滤
    actions = ['initialize_studyrecords',]
    initialize_studyrecords.short_description = "创建班级本节上课记录"#显示别名

#09学习纪录
class StudyRecordAdmin(admin.ModelAdmin):
    list_display = ['id','student','course_record','attendance','score','date']   #显示字段表头
    list_filter =['course_record','attendance','score','course_record__from_class','student']# 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
    list_editable = ['score','attendance']#可编辑   #用于上课点名 批改成绩

admin.site.register(models.Enrollment,EnrollmentAdmin)              #06学员报名信息表
admin.site.register(models.Payment,PaymentAdmin)                    #07缴费记录表
admin.site.register(models.CourseRecord,CourseRecordAdmin)          #08每节课上课纪录表
admin.site.register(models.StudyRecord,StudyRecordAdmin)            #09学习纪录
# ————————57PerfectCRM实现admin批量生成上课记录————————

# ————————35PerfectCRM实现CRM重写Admin密码修改————————
# admin.site.register(models.UserProfile)             #10账号表
# ————————35PerfectCRM实现CRM重写Admin密码修改————————

admin.site.register(models.Role)                    #11角色表
admin.site.register(models.Tag)                     #12标签表

'''
Django Admin里账号密码重置方法
#运行 Terminal  

python manage.py createsuperuser

Username :              admin
Email address:          admin@qq.com
Password:               admin123456
Password (again):       admin123456


英文转中文方法
到settings.py里修改
# LANGUAGE_CODE = 'en-us'
LANGUAGE_CODE = 'zh-Hans'
'''

# ————————01PerfectCRM基本配置ADMIN————————

#models.py

# ————————01PerfectCRM基本配置ADMIN————————

from django.db import models
# Create your models here.

"""
#运行 Terminal
#    生成 数据表
#    python manage.py makemigrations
#   数据表 迁移
#    python manage.py migrate
"""

"""01校区表"""
class Branch(models.Model):
    name = models.CharField(max_length=128,unique=True) #校区名#CharField作用是保存文本，定长的变量类型
    addr = models.CharField(max_length=128) #地址
    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return self.name #返回 #校区名
    class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural =  "01校区表" #verbose_name_plural给你的模型类起一个更可读的名字

"""02班级表"""
class ClassList(models.Model):
    #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    branch = models.ForeignKey("Branch",on_delete=models.CASCADE)#校区    关联到  校区表
    course = models.ForeignKey("Course",on_delete=models.CASCADE) #课程   关联到   课程表

    # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
    contract = models.ForeignKey('ContractTemplate', blank=True, null=True, default=1,on_delete=models.CASCADE)  # 合同表
    # ————————48PerfectCRM实现CRM客户报名流程学生合同————————

    class_type_choices = ( #上课形式
                          (0,'面授(脱产)'),
                          (1,'面授(周末)'),
                          (2,'网络班'),)
    #PositiveSmallIntegerField正小整数 0 ～ 32767 #choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
    class_type = models.SmallIntegerField(choices=class_type_choices)#上课形式

    #PositiveSmallIntegerField正小整数 0 ～ 32767
    semester = models.PositiveSmallIntegerField(verbose_name="学期") #课程的第几期

    #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。
    teachers = models.ManyToManyField("UserProfile") # 老师   关联到    账号表

    start_date = models.DateField(verbose_name="开班日期") #DateField 日期格式 YYYY-MM-DD #verbose_name是Admin中显示的字段名称

    # DateField 日期格式 YYYY-MM-DD #verbose_name是Admin中显示的字段名称 #Django可空#数据库可以为空
    end_date = models.DateField(verbose_name="结业日期",blank=True,null=True)

    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return "%s %s %s" %(self.branch,self.course,self.semester) #返回 #%s格式化输出字符串 #校区#课程# 学期
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        unique_together=('branch','course','semester')  #联合索引
        verbose_name_plural = "02班级表" #verbose_name_plural给你的模型类起一个更可读的名字

"""03课程表，可以报名那些课程"""
class Course(models.Model):
    name = models.CharField(max_length=64,unique=True)#课程名 #CharField作用是保存文本，定长的变量类型
    price = models.PositiveSmallIntegerField(verbose_name="学费")#学费#PositiveSmallIntegerField正小整数 0 ～ 32767
    period = models.PositiveSmallIntegerField(verbose_name="周期（月）") #PositiveSmallIntegerField正小整数 0 ～ 32767
    outline = models.TextField() #课程大纲  #文本类型
    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return self.name #返回 #课程名
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural =  "03课程表"#verbose_name_plural给你的模型类起一个更可读的名字

'''04客户信息表'''
class Customer(models.Model):
    name = models.CharField(max_length=32,blank=True,null=True)#客户名#CharField定长文本 #名字最长32 # Django可空 #数据库可以为空
    qq = models.CharField(max_length=64,unique=True) #QQ号#CharField定长文本 #名字最长64 #唯一，不能重复
    qq_name = models.CharField(max_length=64,blank=True,null=True)#QQ名 #CharField定长文本 #名字最长64 # Django可空 #数据库可以为空
    phone = models.CharField(max_length=64,blank=True,null=True)#手机号 #CharField定长文本 #名字最长64 # Django可空 #数据库可以为空

    # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
    id_num=models.CharField(max_length=64,blank=True,null=True,verbose_name='身份证号')#身份证号
    email=models.EmailField(max_length=64,blank=True,null=True,verbose_name='邮箱')#email
    sex_choices=((0,'保密'),(1,'男'),(2,'女'))
    sex=models.SmallIntegerField(choices=sex_choices,default=0,verbose_name='性别')
    # ————————48PerfectCRM实现CRM客户报名流程学生合同————————

    # ————————53PerfectCRM实现CRM客户报名流程缴费————————
    status_choices = ((0, '已报名'), (1, '未报名'), (2, '已退学'))
    status = models.SmallIntegerField(choices=status_choices, default=1)  # 学员状态
    # ————————53PerfectCRM实现CRM客户报名流程缴费————————

    source_choices = ( #客户渠道来源 （内存生成）
                      (0,'转介绍'),
                      (1,'QQ群'),
                      (2,'官网'),
                      (3,'百度推广'),
                      (4,'51CTO'),
                      (5,'知乎'),
                      (6,'市场推广'),)
    #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
    source = models.SmallIntegerField(choices=source_choices)#客户渠道来源

    #CharField定长文本#verbose_name是Admin中显示的字段名称#名字最长64 # Django可空 #数据库可以为空
    referral_from = models.CharField(verbose_name="转介绍人qq",max_length=64,blank=True,null=True) #来自谁介绍的

    #ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    consult_courses = models.ForeignKey("Course",verbose_name="咨询课程", on_delete=models.CASCADE) #关联到 课程表

    content= models.TextField(verbose_name="咨询详情") #TextField无限制长度的文本#verbose_name是Admin中显示的字段名称

    #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。
    tags = models.ManyToManyField("Tag",blank=True)#多对多关联到 标签表

    #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    consultant = models.ForeignKey("UserProfile", on_delete=models.CASCADE) #关联到  账号表

    memo = models.TextField(blank=True,null=True)#备注#TextField无限制长度的文本#Django可空#数据库可以为空

    #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date =  models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）

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

    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural =  "04客户表" #verbose_name_plural给你的模型类起一个更可读的名字

# ————————48PerfectCRM实现CRM客户报名流程学生合同————————
#合同模版
class ContractTemplate(models.Model):
    name=models.CharField('合同名称',max_length=64,unique=True)
    template=models.TextField()

    def __str__(self):
        return self.name
    class Meta:
        verbose_name_plural='合同表'
# ————————48PerfectCRM实现CRM客户报名流程学生合同————————


"""05客户跟进表"""
class CustomerFollowUp(models.Model):

    #ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    customer = models.ForeignKey("Customer", on_delete=models.CASCADE)#客户名 #关联到  客户信息表

    content = models.TextField(verbose_name="跟进内容")#跟进的内容#TextField无限制长度的文本#verbose_name是Admin中显示的字段名称

    #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    consultant =models.ForeignKey("UserProfile", on_delete=models.CASCADE) #关联到  账号表

    intention_choices =(  #报名状态
                        (0,'2周内报名'),
                        (1,'1个月内报名'),
                        (2,'近期无报名计划'),
                        (3,'已在其它机构报名'),
                        (4,'已报名'),
                        (5,'已拉黑'),)
    #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
    intention=models.SmallIntegerField(choices=intention_choices) #报名状态

    #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date =  models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）

    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return "<%s:%s>" %(self.customer.qq,self.intention) #返回#格式化字符串#跨表里的QQ号#报名状态
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural =  "05客户跟进表"#verbose_name_plural给你的模型类起一个更可读的名字

"""06学员报名信息表"""
class Enrollment(models.Model):
    # ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    customer = models.ForeignKey("Customer",on_delete=models.CASCADE)#学员名字 #关联到  客户信息表
    enrolled_class = models.ForeignKey("ClassList",verbose_name="所报班级",on_delete=models.CASCADE)#关联到  班级表
    consultant = models.ForeignKey("UserProfile",verbose_name="课程顾问",on_delete=models.CASCADE) #关联到  账号表

    # ————————52PerfectCRM实现CRM客户报名流程学生合同审核————————
    contract_review = models.CharField(max_length=256, blank=True, null=True, verbose_name="合同审核")  # 合同审核
    # ————————52PerfectCRM实现CRM客户报名流程学生合同审核————————

    #BooleanField布尔值类型#default=False默认(True)不允许出现空字符#verbose_name是Admin中显示的字段名称
    contract_agreed = models.BooleanField(default=False,verbose_name="学员已经同意合同")#学员看合同
    contract_approved = models.BooleanField(default=False,verbose_name="合同已经审核") #谁审核

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

    # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date = models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）

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

        # ————————57PerfectCRM实现admin批量生成上课记录————————
        # return "%s %s" %(self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
        return " 学员:%s |QQ: %s |班级:%s" %(self.customer.name,self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
        # ————————57PerfectCRM实现admin批量生成上课记录————————

    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        unique_together =  ("customer","enrolled_class")#联合索引
        verbose_name_plural =  "06学员报名信息表"#verbose_name_plural给你的模型类起一个更可读的名字

"""07缴费记录表"""
class Payment(models.Model):
    #ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    customer = models.ForeignKey("Customer",on_delete=models.CASCADE)#学员名字        关联到  客户信息表
    course = models.ForeignKey("Course",verbose_name="所报课程",on_delete=models.CASCADE)#关联到  课程表

    #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称#默认值=500
    amount = models.PositiveIntegerField(verbose_name="数额",default=500)#缴费数额

    #ForeignKey就是表与表之间的某种约定的关系#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    consultant = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#缴费给谁 关联到  账号表 #财务人员

    #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date=models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）

    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return "%s %s" %(self.customer,self.amount)#返回#格式化字符串#学员名字#缴费数额
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural = "07缴费记录表"#verbose_name_plural给你的模型类起一个更可读的名字

"""08每节课上课纪录表"""
class CourseRecord(models.Model):
    # ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    from_class = models.ForeignKey("ClassList",verbose_name="班级",on_delete=models.CASCADE) #那个班级

    #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称
    day_num = models.PositiveSmallIntegerField(verbose_name="第几节(天)") #第几节课

    # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    teacher = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#老师是谁    关联到    账号表

    #BooleanField布尔值类型#default=True默认(True)不允许出现空字符
    has_homework = models.BooleanField(default=True) #有没有作业

    # CharField定长文本#名字最长128#Django可空#数据库可以为空
    homework_title = models.CharField(max_length=128,blank=True,null=True) #作业标题

    #TextField无限制长度的文本#Django可空#数据库可以为空
    homework_content = models.TextField(blank=True,null=True) #作业内容

    #TextField无限制长度的文本#verbose_name是Admin中显示的字段名称
    outline =models.TextField(verbose_name="本节课程大纲") #课程主要讲什么

    # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date = models.DateField(auto_now_add=True)#创建时间（数据库自增）

    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return " %s:%s" %(self.from_class,self.day_num)#返回#格式化字符串#班级#第几节(天)
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        unique_together = ("from_class","day_num") #联合索引
        verbose_name_plural = "08每节课上课纪录表" #verbose_name_plural给你的模型类起一个更可读的名字

"""09学习纪录"""
class StudyRecord(models.Model):
    # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
    student = models.ForeignKey("Enrollment",on_delete=models.CASCADE)#学生名字   关联到    学员报名信息表
    course_record = models.ForeignKey("CourseRecord",on_delete=models.CASCADE)#开课记录   # 关联到    每节课上课纪录表

    attendance_choices = (# 本节课上课状态记录
                            (0,"已签到"),
                            (1,"迟到"),
                            (2,"缺勤"),
                            (3,"早退"),)
    #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
    attendance = models.SmallIntegerField(choices=attendance_choices) # 本节课上课状态记录

    score_choices = (#学习成绩
                     (100,"A+"),
                     (90,"A"),
                     (85,"B+"),
                     (80,"B"),
                     (75,"B-"),
                     (70,"C+"),
                     (65,"C"),
                     (40,"C-"),
                     (-20,"D"),
                     (-50,"COPY"),
                     (0,"N/A"),)
    #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
    score = models.SmallIntegerField(choices=score_choices) #学习成绩

    memo = models.TextField(blank=True,null=True)#TextField无限制长度的文本#Django可空#数据库可以为空

    # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
    date = models.DateField(auto_now_add=True)#创建时间（数据库自增）

    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return "%s %s %s" % (self.student, self.course_record, self.score)#返回#格式化字符串#学生名字#开课记录#学习成绩
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        unique_together = ('student','course_record')#联合索引#学生名字#开课记录
        verbose_name_plural =  "09学习纪录"#verbose_name_plural给你的模型类起一个更可读的名字

# ————————34PerfectCRM实现CRM自定义用户————————
# """10账号表"""
# class UserProfile(models.Model):
#     from django.contrib.auth.models import User  # 使用django内置的用户表
#
#     #OneToOneField一对一  #User是django Admin里的账号表#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
#     user = models.OneToOneField(User,on_delete=models.CASCADE)# 用户名 #创建外键，关联django用户表
#
#     name = models.CharField(max_length=32) #账号名（扩展用户字段）#CharField定长文本
#
#     #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。#Django可空
#     roles = models.ManyToManyField("Role",blank=True) #角色(权限)   # 双向一对多==多对多
#
#     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
#         return self.name #返回 #账号名
#     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
#         verbose_name_plural = "10账号表"#verbose_name_plural给你的模型类起一个更可读的名字
# ————————34PerfectCRM实现CRM自定义用户————————

# ————————34PerfectCRM实现CRM自定义用户————————
#10账号表，创建用户和超级用户
from django.contrib.auth.models import BaseUserManager
class UserProfileManager(BaseUserManager):
    def create_user(self, email, name, password=None):
        """
    　　创建并保存一个用户用给定的邮件,日期
    　　出生和密码。
        """
        if not email:#没有email 报错
            raise ValueError('用户必须有一个电子邮件地址')

        user = self.model(
            email=self.normalize_email(email),#验证邮箱格式
            name=name,
        )
        user.set_password(password)#加密
        user.is_active = True
        user.save(using=self._db)
        return user
    def create_superuser(self, email, name, password):
        """
    　　创建并保存一个超级用户具有给定邮件,日期
    　　出生和密码。
        """
        user = self.create_user(email,
            password=password,
            name=name
        )
        user.is_active = True
        user.is_superuser = True
        user.save(using=self._db)
        return user

"""10账号表"""
"""

#删除数据库

#调用objects = UserProfileManager()#创建账号 #关联这个函数

#运行 Terminal
#    生成 数据表
#    python manage.py makemigrations
#   数据表 迁移
#    python manage.py migrate
Django Admin里账号密码重置方法
#运行 Terminal  
python manage.py createsuperuser

Email address:          admin@qq.com
用户名 :                 admin
Password:               admin123456
Password (again):       admin123456
"""
from django.contrib.auth.models import AbstractBaseUser
# ————————35PerfectCRM实现CRM重写Admin密码修改————————
from django.utils.translation import ugettext_lazy as _  # 语言国际化
from django.utils.safestring import mark_safe
from django.contrib.auth.models import PermissionsMixin
# class UserProfile(AbstractBaseUser):
class UserProfile(AbstractBaseUser,PermissionsMixin):
# ————————35PerfectCRM实现CRM重写Admin密码修改————————
    email=models.EmailField(
        verbose_name='邮箱账号',
        max_length=255,
        unique=True#唯一  #登陆账号
    )
    name=models.CharField(max_length=32,verbose_name='用户名')

    # ————————35PerfectCRM实现CRM重写Admin密码修改————————
    password = models.CharField(_('password'), max_length=128, help_text=mark_safe('''<a href="../password/">修改密码</a>'''))
    # ————————35PerfectCRM实现CRM重写Admin密码修改————————

    is_active = models.BooleanField(default=True,verbose_name='合法账号')#权限#合法账号
    is_superuser = models.BooleanField(default=False,verbose_name='超级账号') #超级账号
    objects = UserProfileManager()#创建账号 #关联这个函数
    USERNAME_FIELD ='email'#指定做为  #登陆账号
    REQUIRED_FIELDS = ['name']#必填字段
    def get_full_name(self):
        return self.email
    def get_short_name(self):
        #用户确认的电子邮件地址
        return self.email
    def __str__(self):
        return self.name
    def has_perm(self,perm,obj=None):
        #指明用户是否被认为活跃的。以反选代替删除帐号。
        #最简单的可能的答案:是的,总是
        return True   #有效 账号
    def has_module_perms(self, app_label):
        #指明用户是否可以登录到这个管理站点。
        # 最简单的可能的答案:是的,总是
        return True #职员状态
    @property
    def is_staff(self):
        '''“用户的员工吗?”'''
        #最简单的可能的答案:所有管理员都是员工
        return self.is_superuser#是不是超级用户状态
# AUTH_USER_MODEL = 'crm.UserProfile'#使用自定的admin 表单   #settings.py
# ————————34PerfectCRM实现CRM自定义用户————————

"""11角色表"""
class Role(models.Model):
    name = models.CharField(unique=True,max_length=32)#角色名#CharField定长文本#角色名不可以重复#最长度=32字节
    def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return self.name#返回 #角色名
    class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural = "11角色表" #verbose_name_plural给你的模型类起一个更可读的名字

"""12标签表"""
class Tag(models.Model):
    name =  models.CharField(max_length=64,unique=True) #标签名#CharField定长文本#最长度=64字节#不可以重复
    def __str__(self): #__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
        return self.name #返回 #标签名
    class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
        verbose_name_plural =  "12标签表" #verbose_name_plural给你的模型类起一个更可读的名字

# ————————01PerfectCRM基本配置ADMIN————————