#urls.py """PerfectCRM URL Configuration The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.0/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path # ————————02PerfectCRM创建ADMIN页面————————
from django.conf.urls import url # URL
from django.conf.urls import include # 分发URL
# ————————02PerfectCRM创建ADMIN页面———————— # ————————46PerfectCRM实现登陆后页面才能访问————————
from PerfectCRM import main_views
# ————————46PerfectCRM实现登陆后页面才能访问———————— urlpatterns = [
path('admin/', admin.site.urls), # ————————02PerfectCRM创建ADMIN页面————————
url(r'^king_admin/', include("king_admin.king_urls")), # 自定义admin
# ————————02PerfectCRM创建ADMIN页面———————— # ————————03PerfectCRM创建基本数据————————
url(r'^DBadd/', include("DBadd.DBadd_urls")), # 添加随机数据
# ————————03PerfectCRM创建基本数据————————
# ————————38PerfectCRM实现全局账号登录注销————————
url(r'^gbacc/', include("gbacc.gbacc_urls")), # 全局账号登录注销
# ————————38PerfectCRM实现全局账号登录注销———————— # ————————42PerfectCRM实现AJAX全局账号注册————————
url(r'^gbacc/', include("gbacc.gbacc_ajax_urls")), # 全局账号登录注销
# ————————42PerfectCRM实现AJAX全局账号注册———————— # ————————46PerfectCRM实现登陆后页面才能访问————————
url(r'^$', main_views.PortalView.as_view()),
# ————————46PerfectCRM实现登陆后页面才能访问———————— # ————————47PerfectCRM实现CRM客户报名流程————————
url(r'^bpm/', include("bpm.sales.sales_urls")), # 业务流程 #学生报名
# ————————47PerfectCRM实现CRM客户报名流程———————— # ————————53PerfectCRM实现CRM客户报名流程缴费————————
url(r'^bpm/', include("bpm.financial.financial_urls")), # 业务流程 #财务缴费
# ————————53PerfectCRM实现CRM客户报名流程缴费———————— # ————————60PerfectCRM实现CRM学生上课记录————————
url(r'^bpm/', include("bpm.student.student_urls")), # 业务流程 # 学生上课记录
# ————————60PerfectCRM实现CRM学生上课记录————————
]
#urls.py
# student_urls.py
# ————————60PerfectCRM实现CRM学生上课记录————————
from django.conf.urls import url
from bpm.student import student_views urlpatterns = [
url(r'^student_course/$', student_views.student_course, name='student_course'), #学生报名的课程
url(r'^studyrecords/(\d+)/$', student_views.studyrecords, name='studyrecords'), # #学生上课记录列表StudyRecord ]
# ————————60PerfectCRM实现CRM学生上课记录————————
# student_urls.py
# student_views.py
# ————————60PerfectCRM实现CRM学生上课记录————————
from django.shortcuts import render #页面返回
from crm import models #数据库
from django.contrib.auth.decorators import login_required # 登陆后页面才能访问
#学生报名的课程
@login_required # 登陆后页面才能访问
def student_course(request):
if request.user.stu_account:
enrollmentlist=request.user.stu_account.enrollment_set.all()#根据账号表关联的ID获取06学员报名信息表
return render(request, 'bpm_student/student_course.html', locals()) #学生上课记录列表
@login_required # 登陆后页面才能访问
def studyrecords(request,enroll_obj_id):
enroll_obj=models.Enrollment.objects.get(id=enroll_obj_id)#根据ID获取06学员报名信息表
studyrecordlist=enroll_obj.studyrecord_set.all()#根据06学员报名信息表的ID获取09学习纪录
return render(request,'bpm_student/studyrecords.html',locals()) # ————————60PerfectCRM实现CRM学生上课记录————————
# student_views.py
# bpm_tags.py # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
from django import template
register = template.Library() #模板库 #合同格式
@register.simple_tag
def render_enrolled_contract(enroll_obj):#合同格式
if enroll_obj.enrolled_class.contract.template:
return enroll_obj.enrolled_class.contract.template.format(course_name=enroll_obj.enrolled_class,stu_name=enroll_obj.customer.name)
else:
return '' # ————————48PerfectCRM实现CRM客户报名流程学生合同———————— # ————————60PerfectCRM实现CRM学生上课记录———————— # from django import template
# register = template.Library() #模板库
from django.db.models import Sum
#分数统计#我的成绩
@register.simple_tag
def get_score(enroll_obj,customer_obj):
study_records=enroll_obj.studyrecord_set.filter(course_record__from_class_id=enroll_obj.enrolled_class.id)#根据班级ID 取09学习纪录的信息(包含'score')
sum_score= study_records.aggregate(Sum('score')) #aggregate #总 #返回一个字典,其中包含的计算(聚合) #Sum #合计值
return sum_score # ————————60PerfectCRM实现CRM学生上课记录————————
# bpm_tags.py
{#student_course.html#}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{% extends 'bpm_master/bpm_sample.html' %}
{% load bpm_tags %}
{% block right-container-content %} {#自定义内容开始 右边页面内容#}
<div class="panel-default">
<div class="panel-body">
<h4>当前用户： {{ request.user }} | 学员名字:{{ request.user.stu_account.name }} |
学员QQ:{{ request.user.stu_account }}</h4>
<ol class="breadcrumb">
<li><a href="/bpm/student_course/">我的课程</a></li>
</ol>
<table class="table table-striped table-responsive">
<thead>
<tr>
<th>校区班级</th>
<th>班级类型</th>
<th>课程进度</th>
<th>课程成绩</th>
<th>开课日期</th>
<th>结业日期</th>
</tr>
</thead>
<tbody>
{% for enroll_obj in enrollmentlist %}
<tr>
<td>{{ enroll_obj.enrolled_class }}</td>
{#校区班级#}
<td>{{ enroll_obj.enrolled_class.get_class_type_display }}</td>
{#班级类型#}
<td>
<a href="{% url 'studyrecords' enroll_obj.id %}">已上: {{ enroll_obj.enrolled_class.courserecord_set.all.count }}节</a>
</td>
{#课程进度#}
<td>
{% get_score enroll_obj request.user.stu_account as score_data %}{{ score_data.score__sum }}</td>
{#课程成绩#}
<td>{{ enroll_obj.enrolled_class.start_date }}</td>
{#开课日期#}
<td>{{ enroll_obj.enrolled_class.end_date }}</td>
{#结业日期#}
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endblock %}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{#student_course.html#}
{#studyrecords.html#}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{% extends 'bpm_master/bpm_sample.html' %}
{% load bpm_tags %}
{% block right-container-content %} {#自定义内容开始 右边页面内容#}
<div class="panel-default">
<div class="panel-body">
<h4>当前用户： {{ request.user }} | 学员名字:{{ request.user.stu_account.name }} |
学员QQ:{{ request.user.stu_account }}</h4>
<ol class="breadcrumb">
<li><a href="/bpm/student_course/">我的课程</a></li>
<li><a href="/bpm/studyrecords/{{ enroll_obj.id }}/">{{ enroll_obj.enrolled_class }}</a></li>
</ol>
<table class="table table-striped table-responsive ">
<thead>
<tr>
<th>课程节次</th>
<th>签到状态</th>
<th>本节作业</th>
<th>本节成绩</th>
<th>本节讲师</th>
<th>上课日期</th>
<th>本节大纲</th>
<th>作业标题</th>
<th>作业要求</th>
</tr>
</thead>
<tbody>
{% for studyrecord in studyrecordlist %}
<tr>
<td>{{ studyrecord.course_record.day_num }}</td>
{#课程节次#}
<td>{{ studyrecord.get_attendance_display }}</td>
{#签到状态#}
<td> {{ studyrecord.course_record.has_homework }}</td>
{#本节作业#}
<td>{{ studyrecord.get_score_display }}</td>
{#本节成绩#}
<td>{{ studyrecord.course_record.teacher }}</td>
{#本节讲师#}
<td>{{ studyrecord.course_record.date }}</td>
{#上课日期#}
<td>
<pre style="width: 240px;height: 60px">{{ studyrecord.course_record.outline }}</pre>
{#本节大纲#}
</td>
<td>
<pre style="width: 240px;height: 60px">{{ studyrecord.course_record.homework_title }}</pre>
{#作业标题#}
</td>
<td>
<pre style="width: 240px;height: 60px">{{ studyrecord.course_record.homework_content }}</pre>
{#作业要求#}
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endblock %}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{#studyrecords.html#}
#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']#必填字段 # ————————60PerfectCRM实现CRM学生上课记录————————
stu_account=models.ForeignKey("Customer",verbose_name='关联学员帐号',blank=True,null=True,on_delete=models.CASCADE,help_text='报名成功后创建关联帐户')
# ————————60PerfectCRM实现CRM学生上课记录———————— 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————————
#models.py
# DBadd_urls.py
# ————————03PerfectCRM创建基本数据————————
from django.conf.urls import url
from DBadd import auth_views
from DBadd import crm_views urlpatterns = [
url(r'^auth_user/$', auth_views.auth_user), #Django账号表 url(r'^crm_Role/$', crm_views.crm_Role), #角色表 等基本信息
url(r'^crm_UserProfile/$', crm_views.crm_UserProfile),#账号表 #随机学生
url(r'^crm_userprofile_roles/$', crm_views.crm_userprofile_roles),#账号角色关联表 #随机学生 url(r'^crm_Customer/$', crm_views.crm_Customer), # 04客户信息表 # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
url(r'^crm_ContractTemplate/$', crm_views.crm_ContractTemplate), # 角色表 等基本信息
# ————————48PerfectCRM实现CRM客户报名流程学生合同———————— # ————————60PerfectCRM实现CRM学生上课记录————————
url(r'^$', crm_views.DBadd), # Django账号表
url(r'^crm_CourseRecord/$', crm_views.crm_CourseRecord), # 班级节课
url(r'^crm_Enrollment/$', crm_views.crm_Enrollment), # 报名信息
# ————————60PerfectCRM实现CRM学生上课记录———————— ]
# ————————03PerfectCRM创建基本数据————————
# DBadd_urls.py
# crm_views.py # ————————03PerfectCRM创建基本数据———————— from django.shortcuts import render
from django.shortcuts import redirect
from django.shortcuts import HttpResponse from crm import models
from django.contrib.auth import models as auth_models # 随机字符串
import random
from random import choice # 添加"""基本数据"""
def crm_Role(request):
if request.method == "GET":
user_list = models.Role.objects.all()
return render(request, 'crm_Role.html', {'user_list': user_list})
elif request.method == "POST":
try:
models.Role.objects.create(name='角色学生')
models.Role.objects.create(name='角色销售')
models.Role.objects.create(name='角色老师')
models.Role.objects.create(name='角色校长')
models.Role.objects.create(name='角色系统维护') models.Branch.objects.create(name='北京校区', addr='北京*')
models.Branch.objects.create(name='广东校区', addr='广东东莞市')
models.Branch.objects.create(name='上海校区', addr='上海黄浦江')
models.Branch.objects.create(name='福建校区', addr='福建仙游县')
models.Branch.objects.create(name='四川校区', addr='四川成都市') models.Tag.objects.create(name='好，很好')
models.Tag.objects.create(name='很有兴趣')
models.Tag.objects.create(name='兴趣不大')
models.Tag.objects.create(name='交钱很爽快')
models.Tag.objects.create(name='随便问问的') models.Course.objects.create(name='Pyton', price='', period='',
outline='Python , 是一种面向对象的解释型计算机程序设计语言，具有丰富和强大的库，Python 已经成为继JAVA，C++之后的的第三大语言。 特点：简单易学、免费开源、高层语言、可移植性强、面向对象、可扩展性、可嵌入型、丰富的库、规范的代码等。')
models.Course.objects.create(name='PHP', price='', period='',
outline='PHP语言是目前Web后端开发使用最广泛的语言，几乎绝大多数网站使用。PHP开发快速，开发成本低，周期短，后期维护费用低，开源产品丰富。')
models.Course.objects.create(name='Java', price='', period='',
outline='完成本套餐的学习，学员可以全面掌握后续JavaEE开发所需的Java技术，为后续学习JavaEE开发打下坚实的基础。') # ————————47PerfectCRM实现CRM客户报名流程———————— # models.UserProfile.objects.create(name='ADMIN系统维护', user_id=1)
# models.UserProfile.objects.create(name='李白销售老师', user_id=2)
# models.UserProfile.objects.create(name='杜甫销售老师', user_id=3)
# models.UserProfile.objects.create(name='唐伯虎销售老师', user_id=4)
# models.UserProfile.objects.create(name='颜真卿老师', user_id=5)
# models.UserProfile.objects.create(name='罗贯中老师', user_id=6)
# models.UserProfile.objects.create(name='白居易老师', user_id=7)
# models.UserProfile.objects.create(name='施耐庵老师', user_id=8)
# models.UserProfile.objects.create(name='曹雪芹校长', user_id=9) models.UserProfile.objects.create(last_login='2018-04-18', email='admin@qq.com', name='admin', is_active=1,
is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin1@qq.com', name='admin1',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin2@qq.com', name='admin2',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin3@qq.com', name='admin3',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin4@qq.com', name='admin4',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin5@qq.com', name='admin5',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin6@qq.com', name='admin6',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin7@qq.com', name='admin7',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin8@qq.com', name='admin8',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
models.UserProfile.objects.create(last_login='2018-04-18', email='admin9@qq.com', name='admin9',
is_active=1, is_superuser=1,
password='pbkdf2_sha256$100000$cCkwdwzBiea6$VNOFkD7HAKwsjKXsDZMOGO8ct3EpVMaX2JPU+h5PK9E=')
# ————————47PerfectCRM实现CRM客户报名流程———————— models.ClassList.objects.create(class_type=1, semester=2, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=0, semester=5, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=2, semester=8, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=0, semester=1, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=1, semester=3, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=0, semester=9, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=2, semester=6, start_date='2018-03-20', branch_id=1, course_id=1)
models.ClassList.objects.create(class_type=1, semester=20, start_date='2018-03-20', branch_id=1,
course_id=1)
models.ClassList.objects.create(class_type=0, semester=32, start_date='2018-03-20', branch_id=1,
course_id=1) except:
return HttpResponse('基本数据已经添加了。。。') return redirect('/DBadd/crm_Role/') # 添加"""10账号表""" #随机学生
def crm_UserProfile(request):
if request.method == "GET":
user_list = models.UserProfile.objects.all()
return render(request, 'crm_UserProfile.html', {'user_list': user_list})
elif request.method == "POST":
for i in range(50): Rword = ''.join(''.join([chr(random.randint(0x4E00, 0x9FBF)) for i in range(3)]).split()) # 随机中文
n = Rword a = models.UserProfile.objects.values("user_id").all()
e = auth_models.User.objects.values("id").all()
print('eeeee', e, type(e))
x = e.difference(a)
# for i in x:
# print('zzz', x, type(x)) l = []
for i in x:
l.append(i['id'])
print('llll', l, type(l)) if len(l) == 0:
return HttpResponse('请添加 admin的用户后，再来添加。。。')
else:
c = choice(l)
u = c
models.UserProfile.objects.create(name=n, user_id=u)
return redirect('/DBadd/crm_UserProfile/') # 添加"""10账号表--11角色表""" #随机学生
def crm_userprofile_roles(request):
if request.method == "GET":
user_list = models.UserProfile.objects.all()
role_list = models.Role.objects.get(id=1)
return render(request, 'crm_userprofile_roles.html', {'user_list': user_list, 'role_list': role_list})
elif request.method == "POST":
try:
for i in range(50):
b1 = models.Role.objects.get(id=1)
a = b1.userprofile_set.values("id").all() e = models.UserProfile.objects.values("id").all()
x = e.difference(a) l = []
for i in x:
l.append(i['id'])
print('llll', l, type(l)) if len(l) == 0:
return HttpResponse('请添加 数据 后，再来添加。。。')
else:
c = choice(l)
print('c', c, type(c)) g1 = models.UserProfile.objects.get(id=c)
b1 = models.Role.objects.get(id=1)
g1.roles.add(b1)
return redirect('/DBadd/crm_userprofile_roles/')
except:
return HttpResponse('没有数据了。。。') # 添加"""04客户信息表"""
def crm_Customer(request):
if request.method == "GET":
user_list = models.Customer.objects.all()
return render(request, 'crm_Customer.html', {'user_list': user_list})
elif request.method == "POST":
for i in range(50):
Rword = ''.join(''.join([chr(random.randint(0x4E00, 0x9FBF)) for i in range(3)]).split()) # 随机中文
r = random.randint(5, 18)
Num = "".join(random.choice("") for i in range(r)) # 随机数字 #保证qq的唯一性
Cnum = "".join(random.choice("") for i in range(1)) # 随机数字 #id 不能选择0
try:
models.Customer.objects.create(name=Rword, qq=Num, qq_name=Rword, phone=Num, source=1,
referral_from=Rword, consult_courses_id=1, content=Rword,
consultant_id=Cnum, memo=Rword, date='2018-03-20')
except:
return HttpResponse('数据重复了。。。') return redirect('/DBadd/crm_Customer/') # ————————03PerfectCRM创建基本数据———————— # ————————48PerfectCRM实现CRM客户报名流程学生合同————————
def crm_ContractTemplate(request):
if request.method == "GET":
user_list = models.ContractTemplate.objects.all()
return render(request, 'crm_ContractTemplate.html', {'user_list': user_list})
elif request.method == "POST":
try:
t = '''
委托方：＿＿{stu_name}＿＿
法定代表人或负责人：＿＿{stu_name}＿＿
服务方：＿＿＿＿＿＿＿
法定代表人或负责人：＿＿＿＿＿＿＿＿＿
根据《*合同法》的有关规定，经双方当事人协商一致，签订本
合同。
第一条 项目名称＿＿{course_name}＿＿。
（注：本参考格式适用于下列技术服务活动：进行设计、工艺、制造、试验以
及农作物育种，畜禽的饲养等方面的技术指导、讲解技术资料、解决和解答技术问
题；进行示范操作；传授计算机软件的编制技术、先进仪器设备的装配，使用技术
等等。）
第二条 培训的内容和要求：＿＿＿＿＿＿＿。
第三条 培训计划、进度、期限：＿＿＿＿＿＿＿。
第四条 培训地点和方式：＿＿＿＿＿＿＿＿＿＿＿＿。
第五条 服务方（教师）的资历和水平：＿＿＿＿＿＿＿＿。
第六条 学员的人数和质量：＿＿＿＿＿＿＿＿＿＿＿。
第七条 教员、学员的食宿、交通、医疗费用的支付和安排＿＿＿＿。
第八条 报酬及其支付方式：＿＿＿＿＿＿＿＿＿＿。
第九条 委托方的违约责任：＿＿＿＿＿＿＿＿＿。
１．委托方未按合同提供培训条件，影响合同履行的，约定的报酬仍应如数支
付；
２．擅自将服务方要求保密的技术资料引用、发表和提供给第三方，应支付数
额为＿＿＿＿的违约金；
第十条 服务方的违约责任：
１．服务方未按合同制订培训计划，影响培训工作质量的，应当减收＿＿＿％
的报酬；
２．服务方提供的师资不符合合同要求，服务方有义务予以重新配备；未按合
同规定完成培训工作的，应免收报酬。
第十一条 保密条款：＿＿＿＿＿＿＿＿
当事人双方应对下列技术资料承担保密义务：＿＿＿＿＿＿。
第十二条 有关技术成果归属条款
在履行合同过程中，服务方利用委托方提供的技术资料和工作条件所完成的新
的技术成果，属于服务方；委托方利用服务方的工作成果所完成的新技术成果，属
于委托方。对新的技术成果享有就该技术成果取得的精神权利（如获得奖金、奖章、
荣誉证书的权利）、经济权利（如专利权、非专利技术的转让权，使用权等）和
其它利益。
第十三条 本合同争议的解决办法：＿＿＿＿＿＿。
本合同自双方当事人签字、盖章后生效。
委托方负责人（或授权代表） 服务方负责人（或授权代表）
签字：＿＿{stu_name}＿＿（盖章） 签名：＿＿＿＿（盖章）
签字时间：＿＿＿＿＿＿＿＿＿ 签字时间：＿＿＿＿＿＿＿＿＿
签字地点：＿＿＿＿＿＿＿＿＿ 签字地点：＿＿＿＿＿＿＿＿＿
开户银行：＿＿＿＿＿＿＿＿＿ 开户银行：＿＿＿＿＿＿＿＿＿
帐号：＿＿＿＿＿＿＿＿＿＿＿ 帐号：＿＿＿＿＿＿＿＿＿＿＿
委托方担保人（名称）：＿＿＿ 服务方担保人（名称）：＿＿＿
地址：＿＿＿＿＿＿＿＿＿＿＿ 地址：＿＿＿＿＿＿＿＿＿＿＿
负责人（或授权代表） 负责人（或授权代表）
签字：＿＿＿＿＿＿＿＿（盖章） 签字：＿＿＿＿＿＿＿＿（盖章）
签字时间：＿＿＿＿＿＿＿＿＿ 签字时间：＿＿＿＿＿＿＿＿＿
签字地点：＿＿＿＿＿＿＿＿＿ 签字地点：＿＿＿＿＿＿＿＿＿
开户银行：＿＿＿＿＿＿＿＿＿ 开户银行：＿＿＿＿＿＿＿＿＿
帐号：＿＿＿＿＿＿＿＿＿＿＿ 帐号：＿＿＿＿＿＿＿＿＿＿＿''' models.ContractTemplate.objects.create(name='技术合同：专业技术培训协议', template=t)
except:
return HttpResponse('数据错误！重复了吧。。。') return redirect('/DBadd/crm_ContractTemplate/') # ————————48PerfectCRM实现CRM客户报名流程学生合同———————— # ————————60PerfectCRM实现CRM学生上课记录————————
def DBadd(request):
return render(request,'DBadd.html',locals())
def crm_CourseRecord(request):
if request.method == "GET":
user_list = models.CourseRecord.objects.all()
return render(request, 'crm_CourseRecord.html', {'user_list': user_list})
elif request.method == "POST":
a=1
for i in range(2):
try:
# 创建班级 节课
models.CourseRecord.objects.create(from_class_id=1, day_num=a, teacher_id=1, has_homework=1, outline=1,date='2018-05-05')
models.CourseRecord.objects.create(from_class_id=2, day_num=a, teacher_id=1, has_homework=1, outline=1,date='2018-05-05')
models.CourseRecord.objects.create(from_class_id=3, day_num=a, teacher_id=1, has_homework=1, outline=1,date='2018-05-05')
a+=1
# 创建班级 节课
except:
return HttpResponse('数据错误！重复了吧。。。')
return redirect('/DBadd/crm_CourseRecord/')
def crm_Enrollment(request):
if request.method == "GET":
user_list = models.Enrollment.objects.all()
return render(request, 'crm_Enrollment.html', {'user_list': user_list})
elif request.method == "POST":
a=1
for i in range(6):
try:
# 创建报名信息
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')
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')
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')
a+=1
# 创建报名信息
except:
return HttpResponse('数据错误！重复了吧。。。')
return redirect('/DBadd/crm_Enrollment/')
# ————————60PerfectCRM实现CRM学生上课记录————————
# crm_views.py
{#DBadd.html#}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<div style="margin:0 auto;width:50%">
<h1><a target="_blank" href="crm_ContractTemplate/"> 添加合同</a></h1>
<h1><a target="_blank" href="crm_Role/"> 添加基本信息</a></h1>
<h1><a target="_blank" href="crm_Customer/"> 添加学生</a></h1>
<h1><a target="_blank" href="crm_CourseRecord/"> 添加班级节次</a></h1>
<h1><a target="_blank" href="crm_Enrollment/"> 添加报名信息</a></h1>
</div>
</body>
</html>
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{#DBadd.html#}
{#crm_CourseRecord.html#}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h3>添加班级</h3>
<form method="POST" action="/DBadd/crm_CourseRecord/">
{% csrf_token %}
<input type="submit"value="添加"/>
</form>
<h3>班级详细</h3>
<ul>
{% for row in user_list %}
<li>
<a>{{row.id}}-{{row.from_class}}</a>
</li>
{% endfor %}
</ul>
</body>
</html>
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{#crm_CourseRecord.html#}
{#crm_Enrollment.html#}
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h3>添加报名信息</h3>
<form method="POST" action="/DBadd/crm_Enrollment/">
{% csrf_token %}
<input type="submit"value="添加"/>
</form>
<h3>详细</h3>
<ul>
{% for row in user_list %}
<li>
<a>{{row.id}}-{{row.customer}}</a>
</li>
{% endfor %}
</ul>
</body>
</html>
{## ————————60PerfectCRM实现CRM学生上课记录————————#}
{#crm_Enrollment.html#}
