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

  1 #admin.py
  2 # ————————01PerfectCRM基本配置ADMIN————————
  3 from django.contrib import admin
  4 # Register your models here.
  5 from crm import models #从crm导入models
  6 
  7 # ————————24PerfectCRM实现King_admin自定义操作数据————————
  8 from django.shortcuts import render
  9 # ————————24PerfectCRM实现King_admin自定义操作数据————————
 10 
 11 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
 12 from django import forms
 13 from django.contrib.auth.admin import UserAdmin
 14 from django.contrib.auth.forms import ReadOnlyPasswordHashField
 15 from crm.models import UserProfile
 16 #重写admin
 17 class UserCreationForm(forms.ModelForm):
 18     """　　一个表单来创建新用户。包括所有必需的
 19 　　字段,加上重复密码。"""
 20     password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
 21     password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)
 22     class Meta:
 23         model = UserProfile
 24         fields = ('email', 'name')
 25     def clean_password2(self):
 26         # 检查两个密码条目匹配
 27         password1 = self.cleaned_data.get("password1")
 28         password2 = self.cleaned_data.get("password2")
 29         if password1 and password2 and password1 != password2:
 30             raise forms.ValidationError("密码不匹配")
 31         return password2
 32     def save(self, commit=True):
 33         #保存密码散列的格式提供
 34         user = super(UserCreationForm, self).save(commit=False)
 35         user.set_password(self.cleaned_data["password1"])
 36         if commit:
 37             user.save()
 38         return user
 39 #重写admin
 40 class UserChangeForm(forms.ModelForm):
 41     """更新用户的一种形式。包括所有字段
 42 　　用户,但取代了管理员的密码字段
 43 　　密码散列显示领域。
 44     """
 45     password = ReadOnlyPasswordHashField(label="Password",
 46         help_text=("原始密码不存储,所以没有办法看到"
 47                     "这个用户的密码,但是你可以改变密码 "
 48                     "使用 <a href="../password/">修改密码</a>."))#哈值
 49     class Meta:
 50         model = UserProfile
 51         fields = ('email', 'password', 'name', 'is_active', 'is_superuser')
 52     def clean_password(self):
 53         # 不管用户提供什么,返回初始值。
 54         # 这是在这里,而不是在球场上,因为
 55         # 字段没有对初始值的访问
 56         return self.initial["password"]
 57 #重写admin
 58 class UserProfileAdmin(UserAdmin):#用户类,继承上一个类 UserAdmin
 59     # 单添加和更改用户实例
 60     form = UserChangeForm
 61     add_form = UserCreationForm
 62 
 63     # 字段用于显示用户模型。
 64     # 这些覆盖定义UserAdmin固定在底座上
 65     # auth.User引用特定字段。
 66     list_display = ('email', 'name','is_active', 'is_superuser', ) #显示字段表头
 67     list_filter = ('is_superuser',) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
 68     fieldsets = (                 #自定义显示字段
 69         (None, {'fields': ('email','name', 'password')}),
 70         ('个人信息', {'fields': ( 'email','name')}),
 71         ('用户权限', {'fields': ('is_active','is_superuser','groups','user_permissions')}),#后台显示配置
 72     )
 73     #添加自定义字段
 74     # 覆盖get_fieldsets时使用这个属性创建一个用户。
 75     add_fieldsets = (
 76         (None, {
 77             'classes': ('wide',),
 78             'fields': ('email', 'name', 'password1', 'password2')}
 79         ),
 80     )
 81     search_fields = ('email',) #搜索(不能包含CharField)（注意加 逗号 , ）
 82     ordering = ('email',) #自定义排序，默认'-id'
 83     filter_horizontal = ('groups','user_permissions', ) #复选框
 84 
 85 # 现在注册这个新UserAdmin ,因为我们不在使用Django的内置权限
 86 admin.site.register(UserProfile, UserProfileAdmin)
 87 #注销 原来的  # admin.site.register(models.UserProfile)   #10账号表
 88 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
 89 
 90 # ————————04PerfectCRM实现King_admin注册功能————————
 91 class CustomerAdmin(admin.ModelAdmin):#定制Djanago admin
 92     list_display = ('id','qq','source','consultant','content','date')#显示字段表头
 93     # ————————11PerfectCRM实现King_admin分页显示条数————————
 94     list_per_page = 2  #分页条数
 95     # ————————11PerfectCRM实现King_admin分页显示条数————————
 96     # ————————16PerfectCRM实现King_admin日期过滤————————
 97     # ————————15PerfectCRM实现King_admin多条件过滤————————
 98     # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
 99     # list_filter = ('source','consultant','consult_courses',)
100     list_filter = ('date','source','consultant','consult_courses',)
101     # ————————15PerfectCRM实现King_admin多条件过滤————————
102     # ————————16PerfectCRM实现King_admin日期过滤————————
103     # ————————18PerfectCRM实现King_admin搜索关键字————————
104     #搜索(不能包含CharField)（注意加 逗号 , ）
105     search_fields = ('name','qq',)
106     # ————————18PerfectCRM实现King_admin搜索关键字————————
107 
108     # ————————26PerfectCRM实现King_admin自定义排序————————
109     ordering = ['-qq'] #自定义排序，默认'-id'
110     # ————————26PerfectCRM实现King_admin自定义排序————————
111 
112     # ————————27PerfectCRM实现King_admin编辑复选框————————
113     filter_horizontal = ('tags',) #复选框
114     # ————————27PerfectCRM实现King_admin编辑复选框————————
115 
116     # ————————28PerfectCRM实现King_admin编辑限制————————
117     readonly_fields = ('qq','consultant',) # 不可修改
118     # ————————28PerfectCRM实现King_admin编辑限制————————
119 
120 
121 
122     # ————————24PerfectCRM实现King_admin自定义操作数据————————
123     # from django.shortcuts import render
124     actions = ['test_actions',]#定制功能    #测试返回到一个新页面
125     def test_actions(self,request,arg2):#对应的函数 #request类自己的请求  #arg2类的内容
126         return render(request,"king_admin/table_index.html")
127     test_actions.short_description = "测试显示中文"
128     # ————————24PerfectCRM实现King_admin自定义操作数据————————
129 # ————————04PerfectCRM实现King_admin注册功能————————
130 
131 #注册到 Django Admin里
132 admin.site.register(models.Branch)                  #01校区表
133 admin.site.register(models.ClassList)               #02班级表
134 admin.site.register(models.Course)                  #03课程表，可以报名那些课程
135 
136 # ————————04PerfectCRM实现King_admin注册功能————————
137 # admin.site.register(models.Customer)                #04客户信息表
138 admin.site.register(models.Customer,CustomerAdmin)                #04客户信息表
139 # ————————04PerfectCRM实现King_admin注册功能————————
140 
141 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
142 admin.site.register(models.ContractTemplate)            #合同模版
143 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
144 
145 admin.site.register(models.CustomerFollowUp)        #05客户跟进表
146 
147 # ————————57PerfectCRM实现admin批量生成上课记录————————
148 # admin.site.register(models.Enrollment)              #06学员报名信息表
149 # admin.site.register(models.Payment)                 #07缴费记录表
150 # admin.site.register(models.CourseRecord)            #08每节课上课纪录表
151 # admin.site.register(models.StudyRecord)             #09学习纪录
152 
153 # 06学员报名信息表
154 class EnrollmentAdmin(admin.ModelAdmin):
155     list_display = ['id', 'customer', 'enrolled_class', 'consultant', 'Pay_cost', 'date']  # 显示字段表头
156     list_filter = ('enrolled_class','consultant', 'Pay_cost',) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
157 
158 #07缴费记录表
159 class PaymentAdmin(admin.ModelAdmin):
160     list_display = ['id', 'customer','course', 'amount', 'consultant', 'date']  # 显示字段表头
161     list_filter = ('customer','course',  'consultant', ) # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
162 
163 from django.shortcuts import render,HttpResponse,redirect
164 #08每节课上课纪录表
165 class CourseRecordAdmin(admin.ModelAdmin):
166     list_display = ['id','from_class','day_num','teacher','has_homework','homework_title','homework_content','outline','date']  #显示字段表头
167     list_filter = ('from_class','teacher','date') # 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
168     def initialize_studyrecords(self,request,queryset):#制定功能
169         print('initialize_studyrecords',self,request,queryset)
170         if len(queryset)>1:
171             return HttpResponse("同时只能选择一个班级！")
172         print('获取对应的学员',queryset[0].from_class.enrollment_set.all()) # _set反向查询
173         new_obj_list=[]#用于批量创建事务  #防止数据库事物回滚
174         for enrll_obj in queryset[0].from_class.enrollment_set.all():#创建学习记录
175         #     models.StudyRecord.objects.get_or_create(       #get_or_ #防止报错
176         #         student=enrll_obj,#对应学员
177         #         course_record=queryset[0],
178         #         attendance=0,#签到状态,默认签到,
179         #         score=0,#成绩
180         #     )
181                 #防止数据库事物回滚    #"""09学习纪录"""
182             new_obj_list.append(models.StudyRecord(
183                 student=enrll_obj,#对应学员
184                 course_record=queryset[0],  #班级#节课
185                 attendance=0,#签到状态,默认签到,
186                 score=0,#成绩
187             ))
188 
189 
190         try:
191             course_record_id_list= models.StudyRecord.objects.values_list('course_record_id')#每节课上课纪录表ID列表
192             queryset_id=(int(queryset[0].id),)#数字转元组
193             if queryset_id not in course_record_id_list: #列表是元组
194                 models.StudyRecord.objects.bulk_create(new_obj_list)  # bulk_create批量创建数据库事物 #统一最后保存
195                 print('批量创建成功！')
196         except Exception as e:
197             return HttpResponse('批量创建失败,本节课可能有相应的上课记录')
198         return redirect("/admin/crm/studyrecord/?course_record__id__exact=%s"%queryset[0].id)#学习记录 #加上过滤
199     actions = ['initialize_studyrecords',]
200     initialize_studyrecords.short_description = "创建班级本节上课记录"#显示别名
201 
202 #09学习纪录
203 class StudyRecordAdmin(admin.ModelAdmin):
204     list_display = ['id','student','course_record','attendance','score','date']   #显示字段表头
205     list_filter =['course_record','attendance','score','course_record__from_class','student']# 过滤器(可以包含ManyToManyField) （注意加 逗号 , ）
206     list_editable = ['score','attendance']#可编辑   #用于上课点名 批改成绩
207 
208 admin.site.register(models.Enrollment,EnrollmentAdmin)              #06学员报名信息表
209 admin.site.register(models.Payment,PaymentAdmin)                    #07缴费记录表
210 admin.site.register(models.CourseRecord,CourseRecordAdmin)          #08每节课上课纪录表
211 admin.site.register(models.StudyRecord,StudyRecordAdmin)            #09学习纪录
212 # ————————57PerfectCRM实现admin批量生成上课记录————————
213 
214 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
215 # admin.site.register(models.UserProfile)             #10账号表
216 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
217 
218 admin.site.register(models.Role)                    #11角色表
219 admin.site.register(models.Tag)                     #12标签表
220 
221 '''
222 Django Admin里账号密码重置方法
223 #运行 Terminal  
224 
225 python manage.py createsuperuser
226 
227 Username :              admin
228 Email address:          admin@qq.com
229 Password:               admin123456
230 Password (again):       admin123456
231 
232 
233 英文转中文方法
234 到settings.py里修改
235 # LANGUAGE_CODE = 'en-us'
236 LANGUAGE_CODE = 'zh-Hans'
237 '''
238 
239 # ————————01PerfectCRM基本配置ADMIN————————

#admin.py

  1 #models.py
  2 
  3 # ————————01PerfectCRM基本配置ADMIN————————
  4 
  5 from django.db import models
  6 # Create your models here.
  7 
  8 """
  9 #运行 Terminal
 10 #    生成 数据表
 11 #    python manage.py makemigrations
 12 #   数据表 迁移
 13 #    python manage.py migrate
 14 """
 15 
 16 """01校区表"""
 17 class Branch(models.Model):
 18     name = models.CharField(max_length=128,unique=True) #校区名#CharField作用是保存文本，定长的变量类型
 19     addr = models.CharField(max_length=128) #地址
 20     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
 21         return self.name #返回 #校区名
 22     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
 23         verbose_name_plural =  "01校区表" #verbose_name_plural给你的模型类起一个更可读的名字
 24 
 25 """02班级表"""
 26 class ClassList(models.Model):
 27     #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
 28     branch = models.ForeignKey("Branch",on_delete=models.CASCADE)#校区    关联到  校区表
 29     course = models.ForeignKey("Course",on_delete=models.CASCADE) #课程   关联到   课程表
 30 
 31     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
 32     contract = models.ForeignKey('ContractTemplate', blank=True, null=True, default=1,on_delete=models.CASCADE)  # 合同表
 33     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
 34 
 35     class_type_choices = ( #上课形式
 36                           (0,'面授(脱产)'),
 37                           (1,'面授(周末)'),
 38                           (2,'网络班'),)
 39     #PositiveSmallIntegerField正小整数 0 ～ 32767 #choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
 40     class_type = models.SmallIntegerField(choices=class_type_choices)#上课形式
 41 
 42     #PositiveSmallIntegerField正小整数 0 ～ 32767
 43     semester = models.PositiveSmallIntegerField(verbose_name="学期") #课程的第几期
 44 
 45     #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。
 46     teachers = models.ManyToManyField("UserProfile") # 老师   关联到    账号表
 47 
 48     start_date = models.DateField(verbose_name="开班日期") #DateField 日期格式 YYYY-MM-DD #verbose_name是Admin中显示的字段名称
 49 
 50     # DateField 日期格式 YYYY-MM-DD #verbose_name是Admin中显示的字段名称 #Django可空#数据库可以为空
 51     end_date = models.DateField(verbose_name="结业日期",blank=True,null=True)
 52 
 53     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
 54         return "%s %s %s" %(self.branch,self.course,self.semester) #返回 #%s格式化输出字符串 #校区#课程# 学期
 55     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
 56         unique_together=('branch','course','semester')  #联合索引
 57         verbose_name_plural = "02班级表" #verbose_name_plural给你的模型类起一个更可读的名字
 58 
 59 """03课程表，可以报名那些课程"""
 60 class Course(models.Model):
 61     name = models.CharField(max_length=64,unique=True)#课程名 #CharField作用是保存文本，定长的变量类型
 62     price = models.PositiveSmallIntegerField(verbose_name="学费")#学费#PositiveSmallIntegerField正小整数 0 ～ 32767
 63     period = models.PositiveSmallIntegerField(verbose_name="周期（月）") #PositiveSmallIntegerField正小整数 0 ～ 32767
 64     outline = models.TextField() #课程大纲  #文本类型
 65     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
 66         return self.name #返回 #课程名
 67     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
 68         verbose_name_plural =  "03课程表"#verbose_name_plural给你的模型类起一个更可读的名字
 69 
 70 '''04客户信息表'''
 71 class Customer(models.Model):
 72     name = models.CharField(max_length=32,blank=True,null=True)#客户名#CharField定长文本 #名字最长32 # Django可空 #数据库可以为空
 73     qq = models.CharField(max_length=64,unique=True) #QQ号#CharField定长文本 #名字最长64 #唯一，不能重复
 74     qq_name = models.CharField(max_length=64,blank=True,null=True)#QQ名 #CharField定长文本 #名字最长64 # Django可空 #数据库可以为空
 75     phone = models.CharField(max_length=64,blank=True,null=True)#手机号 #CharField定长文本 #名字最长64 # Django可空 #数据库可以为空
 76 
 77     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
 78     id_num=models.CharField(max_length=64,blank=True,null=True,verbose_name='身份证号')#身份证号
 79     email=models.EmailField(max_length=64,blank=True,null=True,verbose_name='邮箱')#email
 80     sex_choices=((0,'保密'),(1,'男'),(2,'女'))
 81     sex=models.SmallIntegerField(choices=sex_choices,default=0,verbose_name='性别')
 82     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
 83 
 84     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
 85     status_choices = ((0, '已报名'), (1, '未报名'), (2, '已退学'))
 86     status = models.SmallIntegerField(choices=status_choices, default=1)  # 学员状态
 87     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
 88 
 89     source_choices = ( #客户渠道来源 （内存生成）
 90                       (0,'转介绍'),
 91                       (1,'QQ群'),
 92                       (2,'官网'),
 93                       (3,'百度推广'),
 94                       (4,'51CTO'),
 95                       (5,'知乎'),
 96                       (6,'市场推广'),)
 97     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
 98     source = models.SmallIntegerField(choices=source_choices)#客户渠道来源
 99 
100     #CharField定长文本#verbose_name是Admin中显示的字段名称#名字最长64 # Django可空 #数据库可以为空
101     referral_from = models.CharField(verbose_name="转介绍人qq",max_length=64,blank=True,null=True) #来自谁介绍的
102 
103     #ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
104     consult_courses = models.ForeignKey("Course",verbose_name="咨询课程", on_delete=models.CASCADE) #关联到 课程表
105 
106     content= models.TextField(verbose_name="咨询详情") #TextField无限制长度的文本#verbose_name是Admin中显示的字段名称
107 
108     #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。
109     tags = models.ManyToManyField("Tag",blank=True)#多对多关联到 标签表
110 
111     #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
112     consultant = models.ForeignKey("UserProfile", on_delete=models.CASCADE) #关联到  账号表
113 
114     memo = models.TextField(blank=True,null=True)#备注#TextField无限制长度的文本#Django可空#数据库可以为空
115 
116     #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
117     date =  models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）
118 
119     def __str__(self): #__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
120         return self.qq  #返回 #QQ号
121 
122     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
123         verbose_name_plural =  "04客户表" #verbose_name_plural给你的模型类起一个更可读的名字
124 
125 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
126 #合同模版
127 class ContractTemplate(models.Model):
128     name=models.CharField('合同名称',max_length=64,unique=True)
129     template=models.TextField()
130 
131     def __str__(self):
132         return self.name
133     class Meta:
134         verbose_name_plural='合同表'
135 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
136 
137 
138 """05客户跟进表"""
139 class CustomerFollowUp(models.Model):
140 
141     #ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
142     customer = models.ForeignKey("Customer", on_delete=models.CASCADE)#客户名 #关联到  客户信息表
143 
144     content = models.TextField(verbose_name="跟进内容")#跟进的内容#TextField无限制长度的文本#verbose_name是Admin中显示的字段名称
145 
146     #ForeignKey就是表与表之间的某种约定的关系  #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
147     consultant =models.ForeignKey("UserProfile", on_delete=models.CASCADE) #关联到  账号表
148 
149     intention_choices =(  #报名状态
150                         (0,'2周内报名'),
151                         (1,'1个月内报名'),
152                         (2,'近期无报名计划'),
153                         (3,'已在其它机构报名'),
154                         (4,'已报名'),
155                         (5,'已拉黑'),)
156     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
157     intention=models.SmallIntegerField(choices=intention_choices) #报名状态
158 
159     #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
160     date =  models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）
161 
162     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
163         return "<%s:%s>" %(self.customer.qq,self.intention) #返回#格式化字符串#跨表里的QQ号#报名状态
164     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
165         verbose_name_plural =  "05客户跟进表"#verbose_name_plural给你的模型类起一个更可读的名字
166 
167 """06学员报名信息表"""
168 class Enrollment(models.Model):
169     # ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
170     customer = models.ForeignKey("Customer",on_delete=models.CASCADE)#学员名字 #关联到  客户信息表
171     enrolled_class = models.ForeignKey("ClassList",verbose_name="所报班级",on_delete=models.CASCADE)#关联到  班级表
172     consultant = models.ForeignKey("UserProfile",verbose_name="课程顾问",on_delete=models.CASCADE) #关联到  账号表
173 
174     # ————————52PerfectCRM实现CRM客户报名流程学生合同审核————————
175     contract_review = models.CharField(max_length=256, blank=True, null=True, verbose_name="合同审核")  # 合同审核
176     # ————————52PerfectCRM实现CRM客户报名流程学生合同审核————————
177 
178     #BooleanField布尔值类型#default=False默认(True)不允许出现空字符#verbose_name是Admin中显示的字段名称
179     contract_agreed = models.BooleanField(default=False,verbose_name="学员已经同意合同")#学员看合同
180     contract_approved = models.BooleanField(default=False,verbose_name="合同已经审核") #谁审核
181 
182     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
183     Pay_cost= models.BooleanField(default=False,verbose_name="缴费") #缴费状态#是不是交定金
184     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
185 
186     # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
187     date = models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）
188 
189     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
190 
191         # ————————57PerfectCRM实现admin批量生成上课记录————————
192         # return "%s %s" %(self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
193         return " 学员:%s |QQ: %s |班级:%s" %(self.customer.name,self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
194         # ————————57PerfectCRM实现admin批量生成上课记录————————
195 
196     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
197         unique_together =  ("customer","enrolled_class")#联合索引
198         verbose_name_plural =  "06学员报名信息表"#verbose_name_plural给你的模型类起一个更可读的名字
199 
200 """07缴费记录表"""
201 class Payment(models.Model):
202     #ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
203     customer = models.ForeignKey("Customer",on_delete=models.CASCADE)#学员名字        关联到  客户信息表
204     course = models.ForeignKey("Course",verbose_name="所报课程",on_delete=models.CASCADE)#关联到  课程表
205 
206     #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称#默认值=500
207     amount = models.PositiveIntegerField(verbose_name="数额",default=500)#缴费数额
208 
209     #ForeignKey就是表与表之间的某种约定的关系#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
210     consultant = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#缴费给谁 关联到  账号表 #财务人员
211 
212     #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
213     date=models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）
214 
215     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
216         return "%s %s" %(self.customer,self.amount)#返回#格式化字符串#学员名字#缴费数额
217     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
218         verbose_name_plural = "07缴费记录表"#verbose_name_plural给你的模型类起一个更可读的名字
219 
220 """08每节课上课纪录表"""
221 class CourseRecord(models.Model):
222     # ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
223     from_class = models.ForeignKey("ClassList",verbose_name="班级",on_delete=models.CASCADE) #那个班级
224 
225     #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称
226     day_num = models.PositiveSmallIntegerField(verbose_name="第几节(天)") #第几节课
227 
228     # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
229     teacher = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#老师是谁    关联到    账号表
230 
231     #BooleanField布尔值类型#default=True默认(True)不允许出现空字符
232     has_homework = models.BooleanField(default=True) #有没有作业
233 
234     # CharField定长文本#名字最长128#Django可空#数据库可以为空
235     homework_title = models.CharField(max_length=128,blank=True,null=True) #作业标题
236 
237     #TextField无限制长度的文本#Django可空#数据库可以为空
238     homework_content = models.TextField(blank=True,null=True) #作业内容
239 
240     #TextField无限制长度的文本#verbose_name是Admin中显示的字段名称
241     outline =models.TextField(verbose_name="本节课程大纲") #课程主要讲什么
242 
243     # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
244     date = models.DateField(auto_now_add=True)#创建时间（数据库自增）
245 
246     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
247         return " %s:%s" %(self.from_class,self.day_num)#返回#格式化字符串#班级#第几节(天)
248     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
249         unique_together = ("from_class","day_num") #联合索引
250         verbose_name_plural = "08每节课上课纪录表" #verbose_name_plural给你的模型类起一个更可读的名字
251 
252 """09学习纪录"""
253 class StudyRecord(models.Model):
254     # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
255     student = models.ForeignKey("Enrollment",on_delete=models.CASCADE)#学生名字   关联到    学员报名信息表
256     course_record = models.ForeignKey("CourseRecord",on_delete=models.CASCADE)#开课记录   # 关联到    每节课上课纪录表
257 
258     attendance_choices = (# 本节课上课状态记录
259                             (0,"已签到"),
260                             (1,"迟到"),
261                             (2,"缺勤"),
262                             (3,"早退"),)
263     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
264     attendance = models.SmallIntegerField(choices=attendance_choices) # 本节课上课状态记录
265 
266     score_choices = (#学习成绩
267                      (100,"A+"),
268                      (90,"A"),
269                      (85,"B+"),
270                      (80,"B"),
271                      (75,"B-"),
272                      (70,"C+"),
273                      (65,"C"),
274                      (40,"C-"),
275                      (-20,"D"),
276                      (-50,"COPY"),
277                      (0,"N/A"),)
278     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
279     score = models.SmallIntegerField(choices=score_choices) #学习成绩
280 
281     memo = models.TextField(blank=True,null=True)#TextField无限制长度的文本#Django可空#数据库可以为空
282 
283     # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
284     date = models.DateField(auto_now_add=True)#创建时间（数据库自增）
285 
286     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
287         return "%s %s %s" % (self.student, self.course_record, self.score)#返回#格式化字符串#学生名字#开课记录#学习成绩
288     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
289         unique_together = ('student','course_record')#联合索引#学生名字#开课记录
290         verbose_name_plural =  "09学习纪录"#verbose_name_plural给你的模型类起一个更可读的名字
291 
292 # ————————34PerfectCRM实现CRM自定义用户————————
293 # """10账号表"""
294 # class UserProfile(models.Model):
295 #     from django.contrib.auth.models import User  # 使用django内置的用户表
296 #
297 #     #OneToOneField一对一  #User是django Admin里的账号表#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
298 #     user = models.OneToOneField(User,on_delete=models.CASCADE)# 用户名 #创建外键，关联django用户表
299 #
300 #     name = models.CharField(max_length=32) #账号名（扩展用户字段）#CharField定长文本
301 #
302 #     #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。#Django可空
303 #     roles = models.ManyToManyField("Role",blank=True) #角色(权限)   # 双向一对多==多对多
304 #
305 #     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
306 #         return self.name #返回 #账号名
307 #     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
308 #         verbose_name_plural = "10账号表"#verbose_name_plural给你的模型类起一个更可读的名字
309 # ————————34PerfectCRM实现CRM自定义用户————————
310 
311 # ————————34PerfectCRM实现CRM自定义用户————————
312 #10账号表，创建用户和超级用户
313 from django.contrib.auth.models import BaseUserManager
314 class UserProfileManager(BaseUserManager):
315     def create_user(self, email, name, password=None):
316         """
317     　　创建并保存一个用户用给定的邮件,日期
318     　　出生和密码。
319         """
320         if not email:#没有email 报错
321             raise ValueError('用户必须有一个电子邮件地址')
322 
323         user = self.model(
324             email=self.normalize_email(email),#验证邮箱格式
325             name=name,
326         )
327         user.set_password(password)#加密
328         user.is_active = True
329         user.save(using=self._db)
330         return user
331     def create_superuser(self, email, name, password):
332         """
333     　　创建并保存一个超级用户具有给定邮件,日期
334     　　出生和密码。
335         """
336         user = self.create_user(email,
337             password=password,
338             name=name
339         )
340         user.is_active = True
341         user.is_superuser = True
342         user.save(using=self._db)
343         return user
344 
345 """10账号表"""
346 """
347 
348 #删除数据库
349 
350 #调用objects = UserProfileManager()#创建账号 #关联这个函数
351 
352 #运行 Terminal
353 #    生成 数据表
354 #    python manage.py makemigrations
355 #   数据表 迁移
356 #    python manage.py migrate
357 Django Admin里账号密码重置方法
358 #运行 Terminal  
359 python manage.py createsuperuser
360 
361 Email address:          admin@qq.com
362 用户名 :                 admin
363 Password:               admin123456
364 Password (again):       admin123456
365 """
366 from django.contrib.auth.models import AbstractBaseUser
367 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
368 from django.utils.translation import ugettext_lazy as _  # 语言国际化
369 from django.utils.safestring import mark_safe
370 from django.contrib.auth.models import PermissionsMixin
371 # class UserProfile(AbstractBaseUser):
372 class UserProfile(AbstractBaseUser,PermissionsMixin):
373 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
374     email=models.EmailField(
375         verbose_name='邮箱账号',
376         max_length=255,
377         unique=True#唯一  #登陆账号
378     )
379     name=models.CharField(max_length=32,verbose_name='用户名')
380 
381     # ————————35PerfectCRM实现CRM重写Admin密码修改————————
382     password = models.CharField(_('password'), max_length=128, help_text=mark_safe('''<a href="../password/">修改密码</a>'''))
383     # ————————35PerfectCRM实现CRM重写Admin密码修改————————
384 
385     is_active = models.BooleanField(default=True,verbose_name='合法账号')#权限#合法账号
386     is_superuser = models.BooleanField(default=False,verbose_name='超级账号') #超级账号
387     objects = UserProfileManager()#创建账号 #关联这个函数
388     USERNAME_FIELD ='email'#指定做为  #登陆账号
389     REQUIRED_FIELDS = ['name']#必填字段
390     def get_full_name(self):
391         return self.email
392     def get_short_name(self):
393         #用户确认的电子邮件地址
394         return self.email
395     def __str__(self):
396         return self.name
397     def has_perm(self,perm,obj=None):
398         #指明用户是否被认为活跃的。以反选代替删除帐号。
399         #最简单的可能的答案:是的,总是
400         return True   #有效 账号
401     def has_module_perms(self, app_label):
402         #指明用户是否可以登录到这个管理站点。
403         # 最简单的可能的答案:是的,总是
404         return True #职员状态
405     @property
406     def is_staff(self):
407         '''“用户的员工吗?”'''
408         #最简单的可能的答案:所有管理员都是员工
409         return self.is_superuser#是不是超级用户状态
410 # AUTH_USER_MODEL = 'crm.UserProfile'#使用自定的admin 表单   #settings.py
411 # ————————34PerfectCRM实现CRM自定义用户————————
412 
413 """11角色表"""
414 class Role(models.Model):
415     name = models.CharField(unique=True,max_length=32)#角色名#CharField定长文本#角色名不可以重复#最长度=32字节
416     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
417         return self.name#返回 #角色名
418     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
419         verbose_name_plural = "11角色表" #verbose_name_plural给你的模型类起一个更可读的名字
420 
421 """12标签表"""
422 class Tag(models.Model):
423     name =  models.CharField(max_length=64,unique=True) #标签名#CharField定长文本#最长度=64字节#不可以重复
424     def __str__(self): #__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
425         return self.name #返回 #标签名
426     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
427         verbose_name_plural =  "12标签表" #verbose_name_plural给你的模型类起一个更可读的名字
428 
429 # ————————01PerfectCRM基本配置ADMIN————————

#models.py