def event_achievement(request, pk):
context = {}
context['pk'] = pk
context["num"] = int(request.query_params["num"])
try:
event = common.get_user_event(request.user, pk)
context['event'] = event
except event_models.Event.DoesNotExist as e:
return default_views.Http404Page(request, e)
return app_render(request, 'exam_achievement.html', context)
def task_detail(request, pk, task_pk, **kwargs):
context = {}
pk = int(pk)
try:
event = common.get_user_event(request.user, pk)
except event_models.Event.DoesNotExist as e:
return default_views.Http404Page(request, e)
context['event'] = event
task_pk = int(task_pk)
if task_pk == 0:
context['mode'] = 0
else:
try:
task = event_models.EventTask.objects.get(pk=task_pk)
except event_models.EventTask.DoesNotExist as e:
return default_views.Http404Page(request, e)
context['task'] = task
return app_render(request, 'task_detail.html', context)
def exam_detail(request, pk, **kwargs):
context = {}
teachers = User.objects.filter(groups__id=GroupType.TEACHER).exclude(
Q(id=request.user.id) | Q(status=0))
context['teachers'] = teachers
pk = int(pk)
if pk == 0:
context['mode'] = 0
else:
try:
event = common.get_user_event(request.user, pk)
except event_models.Event.DoesNotExist as e:
return default_views.Http404Page(request, e)
context['mode'] = 1
context['event'] = event
######################################################
# totalEvent = event_models.Event.objects.all()
# context['totalEvent'] = totalEvent
######################################################
return app_render(request, 'exam_detail.html', context)
def batch_create(self, request):
event_pk = self.shift_data.get('event', int)
task_hashs = self.shift_data.getlist('task_hashs', str)
task_scores = self.shift_data.getlist('task_scores', int)
if not task_hashs:
raise exceptions.ValidationError(error.EMPTY_REQUEST)
if task_scores and len(task_scores) != len(task_hashs):
raise exceptions.ValidationError(
error.TASK_SCORE_NOT_CORRESPONDING)
try:
event = common.get_user_event(request.user, event_pk)
except event_models.Event.DoesNotExist as e:
raise exceptions.NotFound(error.EVENT_NOT_EXIST)
handled_task_hashs = self.task_handler_class.handle_tasks(task_hashs)
seq = event_models.EventTask.objects.filter(event=event).count() + 1
event_tasks = []
for i, task_hash in enumerate(handled_task_hashs):
event_task = event_models.EventTask(
event=event,
seq=seq,
task_hash=task_hash,
type=task_hash.split('.')[-1],
status=event_models.EventTask.Status.CLOSE)
if task_scores:
event_task.task_score = task_scores[i]
event_tasks.append(event_task)
seq = seq + 1
event_models.EventTask.objects.bulk_create(event_tasks)
self.clear_cache()
return Response(status=status.HTTP_200_OK)
def event_report_score(request, pk):
if is_en(request):
ORGANIZATION = ORGANIZATION_EN
else:
ORGANIZATION = ORGANIZATION_CN
context = {}
context['pk'] = pk
context['ORGANIZATION'] = ORGANIZATION
try:
event = common.get_user_event(request.user, pk)
context['event'] = event
taskArrary = event_models.EventTask.objects.filter(event=pk)
all_score = 0
all_count = 0
for t in taskArrary:
all_count += 1
all_score = all_score + t.task_score
context['all_score'] = all_score
context['all_count'] = all_count
# 获取授权的班级,年级,院系
auth_class_list = event.auth_classes.all()
auth_major = []
auth_faculty = []
auth_class = []
process = []
# is authority
process = [{
'id': 0,
'status': _("x_answering")
}, {
'id': 1,
'status': _("x_submit_over")
}]
if len(auth_class_list) == 0:
auth_class_list = Classes.objects.all()
for classes in auth_class_list:
auth_class.append(classes)
major_dict = {
'name': classes.major_name(),
'id': classes.major_id,
'parent_id': classes.major.faculty_id,
}
faculty_dict = {
'name': classes.faculty_name(),
'id': classes.faculty(),
}
if not auth_major.__contains__(major_dict):
auth_major.append(major_dict)
if not auth_faculty.__contains__(faculty_dict):
auth_faculty.append(faculty_dict)
context['process'] = process
context['classes'] = auth_class
context['majors'] = auth_major
context['facultys'] = auth_faculty
except event_models.Event.DoesNotExist as e:
return default_views.Http404Page(request, e)
return app_render(request, 'exam_result_list.html', context)
def event_rank_list(request):
event_id = request.GET.get('event', int)
process = request.GET.get('process', int)
faculty = request.GET.get('faculty', int)
major = request.GET.get('major', int)
classes = request.GET.get('classes', int)
event = common.get_user_event(request.user, event_id)
auth_class_list = event.auth_classes.all()
keyword = request.GET.get("search", None)
if len(auth_class_list) == 0:
type = 'unAuthority'
user_list = User.objects.all()
else:
type = 'authoritied'
auth_class_list = event.auth_classes.all()
auth_class_id_list = {auth_class.id for auth_class in auth_class_list}
user_list = User.objects.all().filter(
classes__id__in=auth_class_id_list)
user_id_list = []
# 如果按班级为单位筛选
if classes != '':
# 获取全班所有学生
user_list = user_list.filter(classes__id=classes)
elif major != '':
user_list = user_list.filter(major__id=major)
elif faculty != '':
user_list = user_list.filter(faculty__id=faculty)
else:
user_list = user_list
user_id_list = {user.id for user in user_list}
# queryset = event_models.EventUserSubmitLog.objects.filter()
# queryset = queryset.filter(event_task__event=event).filter(user__id__in=user_id_list)
queryset = SolvedRecord.objects.filter()
queryset = queryset.filter(event=event).filter(user__id__in=user_id_list)
queryset = queryset.values('user__id').annotate(
obj_id=F('user__id'),
obj_name=F('user__first_name'),
obj_username=F('user__username'))
# 所有已提交记录
queryset = queryset.annotate(
submit_time=Max('solved_time'), ).order_by("-solved_time")
if keyword != "" and keyword is not None:
filter_list = []
for user_result in queryset:
if keyword in user_result["obj_name"] or keyword in user_result[
"obj_username"]:
filter_list.append(user_result)
queryset = filter_list
res_list = []
submit_list = []
finish_list = []
if queryset:
for doing_user in queryset:
doing_user['writeup_score'] = 0
doing_user["submit_time"] = doing_user["submit_time"].strftime(
"%Y-%m-%d %H:%M:%S")
doing_user['status'] = _("x_answering")
doing_user['sum_score'] = 0
if SubmitRecord.objects.filter(user=doing_user["obj_id"]).filter(
event__id=event.id).exists():
pass
else:
submit_list.append(doing_user)
# 所有已交卷的
did_queryset = SubmitRecord.objects.filter(event__id=event.id).filter(
user__id__in=user_id_list)
exam_did_list = did_queryset.values('user__id', 'submit_time').annotate(
obj_id=F('user__id'),
obj_name=F('user__first_name'),
obj_username=F('user__username'),
score=Sum('score'))
if keyword != "" and keyword is not None:
filter_list = []
for user_result in exam_did_list:
if keyword in user_result["obj_name"] or keyword in user_result[
"obj_username"]:
filter_list.append(user_result)
exam_did_list = filter_list
if exam_did_list:
for did_user in exam_did_list:
did_user['status'] = _("x_submit_over")
did_user['submit_time'] = did_user["submit_time"].strftime(
"%Y-%m-%d %H:%M:%S")
did_user['writeup_score'] = 0
did_user['sum_score'] = did_user["score"]
finish_list.append(did_user)
context = {}
context['user_list'] = user_list.exclude(status=User.USER.DELETE)
ret_list = []
ret_list.extend(submit_list)
ret_list.extend(finish_list)
context['contain_list'] = ret_list
if process == '': # 如果是所有状态
res_list.extend(submit_list)
res_list.extend(finish_list)
# not_exam_list = get_not_exam_user(context)
# if len(not_exam_list) != 0:
# res_list.extend(not_exam_list)
elif process == '1': # 已交卷
res_list.extend(finish_list)
elif process == '0': # 已提交
res_list.extend(submit_list)
# else: # 如果是未开始状态
# res_list = get_not_exam_user(context)
# if type == 'unAuthority':
# res_list = []
return _list_view(request, res_list, ListEventRankSerializer)
def outputResult(request, pk):
context = {}
context['pk'] = pk
try:
event = common.get_user_event(request.user, pk)
context['event'] = event
task_arrary = event_models.EventTask.objects.filter(event=pk)
all_score = 0
all_count = 0
for t in task_arrary:
all_count += 1
all_score = all_score + t.task_score
context['all_score'] = all_score
context['all_count'] = all_count
except event_models.Event.DoesNotExist as e:
return default_views.Http404Page(request, e)
events = event_models.Event.objects.get(pk=pk)
eventset = SubmitRecord.objects.filter(event=events)
queryset = eventset.values('user__id').annotate(
obj_id=F('user__id'),
obj_name=F('user__first_name'),
obj_username=F('user__username'))
write_up_list = []
tash_list = []
# for task in task_arrary:
# task_hash = str(task.task_hash)
#
# write_up_di_lict = Note.objects.filter(resource=task_hash)
# tash_list.append(task_hash)
# write_up_list.append(write_up_di_lict)
queryset = queryset.annotate(
start_time=Min('submit_time'),
sum_score=Sum('score'),
submit_time=Max('submit_time'),
).order_by('-sum_score', 'submit_time')
for qs in queryset:
note = Note.objects.filter(resource=events.hash,
user_id=qs['obj_id']).first()
wr_score = qs['sum_score']
if note:
qs['sum_score'] = wr_score + note.score
qs['writeup_score'] = note.score
wb = xlwt.Workbook(encoding='utf-8')
sheet = wb.add_sheet('考试结果')
pattern = xlwt.Pattern() # Create the Pattern
pattern.pattern = xlwt.Pattern.SOLID_PATTERN # May be: NO_PATTERN, SOLID_PATTERN, or 0x00 through 0x12
pattern.pattern_fore_colour = 5 # 0 = Black, 1 = White, 2 = Red, 3 = Green, 4 = Blue, 5 = YelloW
borders = xlwt.Borders() # Create Borders
borders.left = xlwt.Borders.THIN # NO_LINE, THIN, MEDIUM, DASHED, DOTTED, THICK, DOUBLE,
borders.right = xlwt.Borders.THIN
borders.top = xlwt.Borders.THIN
borders.bottom = xlwt.Borders.THIN
style_border = xlwt.XFStyle() # Create Style
style_border_color = xlwt.XFStyle()
style_border.borders = borders # Add Borders to Style
style_border_color.borders = borders
style_border_color.pattern = pattern
sheet = excelHead(sheet, context, style_border, style_border_color)
sheet = excelContent(sheet, queryset, style_border)
wb.save('report.xls')
sio = StringIO.StringIO()
wb.save(sio)
sio.seek(0)
response = HttpResponse(sio.getvalue(),
content_type='application/vnd.ms-excel')
response['Content-Disposition'] = 'attachment; filename=report.xls'
response.write(sio.getvalue())
return response