def history(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
mark_set = SheetAPI.get_marks_for_sheet(sheet).values()
history_items_list = []
for marks in mark_set:
for mark in marks:
for revision in reversion.get_for_object(mark).all():
history_items_list.append(revision)
history_items_list.sort(key=lambda item: item.revision.date_created, reverse=True)
history_items_list = [
history_item.revision.comment + timezone.localtime(history_item.revision.date_created).strftime(
'(%y-%m-%d %H:%m:%S)') for
history_item in history_items_list]
paginator = Paginator(history_items_list, 5)
page = request.GET.get('page')
try:
history_items = paginator.page(page)
except PageNotAnInteger:
history_items = paginator.page(1)
except EmptyPage:
history_items = paginator.page(paginator.num_pages)
return render(request, 'history.html', {
'history_items': history_items
})
def get_marks(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
sheet_marks = SheetAPI.get_marks_for_sheet(sheet)
mark_sets_json_dict = list()
for student, students_marks in sheet_marks.items():
marks_json_dict = list()
for mark in students_marks:
mark_json = mark.as_json_dict
versions = reversion.get_for_object(mark)[:2]
if versions.count() >= 2:
first_revision = versions[0].revision
second_revision = versions[1].revision
if (
second_revision.user == request.user
and first_revision.user != second_revision.user
and (first_revision.date_created - second_revision.date_created).seconds < 10
):
mark_json["warning"] = True
marks_json_dict.append(mark_json)
if mark.user_with_lock:
now = timezone.now()
time_delta = now - mark.user_with_lock.profile.last_activity
if time_delta.total_seconds() > 15:
mark.set_user_with_lock(None)
mark_sets_json_dict.append(dict(student=UserAPI.as_json_dict(student, sheet), marks=marks_json_dict))
mark_sets_json_dict = sorted(mark_sets_json_dict, key=lambda item: item["student"]["fullName"].split(" ")[1])
return JsonResponse(mark_sets_json_dict, safe=False)
def export_xls(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
response = HttpResponse(content_type='application/ms-excel')
response['Content-Disposition'] = 'attachment; filename=' + slugify(sheet.name) + '.xls'
work_book = SheetAPI.generate_report(sheet)
work_book.save(response)
return response
def sheet_detail(request, slug):
sheet = Sheet.objects.get(slug=slug)
assignments = sheet.assignment_set.all()
child_columns_count = dict()
for assignment in assignments:
child_columns_count[assignment] = 0
for task in assignment.task_set.all():
child_columns_count[assignment] += task.problem_set.count() or 1
if request.user.has_perm('sheets.change_sheet', sheet):
users = get_users_with_perms(sheet)
teachers = sorted([user for user in users if user.has_perm('sheets.change_sheet', sheet)],
key=lambda user: user.last_name)
students = SheetAPI.get_students_for_sheet(sheet)
MarkAPI.unlock_marks(request.user, sheet)
return render(request, 'sheet_detail.html', {
'sheet': sheet,
'teachers': teachers,
'students': students,
'assignments': assignments,
'child_columns_count': child_columns_count
})
raw_marks = SheetAPI.get_marks_for_user(request.user, sheet)
marks = []
for ind, mark in enumerate(raw_marks):
mark_dict = dict(mark=raw_marks[ind].mark, comment=raw_marks[ind].comment)
if type(raw_marks[ind]) is BoolMark:
mark_dict['grade_system'] = BaseAssignment.BOOL_MARK
elif type(raw_marks[ind]) is ZeroToFiveMark:
mark_dict['grade_system'] = BaseAssignment.ZERO_FIVE
elif type(raw_marks[ind]) is ZeroToTenMark:
mark_dict['grade_system'] = BaseAssignment.ZERO_TEN
else:
mark_dict['grade_system'] = BaseAssignment.ZERO_HUNDRED
marks.append(mark_dict)
overall_mark = MarkAPI.map_overall_mark(sheet.overall_mark(request.user))
return render(request, 'sheet_detail_student.html', {
'sheet': sheet,
'assignments': assignments,
'child_columns_count': child_columns_count,
'marks': marks,
'overall_mark': overall_mark
})
def attendance_detail(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
users = get_users_with_perms(sheet)
teachers = [user for user in users if user.has_perm('sheets.change_sheet', sheet)]
students = SheetAPI.get_students_for_sheet(sheet)
return render(request, 'attendance_detail.html', {
'sheet': sheet,
'teachers': teachers,
'students': students
})
def get_attendance_records(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
seminars = sheet.seminar_set.order_by('date')
students = sorted(SheetAPI.get_students_for_sheet(sheet), key=operator.attrgetter('last_name'))
attendance_records = []
for student in students:
attendance_records_json_dict = dict(student=UserAPI.as_json_dict(student), attendanceRecords=list())
for seminar in seminars:
attendance_records_json_dict['attendanceRecords'].append(
seminar.attendancerecord_set.get_or_create(student=student)[0].as_json_dict)
attendance_records.append(attendance_records_json_dict)
return JsonResponse(attendance_records, safe=False)
def apply_regex_rules(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
is_valid, errors = SheetAPI.check_and_apply_regex_rules(sheet)
if not is_valid:
assignments = sheet.assignment_set.all()
child_columns_count = dict()
for assignment in assignments:
child_columns_count[assignment] = 0
for task in assignment.task_set.all():
child_columns_count[assignment] += task.problem_set.count() or 1
return render(request, 'regex_rules.html', {
'sheet': sheet,
'assignments': assignments,
'child_columns_count': child_columns_count,
'regex_rules': sheet.regexrule_set.all(),
'errors': errors
})
return redirect('sheet_detail', slug=slug)
def get_students(request, slug):
sheet = get_object_or_404(Sheet, slug=slug)
students = SheetAPI.get_students_for_sheet(sheet)
return JsonResponse([UserAPI.as_json_dict(student, sheet) for student in students], safe=False)
def create_marks_for_problem(problem_instance, grade_system):
students = SheetAPI.get_students_for_sheet(problem_instance.task.assignment.sheet)
marks_manager = MarkAPI.get_marks_manager(grade_system)
for student in students:
marks_manager.get_or_create(student=student, problem=problem_instance,
sheet=problem_instance.task.assignment.sheet)
def create_marks_for_task(task_instance, grade_system):
students = SheetAPI.get_students_for_sheet(task_instance.assignment.sheet)
marks_manager = MarkAPI.get_marks_manager(grade_system)
for student in students:
marks_manager.create(student=student, task=task_instance,
sheet=task_instance.assignment.sheet)
def create_marks_for_assignment(assignment_instance, grade_system):
students = SheetAPI.get_students_for_sheet(assignment_instance.sheet)
marks_manager = MarkAPI.get_marks_manager(grade_system)
for student in students:
marks_manager.create(student=student, assignment=assignment_instance,
sheet=assignment_instance.sheet)
