def get_student_list(request):
from quizzo.serializers.limit_offset_search import LimitOffsetSearchSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(LimitOffsetSearchSerializer, request.data)
from quizzo.models.student import Student
if request_data.filter_by == "all":
student_query_set = Student.objects.all().values(
'id', 'username', 'year')
else:
student_query_set = Student.objects.filter(
username__icontains=request_data.search).values(
'id', 'username', 'year')
total = student_query_set.count()
students_obj = {
"total":
total,
"students":
student_query_set[request_data.offset:request_data.limit +
request_data.offset]
}
from quizzo.serializers.teacher_list_response import StudentListResponseType
students_type_obj = StudentListResponseType(**students_obj)
from quizzo.serializers.teacher_list_response import StudentListResponseSerializer
result = StudentListResponseSerializer(students_type_obj)
return Response(result.data)
def get_student_quiz_list(request, username):
from quizzo.serializers.limit_offset import LimitOffsetSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(LimitOffsetSerializer, request.data)
from quizzo.models.student import Student
student_obj = Student.get_student_obj(username)
from quizzo.models.student_quiz import StudentQuiz
student_query_set = StudentQuiz.objects.filter(student=student_obj)[
request_data.offset:request_data.limit + request_data.offset]
students_list = []
for obj in student_query_set:
temp = {
"title": obj.quiz.title,
"marks": obj.marks_obtained,
"grade": obj.grade
}
students_list.append(temp)
total = student_query_set.count()
students_obj = {
"total": total,
"quizzes": students_list
}
from quizzo.serializers.student_quiz_list import StudentQuizListType
students_type_obj = StudentQuizListType(**students_obj)
from quizzo.serializers.student_quiz_list import StudentQuizListResponseSerializer
result = StudentQuizListResponseSerializer(students_type_obj)
return Response(result.data)
def create(self, validated_data):
from quizzo.serializers.student_quiz import StudentQuizSerializer
quizzes_val = []
quizzes_list_val = validated_data.pop("quizzes", [])
for each_data in quizzes_list_val:
each_obj = deserialize(StudentQuizSerializer, each_data, many=False, partial=True)
quizzes_val.append(each_obj)
return StudentQuizListType(quizzes=quizzes_val, **validated_data)
def create(self, validated_data):
from quizzo.serializers.quiz_attempt import QuizAttemptResponseSerializer
quiz_questions_val = []
quiz_questions_list_val = validated_data.pop("quiz_questions", [])
for each_data in quiz_questions_list_val:
each_obj = deserialize(QuizAttemptResponseSerializer, each_data, many=False, partial=True)
quiz_questions_val.append(each_obj)
return QuizAttemptListType(quiz_questions=quiz_questions_val, **validated_data)
def create(self, validated_data):
from quizzo.serializers.option import OptionSerializer
options_val = []
options_list_val = validated_data.pop("options", [])
for each_data in options_list_val:
each_obj = deserialize(OptionSerializer,
each_data,
many=False,
partial=True)
options_val.append(each_obj)
return QuestionOptionType(options=options_val, **validated_data)
def create(self, validated_data):
from quizzo.serializers.teacher_student_details import StudentDetailsResponseSerializer
students_val = []
students_list_val = validated_data.pop("students", [])
for each_data in students_list_val:
each_obj = deserialize(StudentDetailsResponseSerializer,
each_data,
many=False,
partial=True)
students_val.append(each_obj)
return StudentListResponseType(students=students_val, **validated_data)
def create(self, validated_data):
from quizzo.serializers.leaderboard_response import LeaderboardResponseSerializer
students_val = []
students_list_val = validated_data.pop("students", [])
for each_data in students_list_val:
each_obj = deserialize(LeaderboardResponseSerializer,
each_data,
many=False,
partial=True)
students_val.append(each_obj)
return LeaderboardResponseListType(students=students_val,
**validated_data)
def create(self, validated_data):
print(validated_data)
from quizzo.serializers.question_options import QuestionOptionSerializer
quiz_questions_val = []
quiz_questions_list_val = validated_data.pop("quiz_questions", [])
for each_data in quiz_questions_list_val:
each_obj = deserialize(QuestionOptionSerializer,
each_data,
many=False,
partial=True)
quiz_questions_val.append(each_obj)
return QuizResponseType(quiz_questions=quiz_questions_val,
**validated_data)
def quiz_answers(request, username, quiz_id):
from quizzo.serializers.quiz_attempt_list import QuizAttemptListSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(QuizAttemptListSerializer, request.data)
from quizzo.models.option import Option
from quizzo.models.quiz import Quiz
quiz_obj = Quiz.objects.get(id=quiz_id)
questions = quiz_obj.questions.all()
marks_obtained = 0
for req_obj in request_data.quiz_questions:
for obj in questions:
if req_obj.question_id == obj.id:
if req_obj.type == "mcq":
if req_obj.option_id == obj.answer_id:
marks_obtained += obj.marks
break
else:
if req_obj.option == Option.objects.get(
id=obj.answer_id).content:
marks_obtained += obj.marks
total_question_marks = 0
for obj in questions:
total_question_marks += obj.marks
from quizzo.utils.grade_calculator import grade_calculator
grade = grade_calculator(total_question_marks, marks_obtained)
from quizzo.models.student_quiz import StudentQuiz
from quizzo.models.student import Student
student_obj = Student.get_student_obj(username)
studentquiz_obj = StudentQuiz.objects.create(student=student_obj,
quiz_id=quiz_id,
marks_obtained=marks_obtained,
grade=grade)
from quizzo.models.question import Question
from quizzo.models.student_quiz_attempt import StudentQuizAttempt
for obj in request_data.quiz_questions:
student_attempted_obj = StudentQuizAttempt.objects.create(
question=Question.get_question_obj(obj.question_id),
attempted_id=obj.option_id,
attempted_answer=obj.option)
studentquiz_obj.user_options.add(student_attempted_obj)
result = {"grade": grade, "marks": marks_obtained}
return Response(result)
def update_teacher_profile(request, username):
from quizzo.serializers.teacher_profile import TeacherProfileSerializer
from quizzo.utils.deserialize import deserialize
student_obj = deserialize(TeacherProfileSerializer, request.data)
from quizzo.models.teacher import Teacher
teacher = Teacher.update_profile(student_obj, username)
teacher_obj = {
"id": teacher.id,
"username": teacher.user,
"user_type": "teacher"
}
from quizzo.serializers.id_name import IdNameType
teacher_type_obj = IdNameType(**teacher_obj)
from quizzo.serializers.id_name import IdNameSerializer
teacher_serializer = IdNameSerializer(teacher_type_obj)
return Response(teacher_serializer.data)
def student_signup(request):
from quizzo.serializers.student_profile import StudentProfileSerializer
from quizzo.utils.deserialize import deserialize
student_obj = deserialize(StudentProfileSerializer, request.data)
from quizzo.models.student import Student
student = Student.sign_up(student_obj)
student_obj = {
"id": student.id,
"username": student.user,
"user_type": "student"
}
from quizzo.serializers.id_name import IdNameType
student_type_obj = IdNameType(**student_obj)
from quizzo.serializers.id_name import IdNameSerializer
student_serializer = IdNameSerializer(student_type_obj)
return Response(student_serializer.data)
def quiz_statistics(request, username):
from quizzo.serializers.quiz_title import QuizTitleSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(QuizTitleSerializer, request.data)
from quizzo.models.option import Option
from quizzo.models.student_quiz import StudentQuiz
from quizzo.models.student import Student
from quizzo.models.quiz import Quiz
quiz_obj = StudentQuiz.objects.get(
student=Student.objects.get(username=username),
quiz_id=Quiz.objects.get(title=request_data.title).id)
user_questions = quiz_obj.user_options.all()
questions_list = []
for obj in user_questions:
question_id = obj.question.id
question_content = obj.question.question_content
user_answer = obj.attempted_answer
user_answer_id = obj.attempted_id
question_type = obj.question.type
correct_answer_id = obj.question.answer_id
correct_answer = Option.objects.get(id=obj.question.answer_id).content
options_list = []
for each_obj in obj.question.options.all():
temp = {"option_id": each_obj.id, "option": each_obj.content}
options_list.append(temp)
question_temp = {
"question": question_content,
"question_id": question_id,
"user_answer_id": user_answer_id,
"user_answer": user_answer,
"question_type": question_type,
"options": options_list,
"correct_answer": correct_answer,
"correct_answer_id": correct_answer_id
}
questions_list.append((question_temp))
total = len(questions_list)
result = {"total": total, "questions_list": questions_list}
from quizzo.serializers.quiz_reference_list import QuizReferenceListType
result_obj = QuizReferenceListType(**result)
from quizzo.serializers.quiz_reference_list import QuizReferenceListSerializer
result = QuizReferenceListSerializer(result_obj)
return Response(result.data)
def student_login(request):
from quizzo.serializers.login import LoginSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(LoginSerializer, request.data)
from quizzo.models.student import Student
student = Student.login(request_data)
student_obj = {
"id": student.id,
"username": student.user,
"user_type": "student"
}
from quizzo.serializers.id_name import IdNameType
student_id = IdNameType(**student_obj)
from quizzo.serializers.id_name import IdNameSerializer
student_id_serializer = IdNameSerializer(student_id)
return Response(student_id_serializer.data)
def get_user_info(request):
from quizzo.serializers.id_name import IdNameSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(IdNameSerializer, request.data)
from quizzo.models.student import Student
from quizzo.models.teacher import Teacher
if request_data.user_type == "student":
obj = Student.get_student_details(id=request_data.id)
else:
obj = Teacher.get_teacher_details(id=request_data.id)
from quizzo.serializers.profile import ProfileType
students_type_obj = ProfileType(**obj)
from quizzo.serializers.profile import ProfileSerializer
result = ProfileSerializer(students_type_obj)
return Response(result.data)
def get_leaderboard(request):
from quizzo.serializers.limit_offset_search import LimitOffsetSearchSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(LimitOffsetSearchSerializer, request.data)
from quizzo.utils.constants import LeaderBoardSearchTypes
if request_data.filter_by == LeaderBoardSearchTypes.college.value:
student_query_set = Student.objects.filter(
college__icontains=request_data.search)
elif request_data.filter_by == LeaderBoardSearchTypes.city.value:
student_query_set = Student.objects.filter(
city__icontains=request_data.search)
else:
student_query_set = Student.objects.all()
final_result_list = list()
print("after stundet")
from django.db.models import Sum
for obj in student_query_set:
q = obj.studentquiz_set.aggregate(total_marks=Sum("marks_obtained"))
temp = {
"username": obj.username,
"college": obj.college,
"points": q['total_marks']
}
final_result_list.append(temp)
final_result_list[:] = [
d for d in final_result_list if d.get('points') is not None
]
final_result_list = sorted(final_result_list,
key=lambda k: k['points'],
reverse=True)
students_obj = {
"total":
len(final_result_list),
"students":
final_result_list[request_data.offset:request_data.offset +
request_data.limit]
}
from quizzo.serializers.leaderboard_list_response import LeaderboardResponseListType
students_type_obj = LeaderboardResponseListType(**students_obj)
from quizzo.serializers.leaderboard_list_response import LeaderboardListResponseSerializer
result = LeaderboardListResponseSerializer(students_type_obj)
return Response(result.data)
def teacher_signup(request):
from quizzo.serializers.teacher_profile import TeacherProfileSerializer
from quizzo.utils.deserialize import deserialize
teacher_obj = deserialize(TeacherProfileSerializer, request.data)
from quizzo.models.teacher import Teacher
teacher = Teacher.sign_up(teacher_obj)
teacher_obj = {
"id": teacher.id,
"username": teacher.user,
"user_type": "teacher"
}
from quizzo.serializers.id_name import IdNameType
teacher_type_obj = IdNameType(**teacher_obj)
from quizzo.serializers.id_name import IdNameSerializer
teacher_serializer = IdNameSerializer(teacher_type_obj)
return Response(teacher_serializer.data)
def teacher_login(request):
from quizzo.serializers.login import LoginSerializer
from quizzo.utils.deserialize import deserialize
request_data = deserialize(LoginSerializer, request.data)
from quizzo.models.teacher import Teacher
teacher = Teacher.login(request_data)
teacher_obj = {
"id": teacher.id,
"username": teacher.user,
"user_type": "teacher"
}
from quizzo.serializers.id_name import IdNameType
teacher_id = IdNameType(**teacher_obj)
from quizzo.serializers.id_name import IdNameSerializer
teacher_id_serializer = IdNameSerializer(teacher_id)
return Response(teacher_id_serializer.data)
