def add_user_to_sheet(request, slug): sheet = get_object_or_404(Sheet, slug=slug) form_by_username = AddUserForm(request.POST or None) groups = UserAPI.get_groups_and_users_dict().keys() by_username_valid = form_by_username.is_valid() if by_username_valid: users = list() username = form_by_username.cleaned_data['username'] if username: users.append(get_object_or_404(User, username=username)) for group in groups: selected_users_pk = form_by_username.cleaned_data[group] for pk in selected_users_pk: users.append(get_object_or_404(User, pk=pk)) for user in users: if user != request.user: remove_perm('sheets.change_sheet', user, sheet) assign_perm('sheets.view_sheet', user, sheet) if form_by_username.cleaned_data['role'] == 'T': assign_perm('sheets.change_sheet', user, sheet) else: MarkAPI.create_marks_for_student(sheet, user) return redirect('sheet_detail', slug=slug) return render(request, 'add_user_to_sheet.html', { 'form_by_username': form_by_username, 'sheet': sheet })
def get_marks_for_user(user, sheet): result = [] from marks.services import MarkAPI for assignment in sheet.assignment_set.all(): if not assignment.task_set.exists(): result.append( SheetAPI.get_last_or_create(MarkAPI.get_marks_manager(assignment.grade_system), student=user, assignment=assignment, sheet=sheet)) else: for task in assignment.task_set.all(): if not task.problem_set.exists(): result.append( SheetAPI.get_last_or_create(MarkAPI.get_marks_manager(task.grade_system), student=user, task=task, sheet=sheet)) else: for problem in task.problem_set.all(): result.append( SheetAPI.get_last_or_create(MarkAPI.get_marks_manager(problem.grade_system), student=user, problem=problem, sheet=sheet)) return result
def change_mark(request, slug): if request.method == "POST": data = json.loads(request.body.decode("utf-8")) grade_system = data.get("grade_system") pk = data.get("pk") new_comment = data.get("comment") new_mark = data.get("mark") if grade_system is not None and pk is not None and new_mark is not None: with reversion.create_revision(): mark, old_mark = MarkAPI.set_mark(grade_system, pk, new_mark) if mark.problem: assignment_hierarchy = "{0:s}/{1:s}/{2:s}".format( mark.problem.task.assignment.name, mark.problem.task.name, mark.problem.name ) elif mark.task: assignment_hierarchy = "{0:s}/{1:s}".format(mark.task.assignment.name, mark.task.name) else: assignment_hierarchy = "{0:s}".format(mark.assignment.name) reversion.set_user(request.user) reversion.set_comment( """Mark for '{0:s}' student, for '{1:s}' assignment was changed from '{2:d}' to '{3:d}' by '{4:s}' user """.format( mark.student.username, assignment_hierarchy, old_mark, mark.mark, request.user.username ) ) if grade_system is not None and pk is not None and new_comment is not None: MarkAPI.set_comment(grade_system, pk, new_comment) return HttpResponse()
def lock_mark(request, slug): if request.method == "POST": data = json.loads(request.body.decode("utf-8")) grade_system = data.get("grade_system") pk = data.get("pk") if grade_system is not None and pk is not None: MarkAPI.set_user_with_lock_for_mark(grade_system, pk, request.user) return HttpResponse()
def remove_user_from_sheet(request, slug): username = request.GET['username'] if username and username != request.user.username: user = get_object_or_404(User, username=username) sheet = get_object_or_404(Sheet, slug=slug) MarkAPI.delete_marks_for_student(user) remove_perm('sheets.view_sheet', user, sheet) remove_perm('sheets.change_sheet', user, sheet) return redirect('sheet_detail', slug=slug)
def add_generic_problem(request, slug): if request.method == 'POST': data = json.loads(request.body.decode('utf-8')) task_pk = data.get('taskPk') task = Task.objects.get(pk=int(task_pk)) Problem.objects.create(task=task, name="P{0:d}".format(Problem.objects.filter(task=task).count() + 1)).save() MarkAPI.delete_mark_sets(task) return HttpResponse()
def save(self, commit=True, sheet=None): if sheet: self.instance.sheet = sheet super(AssignmentForm, self).save(commit) if 'grade_system' in self.cleaned_data: grade_system = self.cleaned_data['grade_system'] MarkAPI.delete_mark_sets(self.instance) # Creation of marks for assignemnt MarkAPI.create_marks_for_assignment(self.instance, grade_system) return self.instance
def add_generic_task(request, slug): sheet = Sheet.objects.get(slug=slug) if request.method == 'POST': data = json.loads(request.body.decode('utf-8')) assignment_pk = data.get('assignmentPk') assignment = Assignment.objects.get(pk=int(assignment_pk), sheet=sheet) Task.objects.create(assignment=assignment, name="T{0:d}".format(Task.objects.filter(assignment=assignment).count() + 1)).save() MarkAPI.delete_mark_sets(assignment) return HttpResponse()
def unlock_mark(request, slug): if request.method == "POST": data = json.loads(request.body.decode("utf-8")) grade_system = data.get("grade_system") pk = data.get("pk") if grade_system is not None and pk is not None: while True: try: MarkAPI.set_user_with_lock_for_mark(grade_system, pk, None) except RecordModifiedError: time.sleep(1) continue break return HttpResponse()
def quick_add_problem(request, sheet_slug, assignment_slug, task_slug): form = QuickAddForm(request.POST or None) if form.is_valid(): sheet = Sheet.objects.get(slug=sheet_slug) assignment = sheet.assignment_set.get(slug=assignment_slug) task = assignment.task_set.get(slug=task_slug) number_of_items = form.cleaned_data['number_of_items'] for _ in range(number_of_items): Problem.objects.create(task=task, name="P{0:d}".format(Problem.objects.filter(task=task).count() + 1)).save() MarkAPI.delete_mark_sets(task) return redirect('sheet_detail', slug=sheet_slug) return render(request, 'quick_add.html', { 'form': form })
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 save(self, commit=True, assignment=None): if assignment: self.instance.assignment = assignment super(TaskForm, self).save(commit) if 'grade_system' in self.cleaned_data: grade_system = self.cleaned_data['grade_system'] if self.instance.assignment: MarkAPI.delete_mark_sets(self.instance.assignment) MarkAPI.delete_mark_sets(self.instance) # Creation of marks for task MarkAPI.create_marks_for_task(self.instance, grade_system) return self.instance
def save(self, commit=True, task=None): if task: self.instance.task = task super(ProblemForm, self).save(commit) if task: task.problem_set.add(self.instance) if 'grade_system' in self.cleaned_data: grade_system = self.cleaned_data['grade_system'] if self.instance.task: MarkAPI.delete_mark_sets(self.instance.task) MarkAPI.delete_mark_sets(self.instance) # Creation of marks for problem MarkAPI.create_marks_for_problem(self.instance, grade_system) return self.instance