def update_quiz(request, pk, template_name='teachers/update/update_quiz.html'):
quiz= get_object_or_404(Quiz, pk=pk)
quizzes = repo.QuizRepository(Quiz)
owner_id = quizzes.get_owner_id(pk)
is_active = quizzes.is_active(pk)
if request.user.id == owner_id and not is_active:
questions = repo.QuestionRepository(Questions)
sum_question_points = questions.sum_all_quiz_questions_points(pk)
cur_quiz_points = quizzes.get_quiz_points(pk)
form = QuizForm(request.POST or None, instance=quiz)
if form.is_valid():
quiz = form.save(commit=False)
form_points_data = form.cleaned_data["max_points"]
quiz.max_points = round(form_points_data, 1)
if_points_changed = round(form_points_data - cur_quiz_points, 1)
if if_points_changed != 0:
course_id = quizzes.get_course_id(pk)
all_q_points = quizzes.get_all_quiz_points(course_id)
c_points = quizzes.get_course_points(pk)
free_points = c_points - all_q_points + cur_quiz_points
free_points = round(free_points, 1)
if form_points_data > free_points:
quiz.max_points = cur_quiz_points
messages.error(request, 'Available course points: %f. '%free_points, extra_tags='alert')
if sum_question_points > form_points_data:
quiz.max_points = cur_quiz_points
messages.error(request, 'Question points in this quiz are: %f. '%sum_question_points, extra_tags='alert')
quiz.save()
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
return render(request, template_name, {'form':form, 'id': pk, 'sum_questions_points': sum_question_points})
raise Http404
def take_quiz(request, pk):
qr = repo.QuizRepository(Quiz)
test = helper.construct_quiz(pk)
qsrr = repo.QuizSolveRecordRepository(QuizSolveRecord)
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
is_submitted = qsrr.if_quiz_is_submitted(pk, request.user.id)
if is_submitted:
raise Http404
is_started = qsrr.check_if_started(pk, request.user.id)
if(not is_started):
raise Http404
timer = qr.get_quiz_timer(pk)
start_time = qsrr.get_start_time(pk, request.user.id)
time = start_time + datetime.timedelta(minutes = timer)
now = timezone.now()
now = timezone.localtime(now)
time_delta = (time - now)
time_delta = time_delta.seconds / 60
quiz_name =qr.get_name(pk)
if time_delta > timer and timer != 0:
raise Http404 #TODO page time is end
return render(request, 'students/quiz_solve.html', {'tests': test, 'quiz_id': pk, 'timer': timer, 'minutes_left': time_delta, 'quiz_name': quiz_name})
def get(self, request):
data = {
'deleted': False
}
answersR = repo.AnswerRepository(Answers)
ans_id = request.GET.get('id', None)
quiz_id = answersR.get_quiz_id(ans_id)
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(quiz_id)
questions = repo.QuestionRepository(Questions)
question_id = answersR.get_question_id(ans_id)
question_type = questions.get_question_type(question_id)
answer_points = answersR.get_answer_points(ans_id)
is_done = questions.get_done_status(question_id)
is_deleted = False
if request.user.id == owner_id:
answersR.answer_delete(ans_id)
is_deleted = True
data = {
'deleted': True
}
if is_deleted:
if question_type != 'grammar':
if is_done == True:
if answer_points != 0:
questions.update_is_done(question_id, False)
else:
answersRepo = repo.AnswerRepository(Answers)
answers_count = answersRepo.get_answers_count(question_id)
if is_done == True and answers_count == 0:
questions.update_is_done(question_id, False)
return JsonResponse(data)
def take_quiz_confirm(request, pk):
qsrr = repo.QuizSolveRecordRepository(QuizSolveRecord)
is_started = qsrr.check_if_started(pk, request.user.id)
qr = repo.QuizRepository(Quiz)
quiz = qr.get_by_id(pk)
course_id = qr.get_course_id(pk)
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
minutes_left = 0
if quiz:
if is_started:
timer = quiz[0].timer_minutes
if timer != 0:
start_time = qsrr.get_start_time(pk, request.user.id)
end_time = start_time + datetime.timedelta(minutes = timer)
now = timezone.now()
now = timezone.localtime(now)
time_delta = (end_time - now)
minutes_left = time_delta.seconds / 60
else:
minutes_left = quiz[0].timer_minutes
return render(request, 'students/confirm/take_quiz_confirm.html', {'quiz': quiz, 'course_id': course_id, 'minutes_left': round(minutes_left), 'is_started': is_started})
def quiz_add(request, pk):
course = get_object_or_404(Course, pk=pk, owner_id=request.user)
courses = repo.CourseRepository(Course)
c_points = courses.get_points(pk)
quizzes = repo.QuizRepository(Quiz)
all_q_points = quizzes.get_all_quiz_points(pk)
free_points = c_points - all_q_points
free_points = round(free_points, 1)
if request.method == 'POST':
form = QuizForm(request.POST)
if form.is_valid():
quiz = form.save(commit=False)
quiz.course = course
quiz.owner = request.user
max_points = form.cleaned_data["max_points"]
difference = round(max_points - free_points, 1)
if(difference <= 0):
quiz.max_points = round(max_points, 1)
quiz.save()
messages.success(request, 'You may now add question/options to the quiz.')
return redirect('/teachers/course/%d/quizzes'%pk)
else:
messages.error(request, 'You put more points than you have left. Available points: %f'%free_points, extra_tags='alert')
else:
form = QuizForm()
return render(request, 'teachers/add/quiz_add.html', {'course': course, 'form': form, 'free_points':free_points })
def view_course_quizzes(request, pk):
quiz = repo.QuizRepository(Quiz)
quizzes = quiz.get_by_user_course(request.user, pk)
courses = repo.CourseRepository(Course)
course_name, course_points = courses.get_name_and_points(pk)
owner_id = courses.get_owner_id(pk)
if(request.user.id == owner_id):
return render(request, 'teachers/lists/quiz_list.html', {'quizzes': quizzes, 'course_id': pk, 'course_name': course_name, 'course_points': course_points})
raise Http404
def save_checked_answers(request, pk, spk):
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(pk)
course_id = quiz.get_course_id(pk)
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_participant = cpr.is_user_participant(spk, course_id)
if request.user.id == owner_id and is_participant:
new_points = request.POST['data']
new_points = json.loads(new_points)
quesrtr = repo.QuestionRepository(Questions)
soar = repo.StudentOpenAnswersRepository(StudentOpenAnswers)
qsrr = repo.QuizSolveRecordRepository(QuizSolveRecord)
sgar = repo.StudentGrammarAnswersRepository(StudentGrammarAnswers)
solve_info_id = qsrr.get_solve_info_id(pk, spk)
#new_points[i]['name'] - id
#new_points[i]['value'] - points
sum_points = 0
for i in range(1, len(new_points)):
question_id = int(new_points[i]['name'])
question_info = quesrtr.get_open_grammar_question_id_points(pk, question_id)
if question_info != -1:
if question_info['qtype'] == 'open':
points = round(float(new_points[i]['value']), 1)
open_question_points = float(question_info['points'])
if points <= open_question_points:
soar.update_answer_points(solve_info_id, question_id, points)
sum_points += points
else:
soar.update_answer_points(solve_info_id, question_id, open_question_points)
sum_points += open_question_points
else:
if question_info['qtype'] == 'grammar':
if isfloat(new_points[i]['value']):
points = round(float(new_points[i]['value']), 1)
grammar_points = float(question_info['points'])
if points <= grammar_points:
sgar.update_answer_points(solve_info_id, question_id, points)
sum_points += points
else:
sgar.update_answer_points(solve_info_id, question_id, grammar_points)
sum_points += grammar_points
else:
sgar.update_answer_corrected(solve_info_id, question_id, new_points[i]['value'])
student_points = qsrr.get_points(solve_info_id)
qsrr.update_quiz_points_and_status(solve_info_id, student_points + sum_points, True)
return JsonResponse({
'success': True,
'url': reverse('teachers:view_quiz_for_check', kwargs={'pk': pk}), #, args=[{'courses': courses}]
})
raise Http404
def view_quiz_for_check(request, pk):
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(pk)
if request.user.id == owner_id:
quiz_name = quiz.get_name(pk)
qsr = repo.QuizSolveRecordRepository(QuizSolveRecord)
quizzes = qsr.get_quizzes_and_students(pk, False)
course_id = quiz.get_course_id(pk)
return render(request, 'teachers/lists/check_quiz_list.html', {'quizzes': quizzes, 'course_id': course_id, 'quiz_name': quiz_name})
raise Http404
def quiz_preview(request, pk):
qr = repo.QuizRepository(Quiz)
owner_id = qr.get_owner_id(pk)
if request.user.id == owner_id:
test = construct_quiz_teacher(pk)
quiz_name =qr.get_name(pk)
course_id = qr.get_course_id(pk)
return render(request, 'teachers/view/quiz_preview.html', {'tests': test, 'quiz_name': quiz_name, 'course_id': course_id})
else:
raise Http404
def student_view_quiz_info(request, pk, template_name='students/quiz_info.html'):
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
quiz= get_object_or_404(Quiz, pk=pk)
quizzesR = repo.QuizRepository(Quiz)
owner_id = quizzesR.get_owner_id(pk)
quizzes = quizzesR.get_by_id(pk)
return render(request, template_name, {'id': pk, 'quizzes': quizzes})
def get(self, request):
quizR = repo.QuizRepository(Quiz)
quiz_id = request.GET.get('id', None)
is_active = quizR.is_active(quiz_id)
owner_id = quizR.get_owner_id(quiz_id)
if request.user.id == owner_id and not is_active:
quizR.quiz_delete(quiz_id)
data = {
'deleted': True
}
return JsonResponse(data)
def get(self, request):
quizR = repo.QuizRepository(Quiz)
questionR = repo.QuestionRepository(Questions)
quiz_id = request.GET.get('id', None)
owner_id = quizR.get_owner_id(quiz_id)
if request.user.id == owner_id:
quizR.update_is_active(quiz_id, False)
messages.success(request, 'Success!')
data = {
'deactivated': True
}
return JsonResponse(data)
def graded_quiz_view(request, pk):
qr = repo.QuizRepository(Quiz)
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
test = helper.construct_quiz_student_results(pk, request.user.id)
quiz_name =qr.get_name(pk)
course_id = qr.get_course_id(pk)
return render(request, 'teachers/view/student_quiz_view.html', {'tests': test, 'quiz_name': quiz_name, 'quiz_id': pk, 'course_id': course_id, 'role': 'student'})
def get_answers_for_check(request, pk, spk):
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(pk)
course_id = quiz.get_course_id(pk)
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_participant = cpr.is_user_participant(spk, course_id)
if request.user.id == owner_id and is_participant:
quiz_name = quiz.get_name(pk)
answers = open_answers_for_check(pk, spk)
answers_grammar = grammar_answers_for_check(pk, spk)
return render(request, 'teachers/check_quiz/check_quiz.html', {'answers': answers, 'answers_grammar':answers_grammar, 'quiz_id': pk, 'student_id': spk, 'quiz_name': quiz_name, 'error_codes': checkerop.error_explain})
raise Http404
def view_quiz_questions(request, pk):
questionsR = repo.QuestionRepository(Questions)
questions = questionsR.get_by_quiz_id(pk)
quiz = repo.QuizRepository(Quiz)
quizzes = quiz.get_by_id(pk)
course_id = quiz.get_course_id(pk)
if quizzes:
owner_id = quizzes[0].owner_id
else:
owner_id = 0
if request.user.id == owner_id:
return render(request, 'teachers/lists/questions_list.html', {'questions': questions, 'quiz': pk, 'quizzes': quizzes, 'quiz_is_active': quizzes[0].is_active, 'course_id': course_id})
raise Http404
def view_course_active_quizzes(request, pk):
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_user_participant(request.user.id, pk)
if not is_in_joined_courses:
raise Http404
quiz = repo.QuizRepository(Quiz)
quizzes = quiz.get_active_quizzes_student_info(pk, request.user.id)
if not quizzes:
course_name = ""
else:
course_name = quizzes[0].course
return render(request, 'students/lists/quiz_list.html', {'quizzes': quizzes, 'course_name': course_name})
def student_quiz_view(request, pk, spk):
qr = repo.QuizRepository(Quiz)
owner_id = qr.get_owner_id(pk)
if request.user.id == owner_id:
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_courses(pk, spk)
if not is_in_joined_courses:
raise Http404
test = construct_quiz_student_results(pk, spk)
quiz_name =qr.get_name(pk)
return render(request, 'teachers/view/student_quiz_view.html', {'tests': test, 'quiz_name': quiz_name, 'quiz_id': pk, 'role': 'teacher', 'errors': checkerop.error_explain})
raise Http404
def quiz_update_in_code(request, pk, template_name='teachers/update/update_in_code.html'):
quiz= get_object_or_404(Quiz, pk=pk)
quizzes = repo.QuizRepository(Quiz)
owner_id = quizzes.get_owner_id(pk)
if request.user.id == owner_id:
form = QuizInCodeForm(request.POST or None, instance=quiz)
if form.is_valid():
quiz = form.save(commit=False)
if len(form.cleaned_data["in_code"]) <= 6:
quiz.save()
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
return render(request, template_name, {'form':form, 'id': pk})
raise Http404
def get(self, request):
courses = repo.CourseRepository(Course)
course_id = request.GET.get('id', None)
status = request.GET.get('is_active', None)
owner_id = courses.get_owner_id(course_id)
if request.user.id == owner_id:
if status == 'True':
courses.update_is_active_and_in_code(course_id, status, generate_code())
else:
qr = repo.QuizRepository(Quiz)
qr.update_all_course_quizzes_status(course_id, status)
courses.update_is_active(course_id, status)
data = {
'activated': True
}
return JsonResponse(data)
def update_answer(request, pk, template_name='teachers/update/item_edit_form.html'):
answer= get_object_or_404(Answers, pk=pk)
answersR = repo.AnswerRepository(Answers)
quiz_id = answersR.get_quiz_id(pk)
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(quiz_id)
if request.user.id == owner_id:
form = AnswerForm(request.POST or None, instance=answer)
if form.is_valid():
instance = form.save(commit=False)
form_points_data = form.cleaned_data["points"]
answer_points = answersR.get_answer_points(pk)
are_points_changed = round(answer_points - form_points_data, 1)
if are_points_changed != 0:
questions = repo.QuestionRepository(Questions)
question_id = answersR.get_question_id(pk)
sum_answers_points = answersR.sum_all_question_answers_points(question_id)
question_points = answersR.get_question_points(question_id)
answer_points = answersR.get_answer_points(pk)
free_points = question_points - sum_answers_points + answer_points
free_points = round(free_points, 1)
instance.points = round(form_points_data, 1)
is_done = questions.get_done_status(question_id)
difference = round(free_points - form_points_data, 1)
if difference >= 0:
if(difference == 0):
if is_done == False:
questions.update_is_done(question_id, True)
else:
if is_done == True:
questions.update_is_done(question_id, False)
messages.success(request, 'Success!')
else:
instance.points = answer_points
messages.error(request, 'You put more points than you have left. Available points: %f'%free_points)
instance.save()
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
return render(request, template_name, {'form':form, 'id': pk})
raise Http404
def view_students_quiz_grades(request, pk):
quiz_ch = get_object_or_404(Quiz, pk=pk)
quiz = repo.QuizRepository(Quiz)
owner_id = quiz.get_owner_id(pk)
if request.user.id == owner_id:
qsr = repo.QuizSolveRecordRepository(QuizSolveRecord)
quizzes = qsr.get_quizzes_and_students(pk, True)
course_id = quiz.get_course_id(pk)
points = quiz.get_point_schedule(pk)
max_points = 0
min_points = 0
good_points = 0
if points:
max_points = points[0]['max_points']
min_points = points[0]['min_points']
good_points = points[0]['good_points']
return render(request, 'teachers/lists/students_grade_list.html', {'quizzes': quizzes, 'course_id': course_id, 'min_points': min_points, 'good_points': good_points, 'max_points': max_points})
raise Http404
def activate_quiz(request, pk, template_name='teachers/activate/activate_quiz.html'):
quiz= get_object_or_404(Quiz, pk=pk)
quizR = repo.QuizRepository(Quiz)
#owner_id = quizR.get_owner_id(pk)
owner_id = quiz.owner_id
if request.user.id == owner_id:
is_course_active = quizR.is_course_active(pk)
form = QuizActivateForm(request.POST or None, instance=quiz)
if is_course_active:
questionR = repo.QuestionRepository(Questions)
is_quiz_done = questionR.is_quiz_done(pk)
sum_questions_points = questionR.sum_all_quiz_questions_points(pk)
quiz_points = quizR.get_quiz_points(pk)
is_active = quizR.is_active(pk)
if form.is_valid():
quiz = form.save(commit=False)
check = check_grades(form.cleaned_data["max_points"], form.cleaned_data["good_points"], form.cleaned_data["min_points"])
if check:
if(sum_questions_points == quiz_points):
if is_quiz_done:
quiz.in_code = generate_code()
quiz.save()
quizR.update_is_active(pk, not is_active)
messages.success(request, 'Success!')
else:
messages.error(request, 'You have question that dont have enough answers')
else:
messages.error(request, 'Sum of quiz queston is not equal quiz points')
else:
messages.error(request, 'Put points in the right order')
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
return render(request, template_name, {'form':form, 'id': pk})
else:
messages.error(request, 'Please activate course first.')
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
else:
raise Http404
def update_course(request, pk, template_name='teachers/update/update_course.html'):
course= get_object_or_404(Course, pk=pk)
courses = repo.CourseRepository(Course)
owner_id = courses.get_owner_id(pk)
if request.user.id == owner_id:
form = CourseForm(request.POST or None, instance=course)
if form.is_valid():
points = form.cleaned_data["points"]
quiz = repo.QuizRepository(Quiz)
all_quiz_points = quiz.get_all_quiz_points(pk)
difference = round(points - all_quiz_points, 1)
if(difference >= 0):
form.save()
messages.success(request, 'Course is updated')
else:
messages.error(request, 'Course is not updated. Quizzes in the course have more points than new course points', extra_tags='alert')
return HttpResponse(render_to_string('teachers/update/item_edit_form_success.html'))
return render(request, template_name, {'form':form, 'id': pk})
raise Http404
def join_quiz(request, pk, template_name='students/join_quiz.html'):
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
quiz= get_object_or_404(Quiz, pk=pk)
qr = repo.QuizRepository(Quiz)
if request.method == 'POST':
code = request.POST.get('code')
in_code = qr.get_quiz_code(pk)
if in_code == code:
qsrr = repo.QuizSolveRecordRepository(QuizSolveRecord)
is_started = qsrr.check_if_started(pk, request.user.id)
if(not is_started):
qsrr.start_quiz(pk, request.user.id)
return redirect('students:take_quiz', pk=pk)
messages.success(request, 'Welcome to the course')
else:
messages.error(request, 'Please enter the right varification code.')
return redirect('students:take_quiz_confirm', pk=pk)
else:
return render(request, template_name, {'id': pk})
def finish_test(request, pk):
qsrr = repo.QuizSolveRecordRepository(QuizSolveRecord)
is_submitted = qsrr.if_quiz_is_submitted(pk, request.user.id)
if is_submitted:
raise Http404
cpr = repo.CourseParticipantsRepository(CourseParticipants)
is_in_joined_courses = cpr.is_quiz_in_joined_active_courses(pk, request.user.id)
if not is_in_joined_courses:
raise Http404
solve_info_id = qsrr.get_solve_info_id(pk, request.user.id)
if solve_info_id != 0:
grammarChecker_ru = checkerop.GrammarChecker('ru')
grammarChecker_en = checkerop.GrammarChecker('en')
student_answers = request.POST['data']
student_answers = json.loads(student_answers)
quiz_data = helper.construct_main(pk)
is_fully_checked = True
points = 0
solve_info_id = int(solve_info_id)
sar = repo.StudentAnswersRepository(StudentAnswers)
soar = repo.StudentOpenAnswersRepository(StudentOpenAnswers)
sgar = repo.StudentGrammarAnswersRepository(StudentGrammarAnswers)
lang_id = -1
grammarChecker = -1
gqsr = -1
for i in range(1, len(student_answers)):
if i != 0:
#name = question_id
#value = answer_id or answer to open question
key = int(student_answers[i]['name'])
#check if question_id belongs to quiz
if key in quiz_data.keys():
if quiz_data[key]['qtype'] != 'open' and quiz_data[key]['qtype'] != 'compare' and quiz_data[key]['qtype'] != 'grammar':
#check if answer_id belongs to question
answer_id = int(student_answers[i]['value'])
if answer_id in quiz_data[key]['answers'].keys():
points += float(quiz_data[key]['answers'][answer_id])
#create record
sar.save_answer(solve_info_id, key, answer_id)
else:
answer = student_answers[i]['value']
if quiz_data[key]['qtype'] == 'open':
is_fully_checked = False
soar.save_answer(solve_info_id, key, answer, 0)
if(len(answer)):
if quiz_data[key]['qtype'] == 'compare':
points_compare = helper.check_student_compare_answer(key, str(answer))
points += points_compare
#save answer + compare algorithm = points
soar.save_answer(solve_info_id, key, answer, points_compare)
if quiz_data[key]['qtype'] == 'grammar':
gqsr = repo.GrammarQuestionSanctionsRepository(GrammarQuestionSanctions)
lang_id = gqsr.get_language(key)
if lang_id != -1:
langRepo = repo.LanguagesRepository(Languages)
lang = langRepo.get_abr_by_id(lang_id)
'''
if grammarChecker != -1:
if grammarChecker.lang != lang:
grammarChecker = checkerop.GrammarChecker(lang)
else:
grammarChecker = checkerop.GrammarChecker(lang)
'''
if lang == 'ru':
grammarChecker = grammarChecker_ru
else:
grammarChecker = grammarChecker_en
if lang_id != -1 and grammarChecker != -1 and gqsr != -1:
question_sanctions = gqsr.form_error_sanction_dict(key)
struct, corrected_sents, points_gra = helper.check_student_grammar_answer(key, str(answer), question_sanctions, grammarChecker)
sgar.save_answer(solve_info_id, key, answer, points_gra, corrected_sents, struct)
grammarChecker.reset()
qsrr.finish_quiz(pk, request.user.id, points, is_fully_checked)
qr = repo.QuizRepository(Quiz)
course_id = qr.get_course_id(pk)
return JsonResponse({
'success': True,
'url': reverse('students:view_course_active_quizzes', kwargs={'pk': course_id}), #, args=[{'courses': courses}]
})
raise Http404
def view_quiz_info(request, pk, template_name='teachers/info/quiz_info.html'):
quiz= get_object_or_404(Quiz, pk=pk)
quizzesR = repo.QuizRepository(Quiz)
owner_id = quizzesR.get_owner_id(pk)
quizzes = quizzesR.get_by_id(pk)
return render(request, template_name, {'id': pk, 'quizzes': quizzes})