CRM项目总结

  1 from django.db import models
  2 from rbac import models as rbac_model
  3 # Create your models here.
  4 
  5 
  6 class Department(models.Model):
  7     """
  8     部门表
  9     市场部     1000
 10     销售      1001
 11     """
 12     title = models.CharField(verbose_name=‘部门名称‘, max_length=16)
 13     code = models.IntegerField(verbose_name=‘部门编号‘,unique=True,null=False)
 14 
 15     def __str__(self):
 16         return self.title
 17 
 18 
 19 class UserInfo(models.Model):
 20     """
 21     员工表
 22     """
 23     auth = models.OneToOneField(verbose_name=‘用户权限‘, to=rbac_model.User,null=True,blank=True)
 24     name = models.CharField(verbose_name=‘员工姓名‘, max_length=16)
 25     username = models.CharField(verbose_name=‘用户名‘, max_length=32)
 26     password = models.CharField(verbose_name=‘密码‘, max_length=64)
 27     email = models.EmailField(verbose_name=‘邮箱‘, max_length=64)
 28     openid = models.CharField(verbose_name=‘微信唯一ID‘, max_length=64, null=True, blank=True)
 29     depart = models.ForeignKey(verbose_name=‘部门‘, to="Department",to_field="code")
 30 
 31     def __str__(self):
 32         return self.name
 33 
 34 
 35 class Course(models.Model):
 36     """
 37     课程表
 38     如：
 39         Linux基础
 40         Linux架构师
 41         Python自动化开发精英班
 42         Python自动化开发架构师班
 43     """
 44     name = models.CharField(verbose_name=‘课程名称‘, max_length=32)
 45 
 46     def __str__(self):
 47         return self.name
 48 
 49 
 50 class School(models.Model):
 51     """
 52     校区表
 53 
 54     """
 55     title = models.CharField(verbose_name=‘校区名称‘, max_length=32)
 56 
 57     def __str__(self):
 58         return self.title
 59 
 60 
 61 class ClassList(models.Model):
 62     """
 63     班级表
 64     如：
 65         烧饼  打饼班  1期  10000  2017-11-11  2018-5-11
 66     """
 67     school = models.ForeignKey(verbose_name=‘校区‘, to=‘School‘)
 68     course = models.ForeignKey(verbose_name=‘课程名称‘, to=‘Course‘)
 69 
 70     semester = models.IntegerField(verbose_name="班级(期)")
 71     price = models.IntegerField(verbose_name="学费")
 72     start_date = models.DateField(verbose_name="开班日期")
 73     graduate_date = models.DateField(verbose_name="结业日期", null=True, blank=True)
 74     memo = models.CharField(verbose_name=‘说明‘, max_length=256, blank=True, null=True, )
 75     teachers = models.ManyToManyField(verbose_name=‘任课老师‘, to=‘UserInfo‘, related_name=‘teach_classes‘,limit_choices_to={‘depart_id__in‘:[1003,1004]})
 76     tutor = models.ForeignKey(verbose_name=‘班主任‘, to=‘UserInfo‘, related_name=‘classes‘,limit_choices_to={‘depart_id‘:1002})
 77 
 78     def __str__(self):
 79         return "{0}({1}期)".format(self.course.name, self.semester)
 80 
 81 
 82 class Customer(models.Model):
 83     """
 84     客户表
 85     """
 86     qq = models.CharField(verbose_name=‘qq‘, max_length=64, unique=True, help_text=‘QQ号必须唯一‘)
 87 
 88     name = models.CharField(verbose_name=‘学生姓名‘, max_length=16)
 89     gender_choices = ((1, ‘男‘), (2, ‘女‘))
 90     gender = models.SmallIntegerField(verbose_name=‘性别‘, choices=gender_choices)
 91 
 92     education_choices = (
 93         (1, ‘重点大学‘),
 94         (2, ‘普通本科‘),
 95         (3, ‘独立院校‘),
 96         (4, ‘民办本科‘),
 97         (5, ‘大专‘),
 98         (6, ‘民办专科‘),
 99         (7, ‘高中‘),
100         (8, ‘其他‘)
101     )
102     education = models.IntegerField(verbose_name=‘学历‘, choices=education_choices, blank=True, null=True, )
103     graduation_school = models.CharField(verbose_name=‘毕业学校‘, max_length=64, blank=True, null=True)
104     major = models.CharField(verbose_name=‘所学专业‘, max_length=64, blank=True, null=True)
105 
106     experience_choices = [
107         (1, ‘在校生‘),
108         (2, ‘应届毕业‘),
109         (3, ‘半年以内‘),
110         (4, ‘半年至一年‘),
111         (5, ‘一年至三年‘),
112         (6, ‘三年至五年‘),
113         (7, ‘五年以上‘),
114     ]
115     experience = models.IntegerField(verbose_name=‘工作经验‘, blank=True, null=True, choices=experience_choices)
116     work_status_choices = [
117         (1, ‘在职‘),
118         (2, ‘无业‘)
119     ]
120     work_status = models.IntegerField(verbose_name="职业状态", choices=work_status_choices, default=1, blank=True,
121                                       null=True)
122     company = models.CharField(verbose_name="目前就职公司", max_length=64, blank=True, null=True)
123     salary = models.CharField(verbose_name="当前薪资", max_length=64, blank=True, null=True)
124 
125     source_choices = [
126         (1, "qq群"),
127         (2, "内部转介绍"),
128         (3, "官方网站"),
129         (4, "百度推广"),
130         (5, "360推广"),
131         (6, "搜狗推广"),
132         (7, "腾讯课堂"),
133         (8, "广点通"),
134         (9, "高校宣讲"),
135         (10, "渠道代理"),
136         (11, "51cto"),
137         (12, "智汇推"),
138         (13, "网盟"),
139         (14, "DSP"),
140         (15, "SEO"),
141         (16, "其它"),
142     ]
143     source = models.SmallIntegerField(‘客户来源‘, choices=source_choices, default=1)
144     referral_from = models.ForeignKey(
145         ‘self‘,
146         blank=True,
147         null=True,
148         verbose_name="转介绍自学员",
149         help_text="若此客户是转介绍自内部学员,请在此处选择内部学员姓名",
150         related_name="internal_referral"
151     )
152     course = models.ManyToManyField(verbose_name="咨询课程", to="Course")
153 
154     status_choices = [
155         (1, "已报名"),
156         (2, "未报名")
157     ]
158     status = models.IntegerField(
159         verbose_name="状态",
160         choices=status_choices,
161         default=2,
162         help_text=u"选择客户此时的状态"
163     )
164     consultant = models.ForeignKey(verbose_name="课程顾问", to=‘UserInfo‘, related_name=‘consultant‘,limit_choices_to={‘depart_id‘:1005})
165     date = models.DateField(verbose_name="咨询日期", auto_now_add=True)
166 
167     recv_date = models.DateField(verbose_name=‘接单时间‘,null=True,blank=True)
168 
169     last_consult_date = models.DateField(verbose_name="最后跟进日期", auto_now_add=True)
170 
171     def __str__(self):
172         return "姓名:{0},QQ:{1}".format(self.name, self.qq, )
173 
174 
175 class CustomerDistribution(models.Model):
176     """客户分配表"""
177     user = models.ForeignKey(verbose_name="当前客户顾问",to=‘UserInfo‘,limit_choices_to={‘depart_id‘:1005},related_name="cds",null=True,blank=True)
178     customer = models.ForeignKey(verbose_name="客户",to="Customer",related_name="dealers",null=True,blank=True)
179     ctime = models.DateField(auto_now_add=True,null=True,blank=True)
180     status_choices = (
181         (1,‘正在跟进‘),
182         (2,‘已成单‘),
183         (3,‘三天未跟进‘),
184         (4,‘十五天未成单‘),
185     )
186     status = models.IntegerField(verbose_name="状态",choices=status_choices,default=1)
187     memo = models.CharField(verbose_name="更多信息",max_length=255,null=True,blank=True)
188 
189 
190 class SaleRank(models.Model):
191     """销售权重与分配"""
192     user = models.ForeignKey(to="UserInfo",verbose_name=‘课程顾问‘,limit_choices_to={‘depart‘:1005})
193     num = models.IntegerField(verbose_name=‘数量‘)
194     weight = models.IntegerField(verbose_name=‘权重‘)
195     def __str__(self):
196         return ‘权重:{0}??;num:{1}‘.format(self.weight,self.num)
197 
198 
199 class ConsultRecord(models.Model):
200     """
201     客户跟进记录
202     """
203     customer = models.ForeignKey(verbose_name="所咨询客户", to=‘Customer‘)
204     consultant = models.ForeignKey(verbose_name="跟踪人", to=‘UserInfo‘,limit_choices_to={‘depart_id‘:1005})
205     date = models.DateField(verbose_name="跟进日期", auto_now_add=True)
206     note = models.TextField(verbose_name="跟进内容...")
207 
208 
209 class PaymentRecord(models.Model):
210     """
211     缴费记录
212     """
213     customer = models.ForeignKey(Customer, verbose_name="客户")
214 
215     class_list = models.ForeignKey(verbose_name="班级", to="ClassList", blank=True, null=True)
216 
217     pay_type_choices = [
218         (1, "订金/报名费"),
219         (2, "学费"),
220         (3, "转班"),
221         (4, "退学"),
222         (5, "退款"),
223     ]
224     pay_type = models.IntegerField(verbose_name="费用类型", choices=pay_type_choices, default=1)
225     paid_fee = models.IntegerField(verbose_name="费用数额", default=0)
226     turnover = models.IntegerField(verbose_name="成交金额", blank=True, null=True)
227     quote = models.IntegerField(verbose_name="报价金额", blank=True, null=True)
228     note = models.TextField(verbose_name="备注", blank=True, null=True)
229     date = models.DateTimeField(verbose_name="交款日期", auto_now_add=True)
230     consultant = models.ForeignKey(verbose_name="负责老师", to=‘UserInfo‘, help_text="谁签的单就选谁")
231 
232 
233 class Student(models.Model):
234     """
235     学生表（已报名）
236     """
237     customer = models.OneToOneField(verbose_name=‘客户信息‘, to=‘Customer‘)
238 
239     username = models.CharField(verbose_name=‘用户名‘, max_length=32)
240     password = models.CharField(verbose_name=‘密码‘, max_length=64)
241     emergency_contract = models.CharField(max_length=32, blank=True, null=True, verbose_name=‘紧急联系人‘)
242     class_list = models.ManyToManyField(verbose_name="已报班级", to=‘ClassList‘, blank=True)
243 
244     company = models.CharField(verbose_name=‘公司‘, max_length=128, blank=True, null=True)
245     location = models.CharField(max_length=64, verbose_name=‘所在区域‘, blank=True, null=True)
246     position = models.CharField(verbose_name=‘岗位‘, max_length=64, blank=True, null=True)
247     salary = models.IntegerField(verbose_name=‘薪资‘, blank=True, null=True)
248     welfare = models.CharField(verbose_name=‘福利‘, max_length=256, blank=True, null=True)
249     date = models.DateField(verbose_name=‘入职时间‘, help_text=‘格式yyyy-mm-dd‘, blank=True, null=True)
250     memo = models.CharField(verbose_name=‘备注‘, max_length=256, blank=True, null=True)
251 
252     def __str__(self):
253         return self.username
254 
255 
256 class CourseRecord(models.Model):
257     """
258     上课记录表
259     """
260     class_obj = models.ForeignKey(verbose_name="班级", to="ClassList")
261     day_num = models.IntegerField(verbose_name="节次", help_text=u"此处填写第几节课或第几天课程...,必须为数字")
262     teacher = models.ForeignKey(verbose_name="讲师", to=‘UserInfo‘,limit_choices_to={‘depart_id__in‘:[1003,1004]})
263     date = models.DateField(verbose_name="上课日期", auto_now_add=True)
264 
265     course_title = models.CharField(verbose_name=‘本节课程标题‘, max_length=64, blank=True, null=True)
266     course_memo = models.TextField(verbose_name=‘本节课程内容概要‘, blank=True, null=True)
267     has_homework = models.BooleanField(default=True, verbose_name="本节有作业")
268     homework_title = models.CharField(verbose_name=‘本节作业标题‘, max_length=64, blank=True, null=True)
269     homework_memo = models.TextField(verbose_name=‘作业描述‘, max_length=500, blank=True, null=True)
270     exam = models.TextField(verbose_name=‘踩分点‘, max_length=300, blank=True, null=True)
271 
272     def __str__(self):
273         return "{0} day{1}".format(self.class_obj, self.day_num)
274 
275 
276 class StudyRecord(models.Model):
277     course_record = models.ForeignKey(verbose_name="第几天课程", to="CourseRecord")
278     student = models.ForeignKey(verbose_name="学员", to=‘Student‘)
279     record_choices = ((‘checked‘, "已签到"),
280                       (‘vacate‘, "请假"),
281                       (‘late‘, "迟到"),
282                       (‘noshow‘, "缺勤"),
283                       (‘leave_early‘, "早退"),
284                       )
285     record = models.CharField("上课纪录", choices=record_choices, default="checked", max_length=64)
286     score_choices = ((100, ‘A+‘),
287                      (90, ‘A‘),
288                      (85, ‘B+‘),
289                      (80, ‘B‘),
290                      (70, ‘B-‘),
291                      (60, ‘C+‘),
292                      (50, ‘C‘),
293                      (40, ‘C-‘),
294                      (0, ‘ D‘),
295                      (-1, ‘N/A‘),
296                      (-100, ‘COPY‘),
297                      (-1000, ‘FAIL‘),
298                      )
299     score = models.IntegerField("本节成绩", choices=score_choices, default=-1)
300     homework_note = models.CharField(verbose_name=‘作业评语‘, max_length=255, blank=True, null=True)
301     note = models.CharField(verbose_name="备注", max_length=255, blank=True, null=True)
302 
303     homework = models.FileField(verbose_name=‘作业文件‘, blank=True, null=True, default=None)
304     stu_memo = models.TextField(verbose_name=‘学员备注‘, blank=True, null=True)
305     date = models.DateTimeField(verbose_name=‘提交作业日期‘, auto_now_add=True)
306 
307     def __str__(self):
308         return "{0}-{1}".format(self.course_record, self.student)

 1 import redis
 2 from app01 import models
 3 from oomph_2.settings import SALE_ID_LIST, SALE_ID_LIST_ORIGIN, SALE_ID_RESET
 4 
 5 POOL = redis.ConnectionPool(host=‘192.168.20.150‘,port=6379)
 6 # host是服务端的，这个port是redis固定的，只要是连接redis的这个port就固定是6379，密码是服务端设置的。
 7 CONN = redis.Redis(connection_pool=POOL)
 8 
 9 
10 class AutoSale(object):
11 
12     @classmethod
13     def fetch_users(cls):
14         # [obj(销售顾问id,num),obj(销售顾问id,num),obj(销售顾问id,num),obj(销售顾问id,num),]
15         sales = models.SaleRank.objects.all().order_by(‘-weight‘)
16         print(sales)
17         sale_id_list = []
18         count = 0
19         while True:
20             flag = False
21             for row in sales:
22                 if count < row.num:
23                     sale_id_list.append(row.user_id)
24                     flag = True
25             count += 1
26             if not flag:
27                 break
28         print(‘SALE_ID_LIST===‘,sale_id_list)
29         if sale_id_list:
30             CONN.rpush(SALE_ID_LIST,*sale_id_list)        # 用来操作的数据
31             CONN.rpush(SALE_ID_LIST_ORIGIN,*sale_id_list) # 保留一份源数据
32             return True
33         return False
34 
35 
36     @classmethod
37     def get_sale_id(cls):
38         # 查看原来数据是否存在
39         
40         sale_id_origin_count = CONN.llen(SALE_ID_LIST_ORIGIN)
41         if not sale_id_origin_count:
42             # 取数据库中获取数据，并且赋值list_origin,pop数据
43             status = cls.fetch_users()
44             if not status:
45                 return None
46             user_id = CONN.lpop(SALE_ID_LIST)
47             if user_id:
48                 return user_id
49 
50             reset = CONN.get(SALE_ID_RESET)
51             if reset:
52                 CONN.delete(SALE_ID_LIST_ORIGIN)
53                 status = cls.fetch_users()
54                 if not status:
55                     return None
56                 CONN.delete(SALE_ID_RESET)
57                 return CONN.lpop(SALE_ID_LIST)
58             else:
59                 ct = CONN.llen(SALE_ID_LIST_ORIGIN)
60                 for i in range(ct):
61                     v = CONN.lindex(SALE_ID_LIST_ORIGIN,i)
62                     CONN.rpush(SALE_ID_LIST,v)
63                 return CONN.lpop(‘sale_list_id‘)
64         # if cls.rollback_list:
65         #     """
66         #     可能存在已经取到了销售,也分配了,可是在写进数据库的过程中出现了问题,
67         #     在customer.py里面,我们使用了事务,虽然事务回滚了,可是因为我们使用的是生成器,所以自己写了rollback方法
68         #     """
69         #     return cls.rollback_list.pop()
70         #
71         # if not cls.users:
72         #     cls.fetch_users()
73         # # 如果没有课程顾问,就返回None
74         # if not cls.users:
75         #     return None
76         #
77         # if not cls.iter_users:
78         #     cls.iter_users = iter(cls.users)
79         # try:
80         #     user_id = next(cls.iter_users)
81         # except StopIteration as e:
82         #     if cls.reset_status:
83         #         cls.fetch_users()
84         #         cls.reset_status = False
85         #     cls.iter_users = iter(cls.users)
86         #     user_id = cls.get_sale_id()
87         # return user_id
88     @classmethod
89     def reset(cls):
90         CONN.set(SALE_ID_RESET,1)
91 
92     @classmethod
93     def rollback(cls,nid):
94         # cls.rollback_list.insert(0,nid)
95         CONN.lpush(SALE_ID_LIST,nid)   # callback的id，往前面放

import json,datetime
from django.conf.urls import url
from django.db.models import Q
from django.http import StreamingHttpResponse
from django.urls import reverse
from django.utils.safestring import mark_safe
from django.shortcuts import render,HttpResponse,redirect
from django.forms import ModelForm
from app01 import models
from cccccccccccccc import AutoSale
from stark.service import v1
from utils import message
from django.db import transaction
from app01.stark import BasePermission

class SingleModelForm(ModelForm):
    class Meta:
        model = models.Customer
        exclude = [‘consultant‘,‘status‘,‘recv_date‘,‘last_consult_date‘]


class CustomerConfig(BasePermission,v1.StarkConfig):
    order_by = [‘-status‘]

    def display_gender(self,obj=None,is_header=None):
        if is_header:
            return ‘性别‘
        return obj.get_gender_display()

    def display_education(self,obj=None,is_header=None):
        if is_header:
            return ‘学历‘
        return obj.get_education_display()

    def display_source(self,obj=None,is_header=None):
        if is_header:
            return ‘客户来源‘
        return obj.get_source_display()

    def display_course(self,obj=None,is_header=None):
        if is_header:
            return ‘咨询课程‘
        html = []
        obj_list = obj.course.all()
        for obj1 in obj_list:
            temp = "<a style=‘display:inline-block;padding:3px 5px;border:2px solid red;margin:2px;‘ href=‘/stark/app01/customer/%s/%s/dc/‘>%s <span class=‘glyphicon glyphicon-trash‘></span></a>" %(obj.pk,obj1.pk,obj1.name)
            html.append(temp)
        return mark_safe(‘‘.join(html))

    def display_status(self,obj=None,is_header=None):
        """
        客户状态是可以点击修改的
        :param obj:
        :param is_header:
        :return:
        """
        if is_header:
            return ‘客户状态‘
        # print(‘obj......‘,obj)   姓名:yy,QQ:123456
        return obj.get_status_display()

    def record(self,obj=None,is_header=None):
        """客户跟进记录,
           http://127.0.0.1:8000/stark/app01/consultrecord/?customer=1
        """
        if is_header:
            return ‘客户跟进记录‘
        return mark_safe("<a href=‘/stark/app01/consultrecord/?customer=%s‘>查看跟进记录</a>"%(obj.pk))

    list_display = [‘name‘,‘referral_from‘,display_gender,display_education,display_source,display_course,display_status,record]
    edit_link = [‘name‘]

    def delete_course(self,request,customer_id,course_id):
        """
        删除当前用户感兴趣的课程
        :param request:
        :param customer_id:
        :param course_id:
        :return:
        """
        # print(‘self.model_class=,=‘,self.model_class.objects.all())
        # < QuerySet[ < Customer: 姓名:骚伟, QQ: 123456 >] >
        customer_obj = self.model_class.objects.filter(pk=customer_id).first()
        # 在多对多字段中可以remove,
        customer_obj.course.remove(course_id)
        # ####################作业:  删除完成跳转回来的时候,带着走的时候的url
        # self.request.GET
        # self._query_param_key
        # 构造QueryDict
        # urlencode()
        return redirect(self.get_list_url())

    def extra_url(self):
        app_model_name = (self.model_class._meta.app_label,self.model_class._meta.model_name,)
        patterns = [
            url(r‘^(\d+)/(\d+)/dc/$‘, self.wrap(self.delete_course), name="%s_%s_dc" %app_model_name),
            url(r‘^public/$‘, self.wrap(self.public_view), name="%s_%s_public" %app_model_name),
            url(r‘^user/$‘, self.wrap(self.user_view), name="%s_%s_user" %app_model_name),
            url(r‘^(\d+)/competition/$‘, self.wrap(self.competition_view),name = "%s_%s_competition" % app_model_name),
            url(r‘^single/$‘, self.wrap(self.single_view), name="%s_%s_single" % app_model_name),
            url(r‘^multi/$‘, self.wrap(self.multi_view), name="%s_%s_multi" % app_model_name),
            # url(r‘^loadfiles/$‘, self.wrap(self.get_loadfiles_view), name="%s_%s_loadfiles" % app_model_name),
        ]
        return patterns

    def public_view(self,request):
        """
        公共客户资源, 未报名 & (15天未接单 or 三天未跟进)
        """

        current_user_id = 9

        # 当前日期
        current_date = datetime.datetime.now().date()
        # 最后接单时间
        no_deal = current_date - datetime.timedelta(days=15)
        # 最后跟进日期
        no_follow_date = current_date - datetime.timedelta(days=3)

        """公共客户"""
        # 方法一:
        # customer_list = models.Customer.objects.filter(Q(recv_date__lt=no_deal)|Q(last_consult_date__lt=no_follow),status=2)
        # customer_list = models.Customer.objects.filter(Q(recv_date__lt=no_deal)|Q(last_consult_date__lt=no_follow_date),status=2)
        # print(‘9999999999‘,customer_list)
        # 方法二:
        con = Q()
        q1 = Q(status=2)
        q2 = Q()
        q2.connector = ‘OR‘
        q2.children.append((‘recv_date__lt‘, no_deal))
        q2.children.append((‘last_consult_date__lt‘, no_follow_date))
        con.add(q1,‘AND‘)
        con.add(q2,‘AND‘)
        customer_list = models.Customer.objects.filter(con)

        return render(request, ‘public_view.html‘, {‘customer_list‘:customer_list, "current_user_id":current_user_id})

    def competition_view(self,request,cid):
        """
        抢单表
        :param request:
        :param cid: customer_id 来自于公共资源里面的抢单选项,public_view
        :return:
        """
        current_user_id = 9 # 这个是从session中拿的
        """抢单之后,它会修改客户表里面的: recv_date & last_consult_date & 课程顾问
            可以抢单的前提条件是: 之前的顾问不是自己,状态必须是未报名,并且满足3/15的要求"""
        current_date = datetime.datetime.now().date()
        no_deal = current_date - datetime.timedelta(days=15) # 最后接单日期
        no_follow_date = current_date - datetime.timedelta(days=3) # 最后跟进日期
        # 更新数据
        row_count = models.Customer.objects.filter(Q(recv_date__lt=no_deal) | Q(last_consult_date__lt=no_follow_date),status=2,id=cid).exclude(consultant_id=current_user_id).update(recv_date=current_date,last_consult_date=current_date,consultant_id=current_user_id)
        if not row_count:
            return HttpResponse(‘配嘛...‘)
        # 如果存在的话,我们就把它添加到客户分配表CustomerDistribution里面
        models.CustomerDistribution.objects.create(ctime=current_date,customer_id=cid,user_id=current_user_id)
        return HttpResponse(‘嗯嗯,归你归你‘)

    def user_view(self,request):
        """当前登录用户的所有的客户(在我这成单的,以及我正在跟进的)"""
        current_user_id = 9
        customer_list = models.CustomerDistribution.objects.filter(user_id=current_user_id).order_by(‘status‘)
        return render(request, ‘user_view.html‘, {‘customer_list‘:customer_list})

    def single_view(self,request):
        """单条录入客户信息"""
        if request.method == ‘GET‘:
            form = SingleModelForm()
            return render(request, ‘single_view.html‘, {‘form‘:form})
        else:
            current_date = datetime.datetime.now().date()
            form = SingleModelForm(request.POST)
            if form.is_valid():
                print(form.cleaned_data)
                sale_id = AutoSale.get_sale_id()
                if not sale_id:
                    return HttpResponse(‘暂无课程顾问,请添加后再分配‘)
                try:
                    with transaction.atomic():
                        # 客户表保存
                        form.instance.consultant_id = sale_id
                        form.instance.recv_date = current_date
                        form.instance.last_consult_date = current_date
                        new_customer = form.save()  #  将数据添加到客户表。这就算创建完成了
                        # 将关系添加到客户分配表
                        models.CustomerDistribution.objects.create(customer=new_customer,ctime=current_date,user_id=sale_id)
                        # 发送邮件信息
                        # message.send_message(‘17701335022@163.com‘,‘saofei‘,‘fk‘,‘fk you‘)
                except Exception as e:
                    # 创建客户和分配销售异常
                    AutoSale.rollback(sale_id)
                    return HttpResponse(‘录入异常‘)
                return  HttpResponse(‘录入成功‘)
            else:
                return render(request, ‘single_view.html‘, {‘form‘:form})

    def multi_view(self,request):
        """批量导入"""
        if request.method == ‘GET‘:
            return render(request, ‘multi_view.html‘)
        else:
            from django.core.files.uploadedfile import InMemoryUploadedFile
            file_obj = request.FILES.get(‘exfile‘)
            # 老方法： 对应218
            # print(file_obj,type(file_obj))
            # with open(‘submit.xlsx‘,‘wb‘) as f :
            #     for chunk in file_obj:
            #         f.write(chunk)
            import xlrd
            # 不再创建xlsx文件
            workbook = xlrd.open_workbook(file_contents=file_obj.read())
            # 老方法： 先写再读
            # workbook = xlrd.open_workbook(‘submit.xlsx‘)
            sheet = workbook.sheet_by_index(0) # 这个当前sheet索引为0的 表单页
            # print(sheet.nrows) # 当前共有多少行
            maps = {
                0 : ‘name‘,
                1 : ‘qq‘,
            }
            row_dict = {}
            for index in range(1,sheet.nrows): # 第一行是标题，从索引为1的开始拿数据
                row = sheet.row(index)
                # [text: ‘zz‘, number: 1123.0]
                # [text: ‘aa‘, number: 23.0]
                # 拿到的是列表，可是我们要转化成字典
                # {text: ‘zz‘, number: 1123.0}
                for i in range(len(maps)):
                    key = maps[i]
                    cell = row[i]
                    row_dict[key] = cell.value
                print(row_dict)

                # 获取客户id，录入客户表，录入分配表
                current_date = datetime.datetime.now().date()
                sale_id = AutoSale.get_sale_id()
                print(‘236‘,sale_id)
                if not sale_id:
                    return HttpResponse(‘暂无课程顾问，请添加后再执行操作！‘)
                try:
                    with transaction.atomic():
                        # 客户表保存
                        new_customer = models.Customer.objects.create(**row_dict,consultant_id=sale_id,recv_date=current_date,last_consult_date=current_date)
                        print(new_customer)
                        # 将关系添加到客户分配表
                        models.CustomerDistribution.objects.create(customer=new_customer,ctime=current_date,user_id=sale_id)
                        # 发送邮件信息
                        # message.send_message(‘17701335022@163.com‘,‘saofei‘,‘fk‘,‘fk you‘)
                        print(new_customer)
                except Exception as e:
                    # 创建客户和分配销售异常
                    AutoSale.rollback(sale_id)
                    return HttpResponse(‘录入异常‘)
                return  HttpResponse(‘录入成功‘)
            else:
                return render(request, ‘multi_view.html‘)

    # # 为用户提供模版
    # def download_file(request):
    #     # do something
    #
    #     the_file_name=‘11.png‘             #显示在弹出对话框中的默认的下载文件名
    #     filename=‘media/uploads/11.png‘    #要下载的文件路径
    #     response=StreamingHttpResponse(readFile(filename))
    #     response[‘Content-Type‘]=‘application/octet-stream‘
    #     response[‘Content-Disposition‘]=‘attachment;filename="{0}"‘.format(the_file_name)
    #     return response
    # def readFile(filename,chunk_size=512):
    #     with open(filename,‘rb‘) as f:
    #         while True:
    #             c=f.read(chunk_size)
    #             if c:
    #                 yield c
    #             else:
    #                 break

v1.site.register(models.Customer,CustomerConfig)

 1 {% load staticfiles %}
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>Title</title>
 7 </head>
 8 <body>
 9 
10 <h2>所在班级</h2>
11 <ul class="fa-list-ul" id="classList" sid="{{ obj.sid }}">
12     {% for obj in class_list %}
13         <li cid="{{ obj.id }}">{{ obj.course.name }}({{ obj.semester }}期)</li>
14     {% endfor %}
15 </ul>
16 <h2>成绩图</h2>
17 <div id="container" style="width:600px;height:400px"></div>
18 
19 <script src="{% static ‘/stark/bootstrap/js/jquery-3.1.1.js‘ %}"></script>
20 <script src="{% static ‘highcharts.js‘ %}"></script>
21 <script>
22 $(function () {
23     $(‘#classList li‘).click(function () {
24         var cid = $(this).attr(‘cid‘);
25         var sid = $(‘#classList‘).attr(‘sid‘);
26         $.ajax({
27             url :‘ /stark/app01/student/chart‘,
28             type : ‘get‘,
29             data : {‘cid‘:cid,‘sid‘:sid},
30             dataType : ‘JSON‘,
31             success:function (arg) {
32                         var config = {
33                             chart: {
34                                 type: ‘column‘
35                             },
36                             title: {
37                                 text: ‘学生成绩‘
38                             },
39                             subtitle: {
40                                 text: ‘数据截止 2017-03，来源: <a href="https://en.wikipedia.org/wiki/List_of_cities_proper_by_population">Wikipedia</a>‘
41                             },
42                             xAxis: {
43                                 type: ‘category‘,
44                                 labels: {
45                                     rotation: -45,
46                                     style: {
47                                         fontSize: ‘13px‘,
48                                         fontFamily: ‘Verdana, sans-serif‘
49                                     }
50                                 }
51                             },
52                             yAxis: {
53                                 min: 0,
54                                 title: {
55                                     text: ‘分数‘
56                                 }
57                             },
58                             legend: {
59                                 enabled: false
60                             },
61                             tooltip: {
62                                 pointFormat: ‘成绩: <b>{point.y} </b>‘
63                             },
64                             series: [{
65                                 name: ‘成绩‘,
66                                 data: [],
67                                 dataLabels: {
68                                     enabled: true,
69                                     rotation: -90,
70                                     color: ‘#FFFFFF‘,
71                                     align: ‘right‘,
72                                     format: ‘{point.y}‘, // one decimal
73                                     y: 10, // 10 pixels down from the top
74                                     style: {
75                                         fontSize: ‘13px‘,
76                                         fontFamily: ‘Verdana, sans-serif‘
77                                     }
78                                 }
79                             }]
80                         };
81 
82                         config.series[0].data =arg.data;
83 
84                         //$(‘#container‘).highcharts(config);
85                         Highcharts.chart(‘container‘,config);
86 
87                     }
88                 })
89             })
90         })
91 
92 
93 </script>
94 </body>
95 </html>

 1     def mutil_init(self,request):
 2         """自定义批量初始化方法"""
 3         # 上课记录id列表
 4         pk_list = request.POST.getlist(‘pk‘)
 5         # 上课记录对象列表
 6         record_list = models.CourseRecord.objects.filter(id__in=pk_list)
 7         # print(record_list)
 8         # # 这种是，遍历每一个学生，查看是否存在记录。
 9         # for record in record_list:
10         #     student_list = models.Student.objects.filter(class_list=record.class_obj)
11         #     bulk_list = []
12         #     for student in student_list:
13         #         exists = models.StudyRecord.objects.filter(student=student,course_record=record).exists()
14         #         if exists:
15         #             continue
16         #         bulk_list.append(models.StudyRecord(student=student,course_record=record))
17         #     models.StudyRecord.objects.bulk_create(bulk_list)
18 
19         # 下面这种是，只要有当天的学习记录，后面不管还有没有学生来，都不能添加
20         for record in record_list:
21             if models.StudyRecord.objects.filter(course_record=record).exists():
22                 continue
23             student_list = models.Student.objects.filter(class_list=record.class_obj)
24             # 为每一个学生创建dayn的学习记录
25             bulk_list = []
26             for student in student_list:
27                 bulk_list.append(models.StudyRecord(student=student,course_record=record))
28             models.StudyRecord.objects.bulk_create(bulk_list)
29         # return redirect(‘/stark/app01/courserecord/‘)
30         return HttpResponse(‘初始化成功！‘)
31 
32     show_actions = True
33     mutil_init.short_desc = "学生初始化"
34     actions = [mutil_init,] # 因为这个是批量操作,咱们需要写点方法,里面是我们要实现的东西,所以函数

 1     def score_list(self,request,record_id):
 2         """
 3         录入成绩页面
 4         :param request:
 5         :param record_id: 老师上课记录ID
 6         :return:
 7         """
 8         if request.method == ‘GET‘:
 9             from django.forms import Form
10             from django.forms import fields
11             from django.forms import widgets
12             ##方式一
13             # study_record_list = models.StudyRecord.objects.filter(course_record_id=record_id)  #这一天上课的所有的学生的学习记录
14             # score_choices = models.StudyRecord.score_choices
15             # return render(request,"score_list.html",{"study_record_list":study_record_list,"score_choices":score_choices})
16 
17             # 改款
18             # class TestForm(Form):
19             #     score = fields.ChoiceField(choices=models.StudyRecord.record_choices)
20             #     homeword_note = fields.CharField(widget=widgets.Textarea())
21 
22             # 因为前端要拿到id和对象，所以使用type来创建，来自定义字段
23             study_record_list = models.StudyRecord.objects.filter(course_record_id=record_id)
24             data = []
25             for obj in study_record_list:
26                 TestForm = type(‘TempForm‘,(Form,),{
27                     ‘score_%s‘%obj.pk : fields.ChoiceField(choices=models.StudyRecord.score_choices),
28                     ‘homework_note_%s‘%obj.pk : fields.CharField(widget=widgets.Textarea())
29                 })
30                 data.append({‘obj‘:obj,‘form‘:TestForm(initial={‘score_%s‘ %obj.pk:obj.score,‘homework_note_%s‘ %obj.pk:obj.homework_note})})
31             return render(request,‘score_list.html‘,{‘data‘:data})
32         else:
33             data_dict = {}
34             """
35             构造这样的字典，目的是保存更新数据库里面的数据，字典的结构的
36             {
37                 3:{"score":2,"homework_note":2}
38                 4:{"score":4,"homework_note":4}
39             }
40             """
41             for key, value in request.POST.items():
42                 if key == "csrfmiddlewaretoken":
43                     continue
44                 name, nid = key.rsplit(‘_‘, 1)
45                 if nid in data_dict:
46                     data_dict[nid][name] = value
47                 else:
48                     data_dict[nid] = {name: value}
49 
50             for nid, update_dict in data_dict.items():
51                 print(data_dict.items())
52                 models.StudyRecord.objects.filter(id=nid).update(**update_dict)
53 
54             return redirect(request.path_info)

 1 {% load staticfiles %}
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>成绩录入</title>
 7     <link rel="stylesheet" href="{% static ‘stark/bootstrap/css/bootstrap.css‘ %}">
 8 </head>
 9 <body>
10 <h2>自定义成绩录入</h2>
11 <form method="post">
12     {% csrf_token %}
13     <table class="table">
14         {% for row in data %}
15             <tr>
16             <td>{{ row.obj.course_record }}</td>
17             <td>{{ row.obj.student }}</td>
18             <td>{{ row.obj.get_record_display }}</td>
19             {% for field in row.form %}
20                 <td>{{ field }}</td>
21             {% endfor %}
22             </tr>
23         {% endfor %}
24 
25     </table>
26     <input type="submit" value="保存">
27 </form>
28 
29 </body>
30 </html>

 1 from django.db import models
 2 
 3 
 4 class UserInfo(models.Model):
 5     """
 6     用户表
 7     """
 8     user = models.CharField(max_length=32,unique=True)
 9     pwd = models.CharField(max_length=64)
10 
11 
12 class Room(models.Model):
13     """
14     会议室表
15     """
16     caption = models.CharField(max_length=32)
17     num = models.IntegerField()
18 
19 
20 class Book(models.Model):
21     """
22     会议室预定信息
23     """
24     user = models.ForeignKey(‘UserInfo‘)
25     room = models.ForeignKey(‘Room‘)
26     date = models.DateField()
27     time_choices = (
28         (1, ‘8:00‘),
29         (2, ‘9:00‘),
30         (3, ‘10:00‘),
31         (4, ‘11:00‘),
32         (5, ‘12:00‘),
33         (6, ‘13:00‘),
34         (7, ‘14:00‘),
35         (8, ‘15:00‘),
36         (9, ‘16:00‘),
37         (10, ‘17:00‘),
38         (11, ‘18:00‘),
39         (12, ‘19:00‘),
40         (13, ‘20:00‘),
41     )
42     time_id = models.IntegerField(choices=time_choices)
43 
44     class Meta:
45         unique_together = (
46             (‘room‘,‘date‘,‘time_id‘),
47         )