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
