def get_subcategory(request, userid, categoryid, format = None):
"""
If all_subcategories = True then return all else return subcategory not have any category.
Either get all subcategories under each quiz and category or get subcategories under specifc quiz and category.
"""
if verify_user_hash(userid, request.query_params.get('hash')):
logger.info('under quiz.get_subcategory')
serializer = None
subcategories = []
if categoryid == 'all':
if checkIfTrue(request.query_params.get('all_subcategories')):
subcategories = SubCategory.objects.filter(user = userid)
else:
subcategories = SubCategory.objects.filter(user = userid, category = None)
serializer = SubCategorySerializer(subcategories, many = True)
elif categoryid.isnumeric():
try:
subcategories = SubCategory.objects.filter(category = categoryid, user = userid)
serializer = SubCategorySerializer(subcategories, many = True)
except SubCategory.DoesNotExist as e:
logger.error('under quiz.get_subcategory '+str(e.args))
return Response({'errors': 'Sub-categories not found'}, status = status.HTTP_404_NOT_FOUND)
else:
logger.error('under quiz.get_subcategory wrong hash')
return Response({'errors': 'Wrong URL passed.'}, status = status.HTTP_404_NOT_FOUND)
return Response(serializer.data, status = status.HTTP_200_OK)
logger.error('under quiz.get_subcategory wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_comprehension_question(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under comprehension.create_comprehension_question')
data = {}
correctoption = request.data.get('correctoption', None)
if correctoption:
options_dict = ast.literal_eval(
(request.data.get('optioncontent')))
data['options_data'] = options_dict if len(
options_dict) <= MAX_OPTIONS else options_dict[:MAX_OPTIONS]
serializer = ComprehensionQuestionSerializer(data=request.data)
if serializer.is_valid():
return save_comprehension_question(
request, serializer, data['options_data'],
request.data['correctoption'],
request.data.get('comprehension'))
else:
logger.error(
'under comprehension.create_comprehension_question ' +
str(serializer.errors))
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
logger.error(
'under comprehension.create_comprehension_question correct option not provided'
+ str(serializer.errors))
return Response(
{'optionerrors': 'Correct answer must be provided.'},
status=status.HTTP_400_BAD_REQUEST)
logger.error(
'under comprehension.create_comprehension_question wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def get_quiz(request, userid, quizid ,format = None):
"""
Get a quiz.
"""
if verify_user_hash(userid, request.query_params.get('hash')):
logger.info('under quiz.get_quiz '+str(quizid))
if quizid == 'all':
try:
quiz_list = Quiz.objects.filter(user=userid).order_by('id')
serializer = QuizSerializer(quiz_list, many = True)
except Quiz.DoesNotExist as e:
logger.error('under quiz.get_quiz(all) - no quizzes '+str(e.args))
return Response({'errors': 'Quizzes not found'}, status=status.HTTP_404_NOT_FOUND)
elif quizid.isnumeric():
try:
quiz = Quiz.objects.get(id = quizid, user = userid)
except Quiz.DoesNotExist as e:
logger.error('under quiz.get_quiz '+str(e.args))
return Response({'errors': 'Quiz not found'}, status = status.HTTP_404_NOT_FOUND)
serializer = QuizSerializer(quiz)
# serializer.data['quiz_key'] = quiz.quiz_key
else:
logger.error('under quiz.get_quiz wrong url passed')
return Response({'errors': 'Wrong URL passed.'}, status=status.HTTP_404_NOT_FOUND)
return Response(serializer.data, status = status.HTTP_200_OK)
logger.error('under quiz.get_quiz wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def comprehension_answers_operations(request, comprehension_question_id):
if verify_user_hash(request.query_params.get('user'), request.query_params.get('hash')):
logger.info('under comprehension.comprehension_answers_operations')
try:
data = {}
comprehension_question = ComprehensionQuestion.objects.get(id = comprehension_question_id)
comprehension_answers = ComprehensionAnswer.objects.filter(question = comprehension_question_id)
except ComprehensionQuestion.DoesNotExist as e:
logger.error('under comprehension.comprehension_answers_operations '+str(e.args))
return Response({'errors': 'Comprehension question not found.'}, status=status.HTTP_404_NOT_FOUND)
data['content'] = comprehension_question.content
if request.method == 'GET':
comprehension_answers_serializer = ComprehensionAnswerSerializer(comprehension_answers, many = True)
data['options'] = comprehension_answers_serializer.data
return Response(data, status = status.HTTP_200_OK)
elif request.method == 'PUT':
optionsContent = dict(request.data.get('optionsContent'))
data['options'] = []
for answer in comprehension_answers:
d = { 'correct' : False, 'content' : optionsContent[str(answer.id)], 'question' : comprehension_question.id }
if request.data.get('correctOption') == str(answer.id):
d['correct'] = True
serializer = ComprehensionAnswerSerializer(answer,data=d)
if serializer.is_valid():
serializer.save()
data['options'].append(serializer.data)
else:
logger.error('under comprehension.comprehension_answers_operations '+str(serializer.errors))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(data, status = status.HTTP_200_OK)
logger.error('under comprehension.comprehension_answers_operations wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def category_list(request, user_id, category_id, format = None):
"""
Either get a single quiz or all.
"""
if verify_user_hash(user_id, request.query_params.get('hash')):
logger.info('under quiz.category_list '+str(category_id))
if category_id == 'all':
categories = Category.objects.filter(user = user_id)
if categories:
serializer = CategorySerializer(categories, many = True)
else:
logger.error('under quiz.category_list no categories found')
return Response({'errors': 'Categories not found'}, status=status.HTTP_404_NOT_FOUND)
else:
if category_id.isnumeric():
try:
category = Category.objects.get(id = category_id, user=user_id)
serializer = CategorySerializer(category, many = False)
except Category.DoesNotExist as e:
logger.error('under quiz.category_list '+str(e.args))
return Response({'errors': 'Category not found'}, status=status.HTTP_404_NOT_FOUND)
else:
logger.error('under quiz.category_list wrong hash')
return Response({'errors': 'Wrong URL passed.'}, status=status.HTTP_404_NOT_FOUND)
return Response(serializer.data, status = status.HTTP_200_OK)
logger.error('under quiz.category_list wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def download_xls_file(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.download_xls_file')
que_type = request.data.get('que_type')
if request.data.get('sub_cat_info'):
sub_category_id = request.data.get('sub_cat_info').split('>>')[0]
sub_category_name = request.data.get('sub_cat_info').split('>>')[1]
else:
logger.error('under quiz.download_xls_file error no subcategory selected')
return Response({'errors': 'Select a sub-category first.'}, status=status.HTTP_400_BAD_REQUEST)
try:
sub_category = SubCategory.objects.get(pk = sub_category_id, sub_category_name = sub_category_name)
except SubCategory.DoesNotExist as e:
logger.error('under quiz.download_xls_file '+str(e.args))
return Response({'errors': 'Sub-category does not exist.'}, status=status.HTTP_404_NOT_FOUND)
data = OrderedDict()
if que_type == 'mcq':
data.update({"Sheet 1": [MCQ_FILE_COLS,["", sub_category_name]]})
elif que_type == 'objective':
data.update({"Sheet 1": [OBJECTIVE_FILE_COLS,[sub_category_name]]})
save_data(sub_category_name+"_"+que_type+"_file.xls", data)
from django.http import FileResponse
response = FileResponse(open(sub_category_name+"_"+que_type+"_file.xls", 'rb'))
try:
import os
os.remove(sub_category_name+"_"+que_type+"_file.xls")
except OSError as ose:
logger.error('under quiz.download_xls_file '+str(ose.args))
return response
logger.error('under quiz.download_xls_file wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_mcq(request, xls_read_data=None):
"""
Create a MCQuestion.
"""
if xls_read_data:
logger.info('under mcq.create_mcq xls_read_data = some value')
last_resp = []
for data in xls_read_data:
data['que_type'] = 'mcq'
serializer = MCQuestionSerializer(data=data)
options_data = data.get('optioncontent', None)
correct_option = data.get('correctoption', None)
correct_option = int(float(correct_option))
last_resp.append(
save_mcq_question(request, serializer, options_data,
correct_option))
else:
if last_resp[::-1][0].status_code == 200:
try:
import os
os.remove('mcq_read_now.xls')
except OSError as ose:
logger.error('under mcq.create_mcq ' + str(ose.args))
return Response({
'msg': 'All questions upload successfully.',
},
status=last_resp[::-1][0].status_code)
else:
logger.error('under mcq.create_mcq not uploaded successfully')
return Response(
{
'msg': 'All questions not uploaded successfully.',
},
status=last_resp[::-1][0].status_code)
else:
logger.info('under mcq.create_mcq xls_read_data = no value')
if verify_user_hash(request.data.get('user'),
request.data.get('hash')):
if request.data.get('correctoption'):
data = {}
options_dict = ast.literal_eval(
(request.data.get('optioncontent')))
data['options_data'] = options_dict if len(
options_dict
) <= MAX_OPTIONS else options_dict[:MAX_OPTIONS]
serializer = MCQuestionSerializer(data=request.data)
return save_mcq_question(request, serializer,
data['options_data'],
request.data.get('correctoption'))
else:
logger.error(
'under mcq.create_mcq correct option not provided')
return Response(
{'optionerrors': 'Correct answer must be provided.'},
status=status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.create_mcq wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def create_subcategory(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.create_subcategory')
serializer = SubCategorySerializer(data = request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_200_OK)
logger.error('under quiz.create_subcategory '+str(e.args))
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.create_subcategory wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def get_comprehension(request, comprehension_id):
if verify_user_hash(request.query_params.get('user'), request.query_params.get('hash')):
logger.info('under comprehension.get_comprehension')
try:
comprehension = Comprehension.objects.get(id = comprehension_id)
return Response({ 'id': comprehension.id, 'content': comprehension.question.content, 'sub_category': comprehension.question.sub_category.sub_category_name, 'heading': comprehension.heading, 'figure':str(comprehension.question.figure) }, status = status.HTTP_200_OK)
except Comprehension.DoesNotExist as e:
logger.error('comprehension.get_comprehension '+str(e.args))
return Response({ 'errors' : "Unable to find comprehension."}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.get_comprehension wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def get_comprehension_questions(request, comprehension_id):
if verify_user_hash(request.query_params.get('user'), request.query_params.get('hash')):
logger.info('under comprehension.get_comprehension_questions')
try:
comprehension = Comprehension.objects.get(id = comprehension_id)
data = get_comprehension_questions_format(comprehension)
return Response(data, status = status.HTTP_200_OK)
except Comprehension.DoesNotExist as e:
logger.error('under comprehension.get_comprehension_questions '+str(e.args))
return Response({ 'errors' : "Unable to find comprehension."}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.get_comprehension_questions wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def upload_private_access_xls(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.upload_private_access_xls')
try:
file = request.data.get('file_data')
quiz_id = request.data.get('quiz_id')
if file and quiz_id and save_test_private_access_from_xls(file, quiz_id):
return Response({'msg': 'Private access user create successfully'}, status=status.HTTP_200_OK)
except Exception as e:
logger.error('under quiz.upload_private_access_xls '+str(e.args))
return Response({'errors': 'Invalid data here.'}, status=status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.upload_private_access_xls wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def mark_quiz_public(request, userid, quizid):
if verify_user_hash(userid, request.query_params.get('hash')):
logger.info('under quiz.mark_quiz_public')
try:
quiz = Quiz.objects.get(id = quizid, user = userid)
quiz.allow_public_access = not quiz.allow_public_access
quiz.save()
return Response({ 'title':quiz.title, "allow_public_access":quiz.allow_public_access, 'id':quiz.id }, status = status.HTTP_200_OK)
except Quiz.DoesNotExist as e:
logger.error('under quiz.mark_quiz_public '+str(e.args))
return Response({'errors': 'Quiz not found'}, status = status.HTTP_404_NOT_FOUND)
logger.error('under quiz.mark_quiz_public wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def answers_operations(request, userid, question_id):
"""
Get answers to a question or update.
"""
if verify_user_hash(userid, request.query_params.get('hash')):
logger.info('under quiz.answers_operations '+str(request.method))
try:
result = {}
question = Question.objects.get(pk = question_id)
if request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[0][0]:
answers = Answer.objects.filter(question = question)
elif request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[1][0]:
answer = ObjectiveQuestion.objects.get(pk=question)
except Question.DoesNotExist:
logger.error('under quiz.answers_operations '+str(e.args))
return Response({'errors': 'Question not found'}, status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
if request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[0][0]:
answerserializer = AnswerSerializer(answers, many = True)
result['options'] = answerserializer.data
elif request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[1][0]:
result['correct'] = answer.correct
result['content'] = question.content
result['sub_category_name'] = question.sub_category.sub_category_name
result['sub_category'] = question.sub_category.id
return Response({ 'answers' : result }, status = status.HTTP_200_OK)
elif request.method == 'PUT':
if request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[0][0]:
optionsContent = dict(request.data.get('optionsContent'))
result['options'] = []
result['content'] = question.content
for answer in answers:
d = { 'correct' : False, 'content' : optionsContent[str(answer.id)], 'question' : question.id }
if request.data.get('correctOption') == str(answer.id):
d['correct'] = True
serializer = AnswerSerializer(answer,data=d)
if serializer.is_valid():
serializer.save()
result['options'].append(serializer.data)
elif request.query_params['que_type'] == QUESTION_TYPE_OPTIONS[1][0]:
serializer = ObjectiveQuestionSerializer(answer, request.data)
if serializer.is_valid():
serializer.save()
result['options'].append(serializer.data)
else:
logger.error('under quiz.answers_operations '+str(serializer.errors))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(result, status = status.HTTP_200_OK)
logger.error('under quiz.answers_operations wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def comprehension_question_operations(request, comprehension_question_id):
user = request.query_params.get('user')
_hash = request.query_params.get('hash')
if not (user and _hash):
user = request.data.get('user')
_hash = request.data.get('hash')
if verify_user_hash(user, _hash):
logger.info('under comprehension.comprehension_question_operations '+str(request.method))
try:
comprehension_question = ComprehensionQuestion.objects.get(id = comprehension_question_id)
except ComprehensionQuestion.DoesNotExist as e:
logger.error('under comprehension.comprehension_question_operations '+str(e.args))
return Response({'errors': 'Comprehension question not found.'}, status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
comprehension_question_serializer = ComprehensionQuestionSerializer(comprehension_question, many = False)
return Response(dict(comprehension_question_serializer.data), status = status.HTTP_200_OK)
elif request.method == 'DELETE':
if comprehension_question.figure:
try:
os.remove(str(comprehension_question.figure))
except OSError as oes:
logger.error('under comprehension.comprehension_question_operations '+oes.args)
question = comprehension_question.comprehension.question
question.ideal_time -= old_ideal_time + comprehension_question.ideal_time
question.save()
comprehension_question.delete()
return Response({'deletedComprehensionQuestionsId': comprehension_question_id}, status = status.HTTP_200_OK)
elif request.method == 'PUT':
question = comprehension_question.comprehension.question
old_ideal_time = question.ideal_time - comprehension_question.ideal_time
question.ideal_time = old_ideal_time + int(request.data.get('ideal_time'))
question.save()
if request.data.get('figure', None):
if comprehension_question.figure:
try:
os.remove(str(comprehension_question.figure))
except OSError as oes:
logger.error('under comprehension.comprehension_question_operations '+oes.args)
serializer = ComprehensionQuestionSerializer(comprehension_question, data = request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_200_OK)
logger.error('under comprehension.comprehension_question_operations '+str(serializer.errors))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.comprehension_question_operations wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def comprehension_answers_operations(request, comprehension_question_id):
if verify_user_hash(request.query_params.get('user'),
request.query_params.get('hash')):
logger.info('under comprehension.comprehension_answers_operations')
try:
data = {}
comprehension_question = ComprehensionQuestion.objects.get(
id=comprehension_question_id)
comprehension_answers = ComprehensionAnswer.objects.filter(
question=comprehension_question_id)
except ComprehensionQuestion.DoesNotExist as e:
logger.error(
'under comprehension.comprehension_answers_operations ' +
str(e.args))
return Response({'errors': 'Comprehension question not found.'},
status=status.HTTP_404_NOT_FOUND)
data['content'] = comprehension_question.content
if request.method == 'GET':
comprehension_answers_serializer = ComprehensionAnswerSerializer(
comprehension_answers, many=True)
data['options'] = comprehension_answers_serializer.data
return Response(data, status=status.HTTP_200_OK)
elif request.method == 'PUT':
optionsContent = dict(request.data.get('optionsContent'))
data['options'] = []
for answer in comprehension_answers:
d = {
'correct': False,
'content': optionsContent[str(answer.id)],
'question': comprehension_question.id
}
if request.data.get('correctOption') == str(answer.id):
d['correct'] = True
serializer = ComprehensionAnswerSerializer(answer, data=d)
if serializer.is_valid():
serializer.save()
data['options'].append(serializer.data)
else:
logger.error(
'under comprehension.comprehension_answers_operations '
+ str(serializer.errors))
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(data, status=status.HTTP_200_OK)
logger.error(
'under comprehension.comprehension_answers_operations wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def get_comprehension_questions(request, comprehension_id):
if verify_user_hash(request.query_params.get('user'),
request.query_params.get('hash')):
logger.info('under comprehension.get_comprehension_questions')
try:
comprehension = Comprehension.objects.get(id=comprehension_id)
data = get_comprehension_questions_format(comprehension)
return Response(data, status=status.HTTP_200_OK)
except Comprehension.DoesNotExist as e:
logger.error('under comprehension.get_comprehension_questions ' +
str(e.args))
return Response({'errors': "Unable to find comprehension."},
status=status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.get_comprehension_questions wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def delete_quiz(request, user_id, quiz_id, format = None):
"""
Delete a quiz.
"""
print user_id,'----'
if verify_user_hash(user_id, request.query_params.get('hash')):
logger.info('under quiz.delete_quiz')
try:
quiz = Quiz.objects.get(id = quiz_id, user = user_id)
quiz.delete()
return Response({}, status = status.HTTP_200_OK)
except Quiz.DoesNotExist as e:
logger.error('under quiz.delete_quiz '+str(e.args))
return Response({'errors': 'Quiz not found'}, status = status.HTTP_404_NOT_FOUND)
logger.error('under quiz.delete_quiz wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_objective(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
try:
if BLANK_HTML in request.data['content']:
serializer = ObjectiveQuestionSerializer(data = request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_200_OK)
else:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
else:
return Response({ "content" : ["No blank field present.Please add one."] } , status = status.HTTP_400_BAD_REQUEST)
except Exception as e:
print e.args
return Response({ "errors" : "Unable to create this question. Server error." }, status = status.HTTP_400_BAD_REQUEST)
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def save_XLS_to_OBJECTIVE(request):
# _level_dict = {'medium': 'M', 'easy': 'E', 'hard': 'H'}
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
print '----'
f = request.data['figure']
with open('mcq_read_now.xls', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
data = get_data("mcq_read_now.xls")
total_entries = len(data)
temp_data = data[0]
# Check if columns of xls file provided are not tampered/changed.
if temp_data == OBJECTIVE_FILE_COLS:
try:
# This dict contains raw-way data with specified keys from temp_data or xls keys
# data_dict = collections.OrderedDict({})
correct_serializers_list = []
d = {}
for i in data[1:]:
if BLANK_HTML in i[4]:
if not d.has_key(i[0]):
try:
d[i[0]] = SubCategory.objects.get(sub_category_name=i[0])
except SubCategory.DoesNotExist as e:
return Response({ "errors" : "Wrong sub-category specified." } , status = status.HTTP_400_BAD_REQUEST)
temp_dict = { 'sub_category':d[i[0]].id, 'level':i[1], 'explanation':'', 'correct':'', 'content':i[4], 'que_type': 'objective' }
temp_dict['explanation'] = str(i[2])
temp_dict['correct'] = str(i[3])
serializer = ObjectiveQuestionSerializer(data = temp_dict)
if serializer.is_valid():
correct_serializers_list.append(serializer)
else:
return Response({ "errors" : "There is some error while saving your questions. Correct the format." } , status = status.HTTP_400_BAD_REQUEST)
else:
return Response({ "errors" : "There is some error while saving your questions. Correct the format." } , status = status.HTTP_400_BAD_REQUEST)
if len(correct_serializers_list) == total_entries - 1:
for serializer in correct_serializers_list:
serializer.save()
return Response({}, status = status.HTTP_200_OK)
except Exception as e:
print e.args
return Response({ "errors" : "There is some error while saving your questions. Correct the format." } , status = status.HTTP_400_BAD_REQUEST)
else:
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_comprehension_question(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under comprehension.create_comprehension_question')
data = {}
correctoption= request.data.get('correctoption', None)
if correctoption:
options_dict = ast.literal_eval((request.data.get('optioncontent')))
data['options_data'] = options_dict if len(options_dict) <= MAX_OPTIONS else options_dict[:MAX_OPTIONS]
serializer = ComprehensionQuestionSerializer(data = request.data)
if serializer.is_valid():
return save_comprehension_question(request, serializer, data['options_data'], request.data['correctoption'], request.data.get('comprehension'))
else:
logger.error('under comprehension.create_comprehension_question '+str(serializer.errors))
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
else:
logger.error('under comprehension.create_comprehension_question correct option not provided'+str(serializer.errors))
return Response({'optionerrors' : 'Correct answer must be provided.'}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.create_comprehension_question wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def all_questions_under_subcategory(request, user_id, subcategory_id):
"""
Either get all questions under specific subcategory.
If questionFormat is True --> Then we also uses answers and options for each question in JSON.
Otherwise, we ignore them.
"""
if verify_user_hash(user_id, request.query_params.get('hash')):
logger.info('under quiz.all_questions_under_subcategory')
try:
if not checkIfTrue(request.query_params.get('questionFormat')):
quizzes = get_questions_format(user_id, subcategory_id, True)
else:
quizzes = get_questions_format(user_id, subcategory_id)
return Response(quizzes, status = status.HTTP_200_OK)
except SubCategory.DoesNotExist as e:
logger.error('under quiz.all_questions_under_subcategory '+str(e.args))
return Response({'errors': 'Questions not found'}, status = status.HTTP_404_NOT_FOUND)
logger.error('under quiz.all_questions_under_subcategory wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def update_quiz(request, userid, quizid ,format = None):
"""
Update a quiz.
"""
if verify_user_hash(userid, request.data.get('hash')):
logger.info('under quiz.update_quiz')
try:
quiz = Quiz.objects.get(id = quizid, user = userid)
except Quiz.DoesNotExist as e:
logger.error('under quiz.update_quiz '+str(e.args))
return Response({'errors': 'Quiz not found'}, status = status.HTTP_404_NOT_FOUND)
serializer = QuizSerializer(quiz, data = request.data)
if serializer.is_valid():
serializer.save()
return Response({ 'updatedQuiz' : serializer.data }, status = status.HTTP_200_OK)
else:
logger.error('under quiz.update_quiz '+str(serializer.errors))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.get_quiz wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_category(request):
"""
Create a category
"""
# print request.data
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.create_category')
try:
serializer = CategorySerializer(data = request.data)
# print serializer
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_200_OK)
else:
logger.error('under quiz.create_category '+str(serializer.errors))
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error('under quiz.create_category error '+str(e.args))
return Response({'errors' : 'Cannot create the category.'}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.create_category wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_mcq(request, xls_read_data = None):
"""
Create a MCQuestion.
"""
if xls_read_data:
logger.info('under mcq.create_mcq xls_read_data = some value')
last_resp = []
for data in xls_read_data:
data['que_type'] = 'mcq'
serializer = MCQuestionSerializer(data = data)
options_data = data.get('optioncontent', None)
correct_option = data.get('correctoption', None)
correct_option = int(float(correct_option))
last_resp.append(save_mcq_question(request, serializer, options_data, correct_option))
else:
if last_resp[::-1][0].status_code == 200:
try:
import os
os.remove('mcq_read_now.xls')
except OSError as ose:
logger.error('under mcq.create_mcq '+str(ose.args))
return Response( {'msg': 'All questions upload successfully.',} ,status = last_resp[::-1][0].status_code)
else:
logger.error('under mcq.create_mcq not uploaded successfully')
return Response( {'msg': 'All questions not uploaded successfully.',} ,status = last_resp[::-1][0].status_code)
else:
logger.info('under mcq.create_mcq xls_read_data = no value')
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
if request.data.get('correctoption'):
data = {}
options_dict = ast.literal_eval((request.data.get('optioncontent')))
data['options_data'] = options_dict if len(options_dict) <= MAX_OPTIONS else options_dict[:MAX_OPTIONS]
serializer = MCQuestionSerializer(data = request.data)
return save_mcq_question(request, serializer, data['options_data'], request.data.get('correctoption'))
else:
logger.error('under mcq.create_mcq correct option not provided')
return Response({'optionerrors' : 'Correct answer must be provided.'}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.create_mcq wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def download_access_xls_file(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.download_access_xls_file')
test_id = request.data.get('test_id')
if test_id:
quiz = Quiz.objects.get(pk = test_id)
else:
logger.error('under quiz.download_access_xls_file error invalid data')
return Response({'errors': 'Invalid data here.'}, status=status.HTTP_400_BAD_REQUEST)
data = {"Sheet 1": [QUIZ_ACCESS_FILE_COLS]}
save_data(quiz.title+"_file.xls", data)
from django.http import FileResponse
response = FileResponse(open(quiz.title+"_file.xls", 'rb'))
try:
import os
os.remove(quiz.title+"access_file.xls")
except OSError as ose:
logger.error('under quiz.download_access_xls_file '+str(ose.args))
return response
logger.error('under quiz.download_access_xls_file wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_objective(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
try:
if BLANK_HTML in request.data['content']:
serializer = ObjectiveQuestionSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(
{"content": ["No blank field present.Please add one."]},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
print e.args
return Response(
{"errors": "Unable to create this question. Server error."},
status=status.HTTP_400_BAD_REQUEST)
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def create_comprehension(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under comprehension.create_comprehension')
try:
question_serializer = QuestionSerializer(data = request.data)
if question_serializer.is_valid():
question_serializer.save()
comprehension_serializer = ComprehensionSerializer(data = {'question': question_serializer.data['id'], 'heading': request.data['heading']})
if comprehension_serializer.is_valid():
comprehension_serializer.save()
return Response(comprehension_serializer.data['id'], status = status.HTTP_200_OK)
else:
logger.error('comprehension.create_comprehension comprehension_serializer '+str(comprehension_serializer.errors))
return Response({ 'errors' : comprehension_serializer.errors }, status = status.HTTP_400_BAD_REQUEST)
else:
logger.error('comprehension.create_comprehension question_serializer '+str(question_serializer.errors))
return Response({ 'errors' : question_serializer.errors }, status = status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error('comprehension.create_comprehension '+str(e.args))
return Response({ 'errors' : "Cannot add this question."}, status = status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.create_comprehension wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def get_comprehension(request, comprehension_id):
if verify_user_hash(request.query_params.get('user'),
request.query_params.get('hash')):
logger.info('under comprehension.get_comprehension')
try:
comprehension = Comprehension.objects.get(id=comprehension_id)
return Response(
{
'id': comprehension.id,
'content': comprehension.question.content,
'sub_category':
comprehension.question.sub_category.sub_category_name,
'heading': comprehension.heading,
'figure': str(comprehension.question.figure)
},
status=status.HTTP_200_OK)
except Comprehension.DoesNotExist as e:
logger.error('comprehension.get_comprehension ' + str(e.args))
return Response({'errors': "Unable to find comprehension."},
status=status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.get_comprehension wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def create_quiz(request, format = None):
"""
Create a new quiz.
"""
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under quiz.create_quiz')
serializer = QuizSerializer(data = request.data)
if serializer.is_valid():
quiz = serializer.save()
data = serializer.data
data['allow_public_access'] = quiz.allow_public_access
data['id'] = quiz.id
data['quiz_key'] = quiz.quiz_key
data['show_result_on_completion'] = quiz.show_result_on_completion
data['total_duration'] = quiz.total_duration
data['total_marks'] = quiz.total_marks
data['total_questions'] = quiz.total_questions
data['total_sections'] = quiz.total_sections
data['url'] = quiz.url
return Response(data, status = status.HTTP_200_OK)
logger.error('under quiz.create_quiz '+str(serializer.errors))
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
logger.error('under quiz.mark_quiz_public wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def create_comprehension(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under comprehension.create_comprehension')
try:
question_serializer = QuestionSerializer(data=request.data)
if question_serializer.is_valid():
question_serializer.save()
comprehension_serializer = ComprehensionSerializer(
data={
'question': question_serializer.data['id'],
'heading': request.data['heading']
})
if comprehension_serializer.is_valid():
comprehension_serializer.save()
return Response(comprehension_serializer.data['id'],
status=status.HTTP_200_OK)
else:
logger.error(
'comprehension.create_comprehension comprehension_serializer '
+ str(comprehension_serializer.errors))
return Response(
{'errors': comprehension_serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
else:
logger.error(
'comprehension.create_comprehension question_serializer ' +
str(question_serializer.errors))
return Response({'errors': question_serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error('comprehension.create_comprehension ' + str(e.args))
return Response({'errors': "Cannot add this question."},
status=status.HTTP_400_BAD_REQUEST)
logger.error('under comprehension.create_comprehension wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def save_XLS_to_MCQ(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under mcq.save_XLS_to_MCQ')
'''
{u'sub_category': u'5', u'answer_order': u'random', u'explanation': u'eeeeeeeeee',
u'level': u'easy', u'correctoption': u'1', u'content': u'eeeeeeeeee',
u'optioncontent': {u'1': u'eeeeeeeeee', u'2': u'eeeeeeeeeee'}}
'''
# _level_dict = {'medium': 'M', 'easy': 'E', 'hard': 'H'}
f = request.data['figure']
with open('mcq_read_now.xls', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
data = get_data("mcq_read_now.xls")
total_entries = len(data)
temp_data = data[0]
_dict_mcq_keys = ['category', 'sub_category', 'que_type', 'level', 'explanation', 'option_display_order_random', 'correctoption', 'content', 'ideal_time', 'problem_type']
# This dict contains raw-way data with specified keys from temp_data or xls keys
data_dict = OrderedDict({})
# _quiz_id = None
category_dict = {}
sub_category_dict = {}
option_check = ['option1', 'option2', 'option3', 'option4', 'option5', 'option6']
data_list = []
for row_name in _dict_mcq_keys:
data_dict.update({row_name : ''})
# Create empty value dict. for each mcq entry ..
for i, list_data in enumerate(data[1:]):
data_list.append(data_dict.copy())
optioncontent = {}
for j, mcq_data in enumerate(list_data):
mcq_data = ascii_safe(mcq_data)
if temp_data[j] == 'correctoption':
data_list[i][temp_data[j]] = str(mcq_data)
# Check if row is for option then create a dict_ of options and add it on optioncontent ....
elif temp_data[j] in option_check:
if mcq_data:
optioncontent[option_check.index(temp_data[j])+1] = str(mcq_data)
data_list[i]['optioncontent'] = optioncontent
# data_list[i]['optioncontent'] = optioncontent[option_check.index(temp_data[j])] = str(mcq_data)
#Check first for // key(category name) value(category id) // pair in dict. if not exist then call query.
elif temp_data[j] == 'category':
if category_dict.has_key(mcq_data):
category_id = category_dict.get(mcq_data)
else:
try:
category_id = Category.objects.get(category_name = mcq_data).id
except Exception as e:
logger.error('under mcq.save_XLS_to_MCQ '+str(e.args))
category_id = None
category_dict[mcq_data] = category_id
data_list[i][temp_data[j]] = str(category_id)
#Check first for // key(sub_category name) value(sub_category id) // pair in dict. if not exist then call query.
elif temp_data[j] == 'sub_category':
try:
if sub_category_dict.has_key(mcq_data):
sub_category_id = sub_category_dict.get(mcq_data)
else:
sub_category_id = SubCategory.objects.get(sub_category_name = mcq_data).id
sub_category_dict[mcq_data] = sub_category_id
data_list[i][temp_data[j]] = str(sub_category_id)
except SubCategory.DoesNotExist as e:
logger.error('under mcq.save_XLS_to_MCQ wrong subcategory specified '+str(e.args))
return Response({ "errors" : "Wrong sub-category specified." } , status = status.HTTP_400_BAD_REQUEST)
else:
data_list[i][temp_data[j]] = str(mcq_data)
# DONE ........
return create_mcq(request, data_list)
# return Response({'msg' : data_list}, status = status.HTTP_200_OK)
else:
logger.error('under quiz.save_XLS_to_MCQ wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def save_XLS_to_OBJECTIVE(request):
# _level_dict = {'medium': 'M', 'easy': 'E', 'hard': 'H'}
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
print '----'
f = request.data['figure']
with open('mcq_read_now.xls', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
data = get_data("mcq_read_now.xls")
total_entries = len(data)
temp_data = data[0]
# Check if columns of xls file provided are not tampered/changed.
if temp_data == OBJECTIVE_FILE_COLS:
try:
# This dict contains raw-way data with specified keys from temp_data or xls keys
# data_dict = collections.OrderedDict({})
correct_serializers_list = []
d = {}
for i in data[1:]:
if BLANK_HTML in i[4]:
if not d.has_key(i[0]):
try:
d[i[0]] = SubCategory.objects.get(
sub_category_name=i[0])
except SubCategory.DoesNotExist as e:
return Response(
{
"errors":
"Wrong sub-category specified."
},
status=status.HTTP_400_BAD_REQUEST)
temp_dict = {
'sub_category': d[i[0]].id,
'level': i[1],
'explanation': '',
'correct': '',
'content': i[4],
'que_type': 'objective'
}
temp_dict['explanation'] = str(i[2])
temp_dict['correct'] = str(i[3])
serializer = ObjectiveQuestionSerializer(
data=temp_dict)
if serializer.is_valid():
correct_serializers_list.append(serializer)
else:
return Response(
{
"errors":
"There is some error while saving your questions. Correct the format."
},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(
{
"errors":
"There is some error while saving your questions. Correct the format."
},
status=status.HTTP_400_BAD_REQUEST)
if len(correct_serializers_list) == total_entries - 1:
for serializer in correct_serializers_list:
serializer.save()
return Response({}, status=status.HTTP_200_OK)
except Exception as e:
print e.args
return Response(
{
"errors":
"There is some error while saving your questions. Correct the format."
},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def save_XLS_to_MCQ(request):
if verify_user_hash(request.data.get('user'), request.data.get('hash')):
logger.info('under mcq.save_XLS_to_MCQ')
'''
{u'sub_category': u'5', u'answer_order': u'random', u'explanation': u'eeeeeeeeee',
u'level': u'easy', u'correctoption': u'1', u'content': u'eeeeeeeeee',
u'optioncontent': {u'1': u'eeeeeeeeee', u'2': u'eeeeeeeeeee'}}
'''
# _level_dict = {'medium': 'M', 'easy': 'E', 'hard': 'H'}
f = request.data['figure']
with open('mcq_read_now.xls', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
data = get_data("mcq_read_now.xls")
total_entries = len(data)
temp_data = data[0]
_dict_mcq_keys = [
'category', 'sub_category', 'que_type', 'level', 'explanation',
'option_display_order_random', 'correctoption', 'content',
'ideal_time', 'problem_type'
]
# This dict contains raw-way data with specified keys from temp_data or xls keys
data_dict = OrderedDict({})
# _quiz_id = None
category_dict = {}
sub_category_dict = {}
option_check = [
'option1', 'option2', 'option3', 'option4', 'option5', 'option6'
]
data_list = []
for row_name in _dict_mcq_keys:
data_dict.update({row_name: ''})
# Create empty value dict. for each mcq entry ..
for i, list_data in enumerate(data[1:]):
data_list.append(data_dict.copy())
optioncontent = {}
for j, mcq_data in enumerate(list_data):
mcq_data = ascii_safe(mcq_data)
if temp_data[j] == 'correctoption':
data_list[i][temp_data[j]] = str(mcq_data)
# Check if row is for option then create a dict_ of options and add it on optioncontent ....
elif temp_data[j] in option_check:
if mcq_data:
optioncontent[option_check.index(temp_data[j]) +
1] = str(mcq_data)
data_list[i]['optioncontent'] = optioncontent
# data_list[i]['optioncontent'] = optioncontent[option_check.index(temp_data[j])] = str(mcq_data)
#Check first for // key(category name) value(category id) // pair in dict. if not exist then call query.
elif temp_data[j] == 'category':
if category_dict.has_key(mcq_data):
category_id = category_dict.get(mcq_data)
else:
try:
category_id = Category.objects.get(
category_name=mcq_data).id
except Exception as e:
logger.error('under mcq.save_XLS_to_MCQ ' +
str(e.args))
category_id = None
category_dict[mcq_data] = category_id
data_list[i][temp_data[j]] = str(category_id)
#Check first for // key(sub_category name) value(sub_category id) // pair in dict. if not exist then call query.
elif temp_data[j] == 'sub_category':
try:
if sub_category_dict.has_key(mcq_data):
sub_category_id = sub_category_dict.get(mcq_data)
else:
sub_category_id = SubCategory.objects.get(
sub_category_name=mcq_data).id
sub_category_dict[mcq_data] = sub_category_id
data_list[i][temp_data[j]] = str(sub_category_id)
except SubCategory.DoesNotExist as e:
logger.error(
'under mcq.save_XLS_to_MCQ wrong subcategory specified '
+ str(e.args))
return Response(
{"errors": "Wrong sub-category specified."},
status=status.HTTP_400_BAD_REQUEST)
else:
data_list[i][temp_data[j]] = str(mcq_data)
# DONE ........
return create_mcq(request, data_list)
# return Response({'msg' : data_list}, status = status.HTTP_200_OK)
else:
logger.error('under quiz.save_XLS_to_MCQ wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
def question_operations(request, userid, question_id):
"""
Get a single question, delete or update
"""
_hash = request.query_params.get('hash')
if not _hash:
_hash = request.data.get('hash')
if verify_user_hash(userid, _hash):
logger.info('under quiz.question_operations '+str(request.method))
try:
question = Question.objects.get(id = question_id)
except Question.DoesNotExist:
logger.error('under quiz.question_operations '+str(e.args))
return Response({'errors': 'Question not found.'}, status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
questionserializer = QuestionSerializer(question, many = False)
answers = Answer.objects.filter(question = question)
answerserializer = AnswerSerializer(answers, many = True)
result = dict(questionserializer.data)
if question.que_type == QUESTION_TYPE_OPTIONS[2][0]:
result['heading'] = Comprehension.objects.get(question = question).heading
else:
result['problem_type'] = MCQuestion.objects.get(question_ptr = question.id).problem_type
result.update( { 'options' : answerserializer.data } )
result['sub_category_name'] = question.sub_category.sub_category_name
result['sub_category_id'] = question.sub_category.id
return Response({ 'question' : result }, status = status.HTTP_200_OK)
elif request.method == 'PUT':
result = {}
if request.data.get('figure', None):
if question.figure:
os.remove(str(question.figure))
if question.que_type == QUESTION_TYPE_OPTIONS[1][0]:
if BLANK_HTML in request.data['content']:
serializer = ObjectiveQuestionSerializer(question, data = request.data)
else:
logger.error('under quiz.question_operations error no blank field present')
return Response({ "content" : ["No blank field present.Please add one."] } , status = status.HTTP_400_BAD_REQUEST)
else:
serializer = QuestionSerializer(question, data = request.data)
if question.que_type == QUESTION_TYPE_OPTIONS[2][0]:
d = { 'heading': request.data['heading'], 'question': question.id }
comprehension_serializer = ComprehensionSerializer(Comprehension.objects.get(question = question), data = d)
if comprehension_serializer.is_valid():
comprehension_serializer.save()
result = comprehension_serializer.data
else:
return Response(comprehension_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
mcq_question_serailizer = MCQuestionSerializer(MCQuestion.objects.get(question_ptr = question.id), data = request.data)
result['problem_type'] = request.data.get('problem_type')
if mcq_question_serailizer.is_valid():
mcq_question_serailizer.save()
if serializer.is_valid():
serializer.save()
if result:
result.update(serializer.data)
else:
result = serializer.data
return Response(result, status = status.HTTP_200_OK)
else:
logger.error('under quiz.question_operations '+str(serializer.errors))
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
if question.figure:
os.remove(str(question.figure))
question.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
logger.error('under quiz.question_operations wrong hash')
return Response({'errors': 'Corrupted User.'}, status=status.HTTP_404_NOT_FOUND)
def comprehension_question_operations(request, comprehension_question_id):
user = request.query_params.get('user')
_hash = request.query_params.get('hash')
if not (user and _hash):
user = request.data.get('user')
_hash = request.data.get('hash')
if verify_user_hash(user, _hash):
logger.info('under comprehension.comprehension_question_operations ' +
str(request.method))
try:
comprehension_question = ComprehensionQuestion.objects.get(
id=comprehension_question_id)
except ComprehensionQuestion.DoesNotExist as e:
logger.error(
'under comprehension.comprehension_question_operations ' +
str(e.args))
return Response({'errors': 'Comprehension question not found.'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
comprehension_question_serializer = ComprehensionQuestionSerializer(
comprehension_question, many=False)
return Response(dict(comprehension_question_serializer.data),
status=status.HTTP_200_OK)
elif request.method == 'DELETE':
if comprehension_question.figure:
try:
os.remove(str(comprehension_question.figure))
except OSError as oes:
logger.error(
'under comprehension.comprehension_question_operations '
+ oes.args)
question = comprehension_question.comprehension.question
question.ideal_time -= old_ideal_time + comprehension_question.ideal_time
question.save()
comprehension_question.delete()
return Response(
{'deletedComprehensionQuestionsId': comprehension_question_id},
status=status.HTTP_200_OK)
elif request.method == 'PUT':
question = comprehension_question.comprehension.question
old_ideal_time = question.ideal_time - comprehension_question.ideal_time
question.ideal_time = old_ideal_time + int(
request.data.get('ideal_time'))
question.save()
if request.data.get('figure', None):
if comprehension_question.figure:
try:
os.remove(str(comprehension_question.figure))
except OSError as oes:
logger.error(
'under comprehension.comprehension_question_operations '
+ oes.args)
serializer = ComprehensionQuestionSerializer(
comprehension_question, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
logger.error(
'under comprehension.comprehension_question_operations ' +
str(serializer.errors))
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
logger.error(
'under comprehension.comprehension_question_operations wrong hash')
return Response({'errors': 'Corrupted User.'},
status=status.HTTP_404_NOT_FOUND)
