def action_multi_init(self, request, *args, **kwargs):
course_record_id_list = request.POST.getlist('pk')
class_id = kwargs.get('class_id')
class_object = models.ClassList.objects.filter(id=class_id).first()
if not class_object:
return HttpResponse('班级不存在')
student_object_list = class_object.student_set.all()
for course_record_id in course_record_id_list:
# 判断上课记录是否合法
course_record_object = models.CourseRecord.objects.filter(
id=course_record_id, class_object_id=class_id).first()
if not course_record_object:
continue
# 判断此上课记录的考勤记录是否已经存在
study_record_exists = models.StudyRecord.objects.filter(
course_record=course_record_object).exists()
if study_record_exists:
continue
# 为每个学生在该天创建考勤记录
study_record_object_list = [
models.StudyRecord(student_id=stu.id,
course_record_id=course_record_id)
for stu in student_object_list
]
models.StudyRecord.objects.bulk_create(study_record_object_list,
batch_size=50)
def multi_init(self, request):
"""
自定义执行批量初始化方法
:param request:
:return:
"""
# 上课记录ID列表
pk_list = request.POST.getlist('pk')
# 上课记录对象
record_list = models.CourseRecord.objects.filter(id__in=pk_list)
for record in record_list:
# day1,day2,day3
# record.class_obj # 关联的班级
exists = models.StudyRecord.objects.filter(
course_record=record).exists()
if exists:
continue
student_list = models.Student.objects.filter(
class_list=record.class_obj)
bulk_list = []
for student in student_list:
# 为每一个学生创建dayn的学习记录
bulk_list.append(
models.StudyRecord(student=student, course_record=record))
models.StudyRecord.objects.bulk_create(bulk_list)
def multi_init(self):
# 批量初始化学习记录
course_record_ids = self.request.POST.get('ids', [])
for course_record_id in course_record_ids:
# 根据一个课程ID生成学习记录
course_record_obj = models.CourseRecord.objects.filter(
pk=course_record_id).first()
# 找当前班级的所有学生
students = course_record_obj.re_class.customer_set.filter(
status='studying')
# for student in students:
# models.StudyRecord.objects.get_or_create(student=student,course_record_id=course_record_id)
# models.StudyRecord.objects.update_or_create(student=student,course_record_id=course_record_id)
# 批量插入
study_record_list = []
for student in students:
if not models.StudyRecord.objects.filter(
student=student,
course_record_id=course_record_id).exists():
study_record_list.append(
models.StudyRecord(student=student,
course_record_id=course_record_id))
models.StudyRecord.objects.bulk_create(study_record_list)
def initCourseRecord(self, request, queryset):
print("初始化上课记录")
print(queryset[0].from_class.enrollment_set.all())
bulk_objs = []
for enroll_obj in queryset[0].from_class.enrollment_set.all():
# models.StudyRecord.objects.get_or_create(
# student=enroll_obj,
# course_record=queryset[0],
# attendence=0,
# score=0,
# )
bulk_objs.append(
models.StudyRecord(
student=enroll_obj,
course_record=queryset[0],
attendence=0,
score=0,
))
try:
models.StudyRecord.objects.bulk_create(bulk_objs) #批量创建，要么成功，要么出错
except:
return HttpResponse("批量初始化学习记录失败，请检查该节课是否已有对应的学习记录")
return redirect("/admin/crm/studyrecord/?course_record_id__exact=%s" %
queryset[0].id)
def initialize_studyrecords(self, request, queryset):
print('--->initialize_studyrecords', self, request, queryset)
if len(queryset) > 1: #不能选多个班级
return HttpResponse("只能选择一个班级")
# print(queryset[0].from_class.enrollment_set.all())
new_obj_list = []
for enroll_obj in queryset[0].from_class.enrollment_set.all(
): #找到此课程所有报了名的学生
# models.StudyRecord.objects.get_or_create( #get_or_create（）有就获取，没有就创建
# student = enroll_obj,
# course_record = queryset[0] ,
# attendance = 0 ,
# score = 0 ,
# ) #但这样新增效率低！！
new_obj_list.append(
models.StudyRecord(
student=enroll_obj,
course_record=queryset[0], #课程记录
attendence=0, #状态，迟到还是早退
score=0, #分数
))
try:
models.StudyRecord.objects.bulk_create(new_obj_list) #批量创建（高效）
except Exception:
return HttpResponse("批量初始化学习记录失败，请检查该节课是否已经有对应的学习记录")
return redirect("/king_admin/crm/studyrecord/?course_record=%s" %
queryset[0].id)
def multi_init(self):
# 根据当前提交的课程记录Id批量初识化学生的学习记录
course_ids = self.request.POST.getlist('id')
course_obj_list = models.CourseRecord.objects.filter(id__in=course_ids)
for course_obj in course_obj_list:
# 查询当前课程记录代表的班级的学生
all_students = course_obj.re_class.customer_set.filter(
status='studying')
student_list = []
for student in all_students:
# models.StudyRecord.objects.create(course_record=course_obj, student=student)
# obj = models.StudyRecord(course_record=course_obj, student=student)
# obj.save()
student_list.append(
models.StudyRecord(course_record=course_obj,
student=student))
models.StudyRecord.objects.bulk_create(student_list)
def multi_init(self):
# 根据当前提交的课程记录ID批量初始化学生的学校记录，也就是将这个班的各个班的人都批量导入
course_ids = self.request.POST.getlist('id')
print('course_ids', course_ids)
course_obj_list = models.CourseRecord.objects.filter(id__in=course_ids)
print('multi_init')
# 循环将每个班级遍历 课程对象列表
for course_obj in course_obj_list:
# 查询当前课程记录代表的班级学生
all_students = course_obj.re_class.customer_set.filter(
status='studying')
student_list = []
for student in all_students:
# 一个一个加有两种方法(sql语句一条一条执行)
# 方法一：
# models.StudyRecord.objects.create(course_record=course_obj)
# 方法二：
# obj = models.StudyRecord(course_record=course_obj, student=student)
# obj.save()
print('student', student)
# 终极一条sql语句解决
student_list.append(
models.StudyRecord(course_record=course_obj,
student=student))
# 将列表中的值批量插入（一条sql语句)）
models.StudyRecord.objects.bulk_create(student_list)
def initialize_studyrecords(self, request, queryset): #制定功能
print()
if len(queryset) > 1:
return HttpResponse("同时只能选择一个班级！")
print(queryset[0].from_class.enrollment_set.all())
new_obj_list = [] #用于批量创建 事务
for enrll_obj in queryset[0].from_class.enrollment_set.all(): #创建学习记录
# models.StudyRecord.objects.get_or_create(
# student=enrll_obj,#对应学员
# course_record=queryset[0],
# attendance=0,#签到状态,默认签到,
# score=0,#成绩
# )
new_obj_list.append(
models.StudyRecord(
student=enrll_obj, #对应学员
course_record=queryset[0],
attendance=0, #签到状态,默认签到,
score=0, #成绩
))
try:
models.StudyRecord.objects.bulk_create(new_obj_list) #批量创建
except Exception as e:
return HttpResponse('批量创建失败,本节课可能有相应的上课记录')
return redirect("/admin/crm/studyrecord/?course_record__id__exact=%s" %
queryset[0].id) #学习记录
def init_study_record(self):
# 获取要初始化学习记录的课程ID
ids = self.request.POST.getlist('id')
# 获取要初始化学习记录的课程对象
course_obj_list = models.CourseRecord.objects.filter(id__in=ids)
for course_obj in course_obj_list:
# 查找每个课程对应的班级中的学生, 且状态为学习中
student_list = course_obj.re_class.customer_set.filter(
status='studying')
# 要生成的学习记录
study_record_list = []
for student in student_list:
# # 方案一
# models.StudyRecord.objects.create(course_record=course_obj, student=student)
# # 方案二
# study_record_obj = models.StudyRecord(course_record=course_obj, student=student)
# study_record_obj.save()
# 方案三
study_record_list.append(
models.StudyRecord(course_record=course_obj,
student=student))
# 批量生成, 这样就只执行一次sql语句, 提高效率
models.StudyRecord.objects.bulk_create(study_record_list)
def multi_init(self):
## 批量创建学习记录
# 课程记录的ID
course_record_ids = self.request.POST.getlist('pk')
# 查询出每一条课程记录对象
course_records = models.CourseRecord.objects.filter(
pk__in=course_record_ids)
for course_record in course_records:
# 通过班 去找客户, 通过学生的status状态判断 是学生还是客户.
stutends = course_record.re_class.customer_set.all().filter(
status='studying')
#
# for student in stutends:
# models.StudyRecord.objects.create(course_record=course_record,student=student)
# 批量插入
### 多次重复插入 . 就会报错 ~~ ~~~ 已解决. 添加到列标签前,查一遍
study_record_list = []
for student in stutends:
if not models.StudyRecord.objects.filter(
course_record=course_record, student=student).exists():
study_record_list.append(
models.StudyRecord(course_record=course_record,
student=student))
# bulk_create 需要一个列表 , batch_size 一次限制插入的条数
# bulk_create 空列表,也不报错
models.StudyRecord.objects.bulk_create(study_record_list,
batch_size=10)
def init_studyecord(request):
"""
批量初始化上课记录
:param request:
:return:
"""
ret={"status":False,"data":None,"error":None}
if request.method=="POST":
course_record_ids=request.POST.getlist("course_record_ids")
bulk_objs=[]
for course_record_id in course_record_ids:
course_record_obj=models.CourseRecord.objects.get(id=course_record_id)
for enroll_obj in course_record_obj.from_class.enrollment_set.all():
bulk_objs.append(models.StudyRecord(
student=enroll_obj,
course_record_id=course_record_id,
attendence=0,
score=0,
))
try:
models.StudyRecord.objects.bulk_create(bulk_objs)#批量创建，要么成功，要么出错
ret["status"]=True
ret["data"]="批量初始化学习记录成功"
except:
ret["error"]="批量初始化学习记录失败，请检查该节课是否已有对应的学习记录"
return HttpResponse(json.dumps(ret))
def initialize_studyrecords(self, request, queryset):
print('--->initialize_studyrecords', self, request, queryset)
if len(queryset) > 1:
return HttpResponse("只能选择一个班级")
print(queryset[0].from_class.enrollment_set.all())
new_obj_list = []
for enroll_obj in queryset[0].from_class.enrollment_set.all():
# models.StudyRecord.objects.get_or_create(
# student = enroll_obj,
# course_record = queryset[0] ,
# attendance = 0 ,
# score = 0 ,
# )
new_obj_list.append(
models.StudyRecord(
student=enroll_obj,
course_record=queryset[0],
attendance=0,
score=0,
))
try:
models.StudyRecord.objects.bulk_create(new_obj_list) #批量创建
except Exception as e:
return HttpResponse("批量初始化学习记录失败，请检查该节课是否已经有对应的学习记录")
return redirect("/admin/crm/studyrecord/?course_record__id__exact=%s" %
queryset[0].id)
def multi_init(self, requset):
'''
初始化学生上课记录
:param requset:
:return:
'''
pk_list = requset.POST.getlist('pk')
print(pk_list)
with transaction.atomic():
for pk in pk_list:
course_obj = models.CourseRecord.objects.filter(pk=pk).first()
studyrecord_obj = models.StudyRecord.objects.filter(
course_record=course_obj)
if not studyrecord_obj:
student_list = models.Student.objects.filter(
class_list=course_obj.class_obj.pk)
bulk_list = []
for stu in student_list:
bulk_list.append(
models.StudyRecord(course_record=course_obj,
record="checked",
student_id=stu.pk))
models.StudyRecord.objects.bulk_create(bulk_list)
else:
print("%s已经初始化了" % course_obj)
def initialize_studyrecords(self, request, queryset):
print('-------------->initialize_studyrecords', self, request,
queryset)
if len(queryset) > 1:
return HttpResponse('只能选择一个班级')
print(queryset[0].from_class.enrollment_set.all())
try:
for enroll_obj in queryset[0].from_class.enrollment_set.all():
# models.StudyRecord.objects.get_or_create(
# student= enroll_obj,
# course_record= queryset[0],
# attendance= 0,
# score= 0,
# )
new_obj_list = []
new_obj_list.append(
models.StudyRecord(
student=enroll_obj,
course_record=queryset[0],
attendance=0,
score=0,
))
models.StudyRecord.objects.bulk_create(new_obj_list) #批量创建
except Exception as e:
return HttpResponse("已有本节课记录，不能再创建，请检查学习记录表！！")
return redirect("/king_admin/crm/studyrecord/?course_record=%s" %
queryset[0].id)
def multi_init(self, request):
"""
批量初始化
:param request:
:return:
"""
id_list = request.POST.getlist('pk') # [1,2]
# 找到选中上课记录的班级
# 找到班级下所有人
# 为每个人生成一条学习记录
for nid in id_list:
record_obj = models.CourseRecord.objects.get(id=nid)
stu_list = models.Student.objects.filter(
class_list=record_obj.class_obj)
exists = models.StudyRecord.objects.filter(
course_record=record_obj).exists()
if exists:
continue
study_record_list = []
for stu in stu_list:
study_record_list.append(
models.StudyRecord(course_record=record_obj, student=stu))
models.StudyRecord.objects.bulk_create(study_record_list)
def multi_init(self):
course_record_id_list = self.request.POST.getlist('pk')
course_record = models.CourseRecord.objects.filter(pk__in=course_record_id_list)
for one_course_record in course_record:
all_student = one_course_record.re_class.customer_set.all().filter(status='studying')
study_record_list = []
for student in all_student:
study_record_list.append(models.StudyRecord(student=student, course_record=one_course_record))
models.StudyRecord.objects.bulk_create(study_record_list, batch_size=10)
def patch_studyRecord(self,request,queryset):
'''批量生产学生上课记录'''
temp = []
for courseRecord in queryset:
students = models.Student.objects.filter(class_list=courseRecord.class_obj)
for student in students:
obj = models.StudyRecord(student=student,course_record=courseRecord)
temp.append(obj)
models.StudyRecord.objects.bulk_create(temp)
def homework_detail(request,customer_id,course_record_id):
course_record_obj = models.CourseRecord.objects.get(id=course_record_id)
upload_dir = "%s%s/%s/%s" % (settings.BASE_HOMEWORK_DIR,
customer_id,
course_record_obj.course.id,
course_record_id)
# print("upload dir",upload_dir)
if not os.path.isdir(upload_dir):
os.makedirs(upload_dir, exist_ok=True)
response_dic = {'files':{}}
if request.method == "POST":
if request.FILES:
print("files:",request.FILES)
for k,file_obj in request.FILES.items():
if len(os.listdir(upload_dir)) < 6:
with open('%s/%s' %(upload_dir,file_obj.name), 'wb+') as destination:
for chunk in file_obj.chunks():
destination.write(chunk)
else:
response_dic['error'] = "can only upload no more than 5 files."
# for filename in os.listdir(upload_dir):
# abs_file = '%s/%s' %(upload_dir,filename)
# file_create_time = time.strftime("%Y-%m-%d %H:%M:%S" ,
# time.gmtime(os.path.getctime(abs_file)))
# response_dic['files'][filename] = {'size':os.path.getsize(abs_file)/1000,
# 'ctime':file_create_time}
#
get_uploaded_fileinfo(response_dic, upload_dir)
return HttpResponse(json.dumps(response_dic))
study_record_obj = models.StudyRecord.objects.filter(student_id=customer_id,course_record_id=course_record_id)
#get uploaded file dic
get_uploaded_fileinfo(response_dic, upload_dir)
if study_record_obj:
study_record_obj = study_record_obj[0]
else: #此时这个学生还没有本节课的学习记录,但需要学习记录方能交作业,所以在这里创建一条学习纪录为他
study_record_obj = models.StudyRecord(
student_id = customer_id,
course_record_id = course_record_id,
record='checked',
score = 0
)
study_record_obj.save()
return render(request,'stu/homework_detail.html',
{'study_record_obj':study_record_obj,
'course_record_obj':course_record_obj,
'uploaded_files':response_dic})
def patch_studyrecord(self, request, queryset):
#找到当前课程下的所有学生进行创建记录
temp = []
for course_record in queryset:
student_list = models.Student.objects.filter(
class_list__id=course_record.class_obj.pk)
for student in student_list:
obj = models.StudyRecord(student=student,
course_record=course_record)
temp.append(obj)
models.StudyRecord.objects.bulk_create(temp)
def study_record_init(self):
course_record_ids = self.request.POST.get(
'pk') if self.request.POST.get('pk') else []
course_record_obj_list = models.CourseRecord.objects.filter(
pk__in=course_record_ids)
for course_record_obj in course_record_obj_list:
all_students = course_record_obj.re_class.customer_set.all(
).filter(status='studying')
study_record_list = []
for student in all_students:
study_record_list.append(
models.StudyRecord(course_record=course_record_obj,
student=student))
models.StudyRecord.objects.bulk_create(study_record_list) # 批量创建数据
def multi_init(self):
"""
根据当前提交的课程id批量初始化学生的学习记录
:return:
"""
course_ids = self.request.POST.getlist('id')
course_obj_list = models.CourseRecord.objects.filter(id__in=course_ids)
for course in course_obj_list:
all_student = course.re_class.customer_set.filter(status='studying')
student_list = []
for student in all_student:
student_list.append(models.StudyRecord(course_record=course, student=student))
models.StudyRecord.objects.bulk_create(student_list)
def multi_init(self):
course_record_id = self.request.POST.get('edit_name')
course_record_objs = models.CourseRecord.objects.filter(
pk__in=course_record_id)
for course_record in course_record_objs:
stu_list = []
for stu in course_record.re_class.customer_set.filter(
status='studying'):
# models.StudyRecord.objects.create(course_record_id=course_record_id, student=stu)
# 批量插入
stu_list.append(
models.StudyRecord(course_record=course_record,
student=stu))
models.StudyRecord.objects.bulk_create(stu_list)
def mul_init(self, request):
pk_list = request.POST.getlist("pk")
record_list = models.CourseRecord.objects.filter(id__in=pk_list)
for record in record_list:
exists = models.StudyRecord.objects.filter(
course_record=record).exists()
if exists:
continue
student_list = models.Student.objects.filter(
class_list=record.class_obj)
bulk_list = []
for student in student_list:
bulk_list.append(
models.StudyRecord(student=student, course_record=record))
models.StudyRecord.objects.bulk_create(bulk_list)
def homework_detail(request, customer_id, course_record_id):
course_record_obj = models.CourseRecord.objects.get(id=course_record_id)
upload_dir = "%s%s/%s/%s" % (settings.BASE_HOMEWORK_DIR,
customer_id,
course_record_obj.course.id,
course_record_id)
# print("upload dir",upload_dir)
if not os.path.isdir(upload_dir):
os.makedirs(upload_dir, exist_ok=True)
response_dic = {'files': {}}
if request.method == "POST":
if request.FILES:
print("files:", request.FILES)
for k, file_obj in request.FILES.items():
if len(os.listdir(upload_dir)) < 6:
with open('%s/%s' % (upload_dir, file_obj.name), 'wb+') as destination:
for chunk in file_obj.chunks():
destination.write(chunk)
else:
response_dic['error'] = "can only upload no more than 5 files."
get_uploaded_fileinfo(response_dic, upload_dir)
return HttpResponse(json.dumps(response_dic))
study_record_obj = models.StudyRecord.objects.filter(student_id=customer_id, course_record_id=course_record_id)
get_uploaded_fileinfo(response_dic, upload_dir)
if study_record_obj:
study_record_obj = study_record_obj[0]
else:
study_record_obj = models.StudyRecord(
student_id=customer_id,
course_record_id=course_record_id,
record='checked',
score=0
)
study_record_obj.save()
return render(request, 'stu/homework_detail.html',
{'study_record_obj': study_record_obj,
'course_record_obj': course_record_obj,
'uploaded_files': response_dic})
def initialize_study_records(self, request, queryset):
if len(queryset) > 1:
return HttpResponse("只能选择一个班级")
new_obj_list = []
for enroll_obj in queryset[0].from_class.enrollment_set.all():
new_obj_list.append(
models.StudyRecord(student=enroll_obj,
course_record=queryset[0],
attendance=0,
score=0))
try:
models.StudyRecord.objects.bulk_create(new_obj_list)
except Exception as e:
return HttpResponse("批量初始化学习记录失败，请检查该节课是否已经有对应的学习记录！")
return redirect("/king_admin/crm/studyrecord/?course_record={}".format(
queryset[0].id))
def create_all_study_record(self,request,querySets):
if len(querySets)>1:
return HttpResponse("不能同时创建超过1个班级的上课记录")
create_obj_list = []
print("--------------",querySets[0].from_class.enrollment_set.all())
for enroll_obj in querySets[0].from_class.enrollment_set.all():
create_obj_list.append(models.StudyRecord(
student = enroll_obj,
course_record = querySets[0],
attendance = 0,
score = 0,
))
try:
models.StudyRecord.objects.bulk_create(create_obj_list)
except Exception as e:
return HttpResponse("批量初始化学习记录失败 请检查该节课是否已经有对应的学习记录")
return redirect('/king_admin/crm/StudyRecord/?course_record=%s'%(querySets[0].id))
def multi_init(self):
course_record_ids = self.request.POST.getlist('id')
course_record_obj_list = models.CourseRecord.objects.filter(
id__in=course_record_ids)
for course_record_obj in course_record_obj_list:
# 根据课程记录创建学习记录
all_students = course_record_obj.re_class.customer_set.all(
).filter(status='studying')
list1 = []
for student in all_students:
list1.append(
models.StudyRecord(course_record=course_record_obj,
student=student))
models.StudyRecord.objects.bulk_create(list1)
def initialize_studyrecords(self, request, queryset):#方式二，具有事务特性，错误则回滚数据
if len(queryset) > 1:
return HttpResponse("只能选择一个班级")
new_obj_list = []
for student_obj in queryset[0].class_grade.student_set.all():
new_obj_list.append(models.StudyRecord(
student = student_obj,
course_record = queryset[0],
))
try:
models.StudyRecord.objects.bulk_create(new_obj_list) # bulk_create:Django提供批量处理，具事务特性，错误则回滚
except Exception as e:#studyrecord设置了联合唯一，创建同样数据会报错
return HttpResponse("批量初始化学习记录失败，请检查该节课是否已经有对应的学习记录")
return redirect("/kingadmin/crm/studyrecord/?course_record__id__exact=%s"%queryset[0].id )
def mutil_init(self, request):
'''初始化的目的是为每一个同学创建记录'''
pk_list = request.POST.getlist("pk") #['1', '2'] 用户发过来的上课记录的id
record_list = models.CourseRecord.objects.filter(
id__in=pk_list) #数据库中查出的上课记录对象
for record in record_list:
print(type(record), "record") #python(6期) day2 对象
exists = models.StudyRecord.objects.filter(
course_record=record).exists()
if exists:
continue
student_list = models.Student.objects.filter(
class_list=record.class_obj) #查出这个班的所有的学生
bluk_list = []
for stu in student_list:
bluk_list.append(
models.StudyRecord(student=stu, course_record=record))
models.StudyRecord.objects.bulk_create(bluk_list)
def post(self, request, class_id):
course_record_ids = request.POST.getlist('ids', [])
for course_record_id in course_record_ids:
course_record_obj = models.CourseRecord.objects.filter(
pk=course_record_id).first()
students = course_record_obj.re_class.customer_set.filter(
status='studying')
study_record_list = []
for student in students:
if not models.StudyRecord.objects.filter(
student=student,
course_record_id=course_record_id).exists():
study_record_list.append(
models.StudyRecord(student=student,
course_record_id=course_record_id))
models.StudyRecord.objects.bulk_create(study_record_list)
return self.get(request, class_id)
