Django项目：CRM(客户关系管理系统)--70--60PerfectCRM实现CRM学生上课记录

 1 #urls.py
 2 
 3 """PerfectCRM URL Configuration
 4 
 5 The `urlpatterns` list routes URLs to views. For more information please see:
 6     https://docs.djangoproject.com/en/2.0/topics/http/urls/
 7 Examples:
 8 Function views
 9     1. Add an import:  from my_app import views
10     2. Add a URL to urlpatterns:  path(‘‘, views.home, name=‘home‘)
11 Class-based views
12     1. Add an import:  from other_app.views import Home
13     2. Add a URL to urlpatterns:  path(‘‘, Home.as_view(), name=‘home‘)
14 Including another URLconf
15     1. Import the include() function: from django.urls import include, path
16     2. Add a URL to urlpatterns:  path(‘blog/‘, include(‘blog.urls‘))
17 """
18 from django.contrib import admin
19 from django.urls import path
20 
21 # ————————02PerfectCRM创建ADMIN页面————————
22 from django.conf.urls import url  # URL
23 from django.conf.urls import include # 分发URL
24 # ————————02PerfectCRM创建ADMIN页面————————
25 
26 # ————————46PerfectCRM实现登陆后页面才能访问————————
27 from PerfectCRM import main_views
28 # ————————46PerfectCRM实现登陆后页面才能访问————————
29 
30 urlpatterns = [
31     path(‘admin/‘, admin.site.urls),
32     
33 # ————————02PerfectCRM创建ADMIN页面————————
34     url(r‘^king_admin/‘, include("king_admin.king_urls")),  # 自定义admin
35 # ————————02PerfectCRM创建ADMIN页面————————
36     
37 # ————————03PerfectCRM创建基本数据————————
38     url(r‘^DBadd/‘, include("DBadd.DBadd_urls")),  # 添加随机数据
39 # ————————03PerfectCRM创建基本数据————————
40     # ————————38PerfectCRM实现全局账号登录注销————————
41     url(r‘^gbacc/‘, include("gbacc.gbacc_urls")),  # 全局账号登录注销
42     # ————————38PerfectCRM实现全局账号登录注销————————
43 
44     # ————————42PerfectCRM实现AJAX全局账号注册————————
45     url(r‘^gbacc/‘, include("gbacc.gbacc_ajax_urls")),  # 全局账号登录注销
46     # ————————42PerfectCRM实现AJAX全局账号注册————————
47 
48     # ————————46PerfectCRM实现登陆后页面才能访问————————
49     url(r‘^$‘, main_views.PortalView.as_view()),
50     # ————————46PerfectCRM实现登陆后页面才能访问————————
51 
52     # ————————47PerfectCRM实现CRM客户报名流程————————
53     url(r‘^bpm/‘, include("bpm.sales.sales_urls")),  # 业务流程 #学生报名
54     # ————————47PerfectCRM实现CRM客户报名流程————————
55 
56     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
57     url(r‘^bpm/‘, include("bpm.financial.financial_urls")),  # 业务流程 #财务缴费
58     # ————————53PerfectCRM实现CRM客户报名流程缴费————————
59 
60     # ————————60PerfectCRM实现CRM学生上课记录————————
61     url(r‘^bpm/‘, include("bpm.student.student_urls")),  # 业务流程 # 学生上课记录
62     # ————————60PerfectCRM实现CRM学生上课记录————————
63 ]

 1 # student_urls.py
 2 # ————————60PerfectCRM实现CRM学生上课记录————————
 3 from django.conf.urls import url
 4 from bpm.student import student_views
 5 
 6 urlpatterns = [
 7     url(r‘^my_course/$‘, student_views.my_course, name=‘my_course‘),   #学生报名的课程
 8     url(r‘^studyrecords/(\d+)/$‘, student_views.studyrecords, name=‘studyrecords‘),  # #学生上课记录列表
 9 ]
10 # ————————60PerfectCRM实现CRM学生上课记录————————

 1 # student_views.py
 2 # ————————60PerfectCRM实现CRM学生上课记录————————
 3 from django.shortcuts import render
 4 from crm import models
 5 
 6 #学生报名的课程
 7 def my_course(request):
 8     return  render(request, ‘bpm_student/my_course.html‘, locals())
 9 
10 #学生上课记录列表
11 def studyrecords(request,enroll_obj_id):
12     enroll_obj=models.Enrollment.objects.get(id=enroll_obj_id)
13     return render(request,‘bpm_student/studyrecords.html‘,locals())
14 
15 # ————————60PerfectCRM实现CRM学生上课记录————————

 1 # bpm_tags.py
 2 
 3 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
 4 from django import template
 5 register = template.Library()    #模板库
 6 
 7 #合同格式
 8 @register.simple_tag
 9 def render_enrolled_contract(enroll_obj):#合同格式
10     if enroll_obj.enrolled_class.contract.template:
11         return enroll_obj.enrolled_class.contract.template.format(course_name=enroll_obj.enrolled_class,stu_name=enroll_obj.customer.name)
12     else:
13         return ‘‘
14 
15 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
16 
17 
18 # ————————60PerfectCRM实现CRM学生上课记录————————
19 
20 # from django import template
21 # register = template.Library()   #模板库
22 from django.db.models import Sum
23 #分数统计
24 @register.simple_tag
25 def get_score(enroll_obj,customer_obj):
26     study_records=enroll_obj.studyrecord_set.filter(course_record__from_class_id=enroll_obj.enrolled_class.id)
27     print(study_records,‘<----study_record‘)
28     return study_records.aggregate(Sum(‘score‘))
29 
30 # ————————60PerfectCRM实现CRM学生上课记录————————

 1 {#my_course.html#}
 2 {## ————————60PerfectCRM实现CRM学生上课记录————————#}
 3 {% extends ‘bpm_master/bpm_sample.html‘ %}
 4 {% load bpm_tags %}
 5 {% block right-container-content %} {#自定义内容开始 右边页面内容#}
 6 
 7     <div class="panel-default">
 8         <div class="panel-body">
 9             <h3>当前用户： {{ request.user }} </h3>
10             <table class="table table-striped table-responsive">
11                 <thead>
12                 <tr>
13                     <th>课程名称</th>
14                     <th>班级</th>
15                     <th>开课日期</th>
16                     <th>结业日期</th>
17                     <th>课程进度</th>
18                     <th>我的成绩</th>
19                     <th>作业管理</th>
20                 </tr>
21                 </thead>
22                 <tbody>
23                 {% for enroll_obj in request.user.stu_account.enrollment_set.all %}
24                     <tr>
25                         <td>{{ enroll_obj.enrolled_class.course }}</td>
26                         <td>s{{ enroll_obj.enrolled_class.semester }}</td>
27                         <td>{{ enroll_obj.enrolled_class.start_date }}</td>
28                         <td>{{ enroll_obj.enrolled_class.end_date }}</td>
29                         <td>已上: {{ enroll_obj.enrolled_class.courserecord_set.all.count }} 节</td>
30                         <td>
31                             {% get_score enroll_obj request.user.stu_account as score_data %}{{ score_data.score__sum }}</td>
32                         <td><a href="{% url ‘studyrecords‘ enroll_obj.id %}">作业管理</a></td>
33                     </tr>
34                 {% endfor %}
35                 </tbody>
36             </table>
37         </div>
38     </div>
39 {% endblock %}
40 {## ————————60PerfectCRM实现CRM学生上课记录————————#}

 1 {#studyrecords.html#}
 2  {## ————————60PerfectCRM实现CRM学生上课记录————————#}
 3 {% extends ‘bpm_master/bpm_sample.html‘ %}
 4 {% load bpm_tags %}
 5 {% block right-container-content %} {#自定义内容开始 右边页面内容#}
 6     <div class="panel-default">
 7         <div class="panel-body">
 8             <h3>当前用户： {{ request.user }}  | <a class="btn btn-info pull" href={% url ‘my_course‘ %}>返回</a></h3>
 9             <table class="table table-striped table-responsive">
10                 <thead>
11                 <tr>
12                     <th>课程名称</th>
13                     <th>课程节次</th>
14                     <th>上课日期</th>
15                     <th>签到状态</th>
16                     <th>我的成绩</th>
17                     <th>是否有作业</th>
18                     <th>作业标题</th>
19                 </tr>
20                 </thead>
21                 <tbody>
22                 {% for studyrecord in enroll_obj.studyrecord_set.all %}
23                     <tr>
24                         <td>{{ studyrecord.course_record }}</td>
25                         <td>{{ studyrecord.course_record.day_num }}</td>
26                         <td>{{ studyrecord.course_record.date }}</td>
27                         <td>{{ studyrecord.get_attendance_display }}</td>
28                         <td>{{ studyrecord.get_score_display }}</td>
29                         <td>{{ studyrecord.course_record.has_homework }}</td>
30                         <td>{{ studyrecord.course_record.homework_title }}</td>
31                     </tr>
32                 {% endfor %}
33                 </tbody>
34             </table>
35         </div>
36     </div>
37 {% endblock %}
38 {## ————————60PerfectCRM实现CRM学生上课记录————————#}

  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         # ————————57PerfectCRM实现admin批量生成上课记录————————
191         # return "%s %s" %(self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
192         return " 学员:%s |QQ: %s |班级:%s" %(self.customer.name,self.customer,self.enrolled_class)#返回#格式化字符串#学员名字#所报班级
193         # ————————57PerfectCRM实现admin批量生成上课记录————————
194     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
195         unique_together =  ("customer","enrolled_class")#联合索引
196         verbose_name_plural =  "06学员报名信息表"#verbose_name_plural给你的模型类起一个更可读的名字
197 
198 """07缴费记录表"""
199 class Payment(models.Model):
200     #ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
201     customer = models.ForeignKey("Customer",on_delete=models.CASCADE)#学员名字        关联到  客户信息表
202     course = models.ForeignKey("Course",verbose_name="所报课程",on_delete=models.CASCADE)#关联到  课程表
203 
204     #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称#默认值=500
205     amount = models.PositiveIntegerField(verbose_name="数额",default=500)#缴费数额
206 
207     #ForeignKey就是表与表之间的某种约定的关系#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
208     consultant = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#缴费给谁 关联到  账号表 #财务人员
209 
210     #DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
211     date=models.DateTimeField(auto_now_add=True)#创建时间（数据库自增）
212 
213     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
214         return "%s %s" %(self.customer,self.amount)#返回#格式化字符串#学员名字#缴费数额
215     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
216         verbose_name_plural = "07缴费记录表"#verbose_name_plural给你的模型类起一个更可读的名字
217 
218 """08每节课上课纪录表"""
219 class CourseRecord(models.Model):
220     # ForeignKey就是表与表之间的某种约定的关系#verbose_name是Admin中显示的字段名称 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
221     from_class = models.ForeignKey("ClassList",verbose_name="班级",on_delete=models.CASCADE) #那个班级
222 
223     #PositiveSmallIntegerField正小整数 0 ～ 32767 #verbose_name是Admin中显示的字段名称
224     day_num = models.PositiveSmallIntegerField(verbose_name="第几节(天)") #第几节课
225 
226     # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
227     teacher = models.ForeignKey("UserProfile",on_delete=models.CASCADE)#老师是谁    关联到    账号表
228 
229     #BooleanField布尔值类型#default=True默认(True)不允许出现空字符
230     has_homework = models.BooleanField(default=True) #有没有作业
231 
232     # CharField定长文本#名字最长128#Django可空#数据库可以为空
233     homework_title = models.CharField(max_length=128,blank=True,null=True) #作业标题
234 
235     #TextField无限制长度的文本#Django可空#数据库可以为空
236     homework_content = models.TextField(blank=True,null=True) #作业内容
237 
238     #TextField无限制长度的文本#verbose_name是Admin中显示的字段名称
239     outline =models.TextField(verbose_name="本节课程大纲") #课程主要讲什么
240 
241     # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
242     date = models.DateField(auto_now_add=True)#创建时间（数据库自增）
243 
244     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
245         return " %s:%s" %(self.from_class,self.day_num)#返回#格式化字符串#班级#第几节(天)
246     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
247         unique_together = ("from_class","day_num") #联合索引
248         verbose_name_plural = "08每节课上课纪录表" #verbose_name_plural给你的模型类起一个更可读的名字
249 
250 """09学习纪录"""
251 class StudyRecord(models.Model):
252     # ForeignKey就是表与表之间的某种约定的关系 #CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
253     student = models.ForeignKey("Enrollment",on_delete=models.CASCADE)#学生名字   关联到    学员报名信息表
254     course_record = models.ForeignKey("CourseRecord",on_delete=models.CASCADE)#开课记录   # 关联到    每节课上课纪录表
255 
256     attendance_choices = (# 本节课上课状态记录
257                             (0,"已签到"),
258                             (1,"迟到"),
259                             (2,"缺勤"),
260                             (3,"早退"),)
261     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
262     attendance = models.SmallIntegerField(choices=attendance_choices) # 本节课上课状态记录
263 
264     score_choices = (#学习成绩
265                      (100,"A+"),
266                      (90,"A"),
267                      (85,"B+"),
268                      (80,"B"),
269                      (75,"B-"),
270                      (70,"C+"),
271                      (65,"C"),
272                      (40,"C-"),
273                      (-20,"D"),
274                      (-50,"COPY"),
275                      (0,"N/A"),)
276     #PositiveSmallIntegerField正小整数 0 ～ 32767（省空间）#choices是Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
277     score = models.SmallIntegerField(choices=score_choices) #学习成绩
278 
279     memo = models.TextField(blank=True,null=True)#TextField无限制长度的文本#Django可空#数据库可以为空
280 
281     # DateTimeField日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] #auto_now_add创建时间（只读）
282     date = models.DateField(auto_now_add=True)#创建时间（数据库自增）
283 
284     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
285         return "%s %s %s" % (self.student, self.course_record, self.score)#返回#格式化字符串#学生名字#开课记录#学习成绩
286     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
287         unique_together = (‘student‘,‘course_record‘)#联合索引#学生名字#开课记录
288         verbose_name_plural =  "09学习纪录"#verbose_name_plural给你的模型类起一个更可读的名字
289 
290 # ————————34PerfectCRM实现CRM自定义用户————————
291 # """10账号表"""
292 # class UserProfile(models.Model):
293 #     from django.contrib.auth.models import User  # 使用django内置的用户表
294 #
295 #     #OneToOneField一对一  #User是django Admin里的账号表#CASCADE从父表删除或更新且自动删除或更新子表中匹配的行。
296 #     user = models.OneToOneField(User,on_delete=models.CASCADE)# 用户名 #创建外键，关联django用户表
297 #
298 #     name = models.CharField(max_length=32) #账号名（扩展用户字段）#CharField定长文本
299 #
300 #     #ManyToManyField多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。#Django可空
301 #     roles = models.ManyToManyField("Role",blank=True) #角色(权限)   # 双向一对多==多对多
302 #
303 #     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
304 #         return self.name #返回 #账号名
305 #     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
306 #         verbose_name_plural = "10账号表"#verbose_name_plural给你的模型类起一个更可读的名字
307 # ————————34PerfectCRM实现CRM自定义用户————————
308 
309 # ————————34PerfectCRM实现CRM自定义用户————————
310 #10账号表，创建用户和超级用户
311 from django.contrib.auth.models import BaseUserManager
312 class UserProfileManager(BaseUserManager):
313     def create_user(self, email, name, password=None):
314         """
315     　　创建并保存一个用户用给定的邮件,日期
316     　　出生和密码。
317         """
318         if not email:#没有email 报错
319             raise ValueError(‘用户必须有一个电子邮件地址‘)
320 
321         user = self.model(
322             email=self.normalize_email(email),#验证邮箱格式
323             name=name,
324         )
325         user.set_password(password)#加密
326         user.is_active = True
327         user.save(using=self._db)
328         return user
329     def create_superuser(self, email, name, password):
330         """
331     　　创建并保存一个超级用户具有给定邮件,日期
332     　　出生和密码。
333         """
334         user = self.create_user(email,
335             password=password,
336             name=name
337         )
338         user.is_active = True
339         user.is_superuser = True
340         user.save(using=self._db)
341         return user
342 
343 """10账号表"""
344 """
345 
346 #删除数据库
347 
348 #调用objects = UserProfileManager()#创建账号 #关联这个函数
349 
350 #运行 Terminal
351 #    生成 数据表
352 #    python manage.py makemigrations
353 #   数据表 迁移
354 #    python manage.py migrate
355 Django Admin里账号密码重置方法
356 #运行 Terminal  
357 python manage.py createsuperuser
358 
359 Email address:          admin@qq.com
360 用户名 :                 admin
361 Password:               admin123456
362 Password (again):       admin123456
363 """
364 from django.contrib.auth.models import AbstractBaseUser
365 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
366 from django.utils.translation import ugettext_lazy as _  # 语言国际化
367 from django.utils.safestring import mark_safe
368 from django.contrib.auth.models import PermissionsMixin
369 # class UserProfile(AbstractBaseUser):
370 class UserProfile(AbstractBaseUser,PermissionsMixin):
371 # ————————35PerfectCRM实现CRM重写Admin密码修改————————
372     email=models.EmailField(
373         verbose_name=‘邮箱账号‘,
374         max_length=255,
375         unique=True#唯一  #登陆账号
376     )
377     name=models.CharField(max_length=32,verbose_name=‘用户名‘)
378 
379     # ————————35PerfectCRM实现CRM重写Admin密码修改————————
380     password = models.CharField(_(‘password‘), max_length=128, help_text=mark_safe(‘‘‘<a href=\"../password/\">修改密码</a>‘‘‘))
381     # ————————35PerfectCRM实现CRM重写Admin密码修改————————
382 
383     is_active = models.BooleanField(default=True,verbose_name=‘合法账号‘)#权限#合法账号
384     is_superuser = models.BooleanField(default=False,verbose_name=‘超级账号‘) #超级账号
385     objects = UserProfileManager()#创建账号 #关联这个函数
386     USERNAME_FIELD =‘email‘#指定做为  #登陆账号
387     REQUIRED_FIELDS = [‘name‘]#必填字段
388 
389     # ————————60PerfectCRM实现CRM学生上课记录————————
390     stu_account=models.ForeignKey("Customer",verbose_name=‘关联学员帐号‘,blank=True,null=True,on_delete=models.CASCADE,help_text=‘报名成功后创建关联帐户‘)
391     # ————————60PerfectCRM实现CRM学生上课记录————————
392 
393     def get_full_name(self):
394         return self.email
395     def get_short_name(self):
396         #用户确认的电子邮件地址
397         return self.email
398     def __str__(self):
399         return self.name
400     def has_perm(self,perm,obj=None):
401         #指明用户是否被认为活跃的。以反选代替删除帐号。
402         #最简单的可能的答案:是的,总是
403         return True   #有效 账号
404     def has_module_perms(self, app_label):
405         #指明用户是否可以登录到这个管理站点。
406         # 最简单的可能的答案:是的,总是
407         return True #职员状态
408     @property
409     def is_staff(self):
410         ‘‘‘“用户的员工吗?”‘‘‘
411         #最简单的可能的答案:所有管理员都是员工
412         return self.is_superuser#是不是超级用户状态
413 # AUTH_USER_MODEL = ‘crm.UserProfile‘#使用自定的admin 表单   #settings.py
414 # ————————34PerfectCRM实现CRM自定义用户————————
415 
416 """11角色表"""
417 class Role(models.Model):
418     name = models.CharField(unique=True,max_length=32)#角色名#CharField定长文本#角色名不可以重复#最长度=32字节
419     def __str__(self):#__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
420         return self.name#返回 #角色名
421     class Meta: #通过一个内嵌类 "class Meta" 给你的 model 定义元数据
422         verbose_name_plural = "11角色表" #verbose_name_plural给你的模型类起一个更可读的名字
423 
424 """12标签表"""
425 class Tag(models.Model):
426     name =  models.CharField(max_length=64,unique=True) #标签名#CharField定长文本#最长度=64字节#不可以重复
427     def __str__(self): #__str__()是Python的一个“魔幻”方法，这个方法定义了当object调用str()时应该返回的值。
428         return self.name #返回 #标签名
429     class Meta:#通过一个内嵌类 "class Meta" 给你的 model 定义元数据
430         verbose_name_plural =  "12标签表" #verbose_name_plural给你的模型类起一个更可读的名字
431 
432 # ————————01PerfectCRM基本配置ADMIN————————

 1 # DBadd_urls.py
 2 # ————————03PerfectCRM创建基本数据————————
 3 from django.conf.urls import url
 4 from DBadd import auth_views
 5 from DBadd import crm_views
 6 
 7 urlpatterns = [
 8     url(r‘^auth_user/$‘, auth_views.auth_user), #Django账号表
 9 
10     url(r‘^crm_Role/$‘, crm_views.crm_Role), #角色表 等基本信息
11     url(r‘^crm_UserProfile/$‘, crm_views.crm_UserProfile),#账号表 #随机学生
12     url(r‘^crm_userprofile_roles/$‘, crm_views.crm_userprofile_roles),#账号角色关联表 #随机学生
13 
14     url(r‘^crm_Customer/$‘, crm_views.crm_Customer),  # 04客户信息表
15 
16     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
17     url(r‘^crm_ContractTemplate/$‘, crm_views.crm_ContractTemplate),  # 角色表 等基本信息
18     # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
19 
20     # ————————60PerfectCRM实现CRM学生上课记录————————
21     url(r‘^$‘, crm_views.DBadd),  # Django账号表
22     url(r‘^crm_CourseRecord/$‘, crm_views.crm_CourseRecord),  # 班级节课
23     url(r‘^crm_Enrollment/$‘, crm_views.crm_Enrollment),  # 报名信息
24     # ————————60PerfectCRM实现CRM学生上课记录————————
25 
26 ]
27 # ————————03PerfectCRM创建基本数据————————

  1 # crm_views.py
  2 
  3 # ————————03PerfectCRM创建基本数据————————
  4 
  5 from django.shortcuts import render
  6 from django.shortcuts import redirect
  7 from django.shortcuts import HttpResponse
  8 
  9 from crm import models
 10 from django.contrib.auth import models as auth_models
 11 
 12 # 随机字符串
 13 import random
 14 from random import choice
 15 
 16 
 17 # 添加"""基本数据"""
 18 def crm_Role(request):
 19     if request.method == "GET":
 20         user_list = models.Role.objects.all()
 21         return render(request, ‘crm_Role.html‘, {‘user_list‘: user_list})
 22     elif request.method == "POST":
 23         try:
 24             models.Role.objects.create(name=‘角色学生‘)
 25             models.Role.objects.create(name=‘角色销售‘)
 26             models.Role.objects.create(name=‘角色老师‘)
 27             models.Role.objects.create(name=‘角色校长‘)
 28             models.Role.objects.create(name=‘角色系统维护‘)
 29 
 30             models.Branch.objects.create(name=‘北京校区‘, addr=‘北京天安门‘)
 31             models.Branch.objects.create(name=‘广东校区‘, addr=‘广东东莞市‘)
 32             models.Branch.objects.create(name=‘上海校区‘, addr=‘上海黄浦江‘)
 33             models.Branch.objects.create(name=‘福建校区‘, addr=‘福建仙游县‘)
 34             models.Branch.objects.create(name=‘四川校区‘, addr=‘四川成都市‘)
 35 
 36             models.Tag.objects.create(name=‘好，很好‘)
 37             models.Tag.objects.create(name=‘很有兴趣‘)
 38             models.Tag.objects.create(name=‘兴趣不大‘)
 39             models.Tag.objects.create(name=‘交钱很爽快‘)
 40             models.Tag.objects.create(name=‘随便问问的‘)
 41 
 42             models.Course.objects.create(name=‘Pyton‘, price=‘6666‘, period=‘40‘,
 43                                          outline=‘Python , 是一种面向对象的解释型计算机程序设计语言，具有丰富和强大的库，Python 已经成为继JAVA，C++之后的的第三大语言。 特点：简单易学、免费开源、高层语言、可移植性强、面向对象、可扩展性、可嵌入型、丰富的库、规范的代码等。‘)
 44             models.Course.objects.create(name=‘PHP‘, price=‘8888‘, period=‘50‘,
 45                                          outline=‘PHP语言是目前Web后端开发使用最广泛的语言，几乎绝大多数网站使用。PHP开发快速，开发成本低，周期短，后期维护费用低，开源产品丰富。‘)
 46             models.Course.objects.create(name=‘Java‘, price=‘9999‘, period=‘60‘,
 47                                          outline=‘完成本套餐的学习，学员可以全面掌握后续JavaEE开发所需的Java技术，为后续学习JavaEE开发打下坚实的基础。‘)
 48 
 49             # ————————47PerfectCRM实现CRM客户报名流程————————
 50 
 51             # models.UserProfile.objects.create(name=‘ADMIN系统维护‘, user_id=1)
 52             # models.UserProfile.objects.create(name=‘李白销售老师‘, user_id=2)
 53             # models.UserProfile.objects.create(name=‘杜甫销售老师‘, user_id=3)
 54             # models.UserProfile.objects.create(name=‘唐伯虎销售老师‘, user_id=4)
 55             # models.UserProfile.objects.create(name=‘颜真卿老师‘, user_id=5)
 56             # models.UserProfile.objects.create(name=‘罗贯中老师‘, user_id=6)
 57             # models.UserProfile.objects.create(name=‘白居易老师‘, user_id=7)
 58             # models.UserProfile.objects.create(name=‘施耐庵老师‘, user_id=8)
 59             # models.UserProfile.objects.create(name=‘曹雪芹校长‘, user_id=9)
 60 
 61 
 62             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin@qq.com‘, name=‘admin‘, is_active=1,
 63                                               is_superuser=1,
 64                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 65             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin1@qq.com‘, name=‘admin1‘,
 66                                               is_active=1, is_superuser=1,
 67                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 68             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin2@qq.com‘, name=‘admin2‘,
 69                                               is_active=1, is_superuser=1,
 70                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 71             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin3@qq.com‘, name=‘admin3‘,
 72                                               is_active=1, is_superuser=1,
 73                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 74             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin4@qq.com‘, name=‘admin4‘,
 75                                               is_active=1, is_superuser=1,
 76                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 77             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin5@qq.com‘, name=‘admin5‘,
 78                                               is_active=1, is_superuser=1,
 79                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 80             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin6@qq.com‘, name=‘admin6‘,
 81                                               is_active=1, is_superuser=1,
 82                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 83             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin7@qq.com‘, name=‘admin7‘,
 84                                               is_active=1, is_superuser=1,
 85                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 86             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin8@qq.com‘, name=‘admin8‘,
 87                                               is_active=1, is_superuser=1,
 88                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 89             models.UserProfile.objects.create(last_login=‘2018-04-18‘, email=‘admin9@qq.com‘, name=‘admin9‘,
 90                                               is_active=1, is_superuser=1,
 91                                               password=‘pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=‘)
 92             # ————————47PerfectCRM实现CRM客户报名流程————————
 93 
 94             models.ClassList.objects.create(class_type=1, semester=2, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
 95             models.ClassList.objects.create(class_type=0, semester=5, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
 96             models.ClassList.objects.create(class_type=2, semester=8, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
 97             models.ClassList.objects.create(class_type=0, semester=1, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
 98             models.ClassList.objects.create(class_type=1, semester=3, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
 99             models.ClassList.objects.create(class_type=0, semester=9, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
100             models.ClassList.objects.create(class_type=2, semester=6, start_date=‘2018-03-20‘, branch_id=1, course_id=1)
101             models.ClassList.objects.create(class_type=1, semester=20, start_date=‘2018-03-20‘, branch_id=1,
102                                             course_id=1)
103             models.ClassList.objects.create(class_type=0, semester=32, start_date=‘2018-03-20‘, branch_id=1,
104                                             course_id=1)
105 
106 
107         except:
108             return HttpResponse(‘基本数据已经添加了。。。‘)
109 
110         return redirect(‘/DBadd/crm_Role/‘)
111 
112 
113 # 添加"""10账号表"""  #随机学生
114 def crm_UserProfile(request):
115     if request.method == "GET":
116         user_list = models.UserProfile.objects.all()
117         return render(request, ‘crm_UserProfile.html‘, {‘user_list‘: user_list})
118     elif request.method == "POST":
119         for i in range(50):
120 
121             Rword = ‘‘.join(‘‘.join([chr(random.randint(0x4E00, 0x9FBF)) for i in range(3)]).split())  # 随机中文
122             n = Rword
123 
124             a = models.UserProfile.objects.values("user_id").all()
125             e = auth_models.User.objects.values("id").all()
126             print(‘eeeee‘, e, type(e))
127             x = e.difference(a)
128             # for i in x:
129             #     print(‘zzz‘, x, type(x))
130 
131             l = []
132             for i in x:
133                 l.append(i[‘id‘])
134             print(‘llll‘, l, type(l))
135 
136             if len(l) == 0:
137                 return HttpResponse(‘请添加 admin的用户后，再来添加。。。‘)
138             else:
139                 c = choice(l)
140                 u = c
141                 models.UserProfile.objects.create(name=n, user_id=u)
142         return redirect(‘/DBadd/crm_UserProfile/‘)
143 
144 
145 # 添加"""10账号表--11角色表""" #随机学生
146 def crm_userprofile_roles(request):
147     if request.method == "GET":
148         user_list = models.UserProfile.objects.all()
149         role_list = models.Role.objects.get(id=1)
150         return render(request, ‘crm_userprofile_roles.html‘, {‘user_list‘: user_list, ‘role_list‘: role_list})
151     elif request.method == "POST":
152         try:
153             for i in range(50):
154                 b1 = models.Role.objects.get(id=1)
155                 a = b1.userprofile_set.values("id").all()
156 
157                 e = models.UserProfile.objects.values("id").all()
158                 x = e.difference(a)
159 
160                 l = []
161                 for i in x:
162                     l.append(i[‘id‘])
163                 print(‘llll‘, l, type(l))
164 
165                 if len(l) == 0:
166                     return HttpResponse(‘请添加 数据 后，再来添加。。。‘)
167                 else:
168                     c = choice(l)
169                     print(‘c‘, c, type(c))
170 
171                     g1 = models.UserProfile.objects.get(id=c)
172                     b1 = models.Role.objects.get(id=1)
173                     g1.roles.add(b1)
174             return redirect(‘/DBadd/crm_userprofile_roles/‘)
175         except:
176             return HttpResponse(‘没有数据了。。。‘)
177 
178 
179 # 添加"""04客户信息表"""
180 def crm_Customer(request):
181     if request.method == "GET":
182         user_list = models.Customer.objects.all()
183         return render(request, ‘crm_Customer.html‘, {‘user_list‘: user_list})
184     elif request.method == "POST":
185         for i in range(50):
186             Rword = ‘‘.join(‘‘.join([chr(random.randint(0x4E00, 0x9FBF)) for i in range(3)]).split())  # 随机中文
187             r = random.randint(5, 18)
188             Num = "".join(random.choice("0123456789") for i in range(r))  # 随机数字 #保证qq的唯一性
189             Cnum = "".join(random.choice("123456789") for i in range(1))  # 随机数字  #id 不能选择0
190             try:
191                 models.Customer.objects.create(name=Rword, qq=Num, qq_name=Rword, phone=Num, source=1,
192                                                referral_from=Rword, consult_courses_id=1, content=Rword,
193                                                consultant_id=Cnum, memo=Rword, date=‘2018-03-20‘)
194             except:
195                 return HttpResponse(‘数据重复了。。。‘)
196 
197         return redirect(‘/DBadd/crm_Customer/‘)
198 
199 
200 # ————————03PerfectCRM创建基本数据————————
201 
202 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
203 def crm_ContractTemplate(request):
204     if request.method == "GET":
205         user_list = models.ContractTemplate.objects.all()
206         return render(request, ‘crm_ContractTemplate.html‘, {‘user_list‘: user_list})
207     elif request.method == "POST":
208         try:
209             t = ‘‘‘
210             委托方：＿＿{stu_name}＿＿ 
211 　　法定代表人或负责人：＿＿{stu_name}＿＿ 
212 　　服务方：＿＿＿＿＿＿＿ 
213 　　法定代表人或负责人：＿＿＿＿＿＿＿＿＿ 
214 　　根据《中华人民共和国合同法》的有关规定，经双方当事人协商一致，签订本 
215 合同。 
216 　　第一条　项目名称＿＿{course_name}＿＿。 
217 　　（注：本参考格式适用于下列技术服务活动：进行设计、工艺、制造、试验以 
218 及农作物育种，畜禽的饲养等方面的技术指导、讲解技术资料、解决和解答技术问 
219 题；进行示范操作；传授计算机软件的编制技术、先进仪器设备的装配，使用技术 
220 等等。） 
221 　　第二条　培训的内容和要求：＿＿＿＿＿＿＿。 
222 　　第三条　培训计划、进度、期限：＿＿＿＿＿＿＿。 
223 　　第四条　培训地点和方式：＿＿＿＿＿＿＿＿＿＿＿＿。 
224 　　第五条　服务方（教师）的资历和水平：＿＿＿＿＿＿＿＿。 
225 　　第六条　学员的人数和质量：＿＿＿＿＿＿＿＿＿＿＿。 
226 　　第七条　教员、学员的食宿、交通、医疗费用的支付和安排＿＿＿＿。 
227 　　第八条　报酬及其支付方式：＿＿＿＿＿＿＿＿＿＿。 
228 　　第九条　委托方的违约责任：＿＿＿＿＿＿＿＿＿。 
229 　　１．委托方未按合同提供培训条件，影响合同履行的，约定的报酬仍应如数支 
230 付； 
231 　　２．擅自将服务方要求保密的技术资料引用、发表和提供给第三方，应支付数 
232 额为＿＿＿＿的违约金； 
233 　　第十条　服务方的违约责任： 
234 　　１．服务方未按合同制订培训计划，影响培训工作质量的，应当减收＿＿＿％ 
235 的报酬； 
236 　　２．服务方提供的师资不符合合同要求，服务方有义务予以重新配备；未按合 
237 同规定完成培训工作的，应免收报酬。 
238 　　第十一条　保密条款：＿＿＿＿＿＿＿＿ 
239 　　当事人双方应对下列技术资料承担保密义务：＿＿＿＿＿＿。 
240 　　第十二条　有关技术成果归属条款 
241 　　在履行合同过程中，服务方利用委托方提供的技术资料和工作条件所完成的新 
242 的技术成果，属于服务方；委托方利用服务方的工作成果所完成的新技术成果，属 
243 于委托方。对新的技术成果享有就该技术成果取得的精神权利（如获得奖金、奖章、 
244 荣誉证书的权利）、经济权利（如专利权、非专利技术的转让权，使用权等）和 
245 其它利益。 
246 　　第十三条　本合同争议的解决办法：＿＿＿＿＿＿。 
247 　　本合同自双方当事人签字、盖章后生效。
248 委托方负责人（或授权代表）　　　　　　服务方负责人（或授权代表） 
249 　　签字：＿＿{stu_name}＿＿（盖章）　　　　　签名：＿＿＿＿（盖章） 
250 　　签字时间：＿＿＿＿＿＿＿＿＿　　　　　签字时间：＿＿＿＿＿＿＿＿＿ 
251 　　签字地点：＿＿＿＿＿＿＿＿＿　　　　　签字地点：＿＿＿＿＿＿＿＿＿ 
252 　　开户银行：＿＿＿＿＿＿＿＿＿　　　　　开户银行：＿＿＿＿＿＿＿＿＿ 
253 　　帐号：＿＿＿＿＿＿＿＿＿＿＿　　　　　帐号：＿＿＿＿＿＿＿＿＿＿＿ 
254 　　委托方担保人（名称）：＿＿＿　　　　　服务方担保人（名称）：＿＿＿ 
255 　　地址：＿＿＿＿＿＿＿＿＿＿＿　　　　　地址：＿＿＿＿＿＿＿＿＿＿＿ 
256 　　负责人（或授权代表）　　　　　　　　　负责人（或授权代表） 
257 　　签字：＿＿＿＿＿＿＿＿（盖章）　　　　签字：＿＿＿＿＿＿＿＿（盖章） 
258 　　签字时间：＿＿＿＿＿＿＿＿＿　　　　　签字时间：＿＿＿＿＿＿＿＿＿ 
259 　　签字地点：＿＿＿＿＿＿＿＿＿　　　　　签字地点：＿＿＿＿＿＿＿＿＿ 
260 　　开户银行：＿＿＿＿＿＿＿＿＿　　　　　开户银行：＿＿＿＿＿＿＿＿＿ 
261 　　帐号：＿＿＿＿＿＿＿＿＿＿＿　　　　　帐号：＿＿＿＿＿＿＿＿＿＿＿‘‘‘
262 
263             models.ContractTemplate.objects.create(name=‘技术合同：专业技术培训协议‘, template=t)
264         except:
265             return HttpResponse(‘数据错误！重复了吧。。。‘)
266 
267         return redirect(‘/DBadd/crm_ContractTemplate/‘)
268 
269 
270 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
271 
272 # ————————60PerfectCRM实现CRM学生上课记录————————
273 def DBadd(request):
274     return  render(request,‘DBadd.html‘,locals())
275 def crm_CourseRecord(request):
276     if request.method == "GET":
277         user_list = models.CourseRecord.objects.all()
278         return render(request, ‘crm_CourseRecord.html‘, {‘user_list‘: user_list})
279     elif request.method == "POST":
280         a=1
281         for i in range(2):
282             try:
283                 # 创建班级  节课
284                 models.CourseRecord.objects.create(from_class_id=1, day_num=a, teacher_id=1, has_homework=1, outline=1,date=‘2018-05-05‘)
285                 models.CourseRecord.objects.create(from_class_id=2, day_num=a, teacher_id=1, has_homework=1, outline=1,date=‘2018-05-05‘)
286                 models.CourseRecord.objects.create(from_class_id=3, day_num=a, teacher_id=1, has_homework=1, outline=1,date=‘2018-05-05‘)
287                 a+=1
288                 # 创建班级  节课
289             except:
290                 return HttpResponse(‘数据错误！重复了吧。。。‘)
291         return redirect(‘/DBadd/crm_CourseRecord/‘)
292 def crm_Enrollment(request):
293     if request.method == "GET":
294         user_list = models.Enrollment.objects.all()
295         return render(request, ‘crm_Enrollment.html‘, {‘user_list‘: user_list})
296     elif request.method == "POST":
297         a=1
298         for i in range(6):
299             try:
300                 # 创建报名信息
301                 models.Enrollment.objects.create(customer_id=a, enrolled_class_id=1, consultant_id=1, contract_review=1,contract_agreed=1,contract_approved=1,Pay_cost=1,date=‘2018-05-05 14:45:19.537109‘)
302                 models.Enrollment.objects.create(customer_id=a, enrolled_class_id=2, consultant_id=1, contract_review=1,contract_agreed=1,contract_approved=1,Pay_cost=1,date=‘2018-05-05 14:45:19.537109‘)
303                 models.Enrollment.objects.create(customer_id=a, enrolled_class_id=3, consultant_id=1, contract_review=1,contract_agreed=1,contract_approved=1,Pay_cost=1,date=‘2018-05-05 14:45:19.537109‘)
304                 a+=1
305                 # 创建报名信息
306             except:
307                 return HttpResponse(‘数据错误！重复了吧。。。‘)
308         return redirect(‘/DBadd/crm_Enrollment/‘)
309 # ————————60PerfectCRM实现CRM学生上课记录————————

 1 {#DBadd.html#}
 2 {## ————————60PerfectCRM实现CRM学生上课记录————————#}
 3 <!DOCTYPE html>
 4 <html lang="en">
 5 <head>
 6     <meta charset="UTF-8">
 7     <title>Title</title>
 8 </head>
 9 <body>
10 <div style="margin:0 auto;width:50%">
11     <h1><a target="_blank" href="crm_ContractTemplate/"> 添加合同</a></h1>
12     <h1><a target="_blank" href="crm_Role/"> 添加基本信息</a></h1>
13     <h1><a target="_blank" href="crm_Customer/"> 添加学生</a></h1>
14     <h1><a target="_blank" href="crm_CourseRecord/"> 添加班级节次</a></h1>
15     <h1><a target="_blank" href="crm_Enrollment/"> 添加报名信息</a></h1>
16 </div>
17 
18 </body>
19 </html>
20 {## ————————60PerfectCRM实现CRM学生上课记录————————#}

 1 {#crm_CourseRecord.html#}
 2 {## ————————60PerfectCRM实现CRM学生上课记录————————#}
 3 <!DOCTYPE html>
 4 <html lang="en">
 5 <head>
 6     <meta charset="UTF-8">
 7     <title>Title</title>
 8 </head>
 9 <body>
10             <h3>添加班级</h3>
11             <form method="POST" action="/DBadd/crm_CourseRecord/">
12                  {% csrf_token %}
13                 <input type="submit"value="添加"/>
14             </form>
15             <h3>班级详细</h3>
16             <ul>
17                 {% for row in user_list %}
18                     <li>
19                         <a>{{row.id}}-{{row.from_class}}</a>
20                     </li>
21                 {% endfor %}
22             </ul>
23 </body>
24 </html>
25 {## ————————60PerfectCRM实现CRM学生上课记录————————#}

 1 {#crm_Enrollment.html#}
 2 {## ————————60PerfectCRM实现CRM学生上课记录————————#}
 3 <!DOCTYPE html>
 4 <html lang="en">
 5 <head>
 6     <meta charset="UTF-8">
 7     <title>Title</title>
 8 </head>
 9 <body>
10             <h3>添加报名信息</h3>
11             <form method="POST" action="/DBadd/crm_Enrollment/">
12                  {% csrf_token %}
13                 <input type="submit"value="添加"/>
14             </form>
15             <h3>详细</h3>
16             <ul>
17                 {% for row in user_list %}
18                     <li>
19                         <a>{{row.id}}-{{row.customer}}</a>
20                     </li>
21                 {% endfor %}
22             </ul>
23 </body>
24 </html>
25 
26 {## ————————60PerfectCRM实现CRM学生上课记录————————#}