def test_saving_and_retrieving_users(self):
quiz_ = Quiz()
quiz_.save()
first_user = User()
first_user.user_text = 'The first (ever) quiz user'
first_user.quiz2 = quiz_
first_user.save()
second_user = User()
second_user.user_text = 'user the second'
second_user.quiz2 = quiz_
second_user.save()
saved_quiz = Quiz.objects.first()
self.assertEqual(saved_quiz, quiz_)
saved_users = User.objects.all()
self.assertEqual(saved_users.count(), 2)
first_saved_user = saved_users[0]
second_saved_user = saved_users[1]
self.assertEqual(first_saved_user.user_text,
'The first (ever) quiz user')
self.assertEqual(first_saved_user.quiz2, quiz_)
self.assertEqual(second_saved_user.user_text, 'user the second')
self.assertEqual(second_saved_user.quiz2, quiz_)
class QuizSelectFormTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
def test_new_quiz_result_created_on_save(self):
quiz_select_form = QuizSelectForm(data={ 'quiz': self.quiz.id, 'name': 'J Doe'})
self.assertEqual(0, QuizResult.objects.count())
quiz_select_form.is_valid()
quiz_select_form.save()
quiz_results = QuizResult.objects.filter(name='J Doe', quiz=self.quiz)
self.assertEqual(1, len(quiz_results))
def test_saving_and_retrieving_questions(self):
quiz_ = Quiz()
quiz_.save()
first_question = Question()
first_question.question_text = 'The first (ever) quiz Question'
first_question.quiz = quiz_
first_question.save()
second_question = Question()
second_question.question_text = 'Question the second'
second_question.quiz = quiz_
second_question.save()
saved_quiz = Quiz.objects.first()
self.assertEqual(saved_quiz, quiz_)
saved_questions = Question.objects.all()
self.assertEqual(saved_questions.count(), 2)
first_saved_question = saved_questions[0]
second_saved_question = saved_questions[1]
self.assertEqual(first_saved_question.question_text,
'The first (ever) quiz Question')
self.assertEqual(first_saved_question.quiz, quiz_)
self.assertEqual(second_saved_question.question_text,
'Question the second')
self.assertEqual(second_saved_question.quiz, quiz_)
def bulk_quiz_create_view(request):
if request.method == 'GET':
return render(request, 'quiz/bulk.html')
quiz_file = request.FILES['quiz-file']
tree = xml_tree.parse(quiz_file)
quiz_xml = tree.getroot()
quiz_name = quiz_xml.attrib['title']
quiz = Quiz(title=quiz_name,
author=request.user,
subject=request.user.teacherprofile.subject)
quiz.save()
for question_xml in quiz_xml:
question = Question(prompt=question_xml.attrib['prompt'],
subject=request.user.teacherprofile.subject,
author=request.user,
quiz=quiz)
question.save()
for answer_xml in question_xml:
answer = Answer(
text=answer_xml.text,
is_correct=True
if answer_xml.attrib['correct'].lower() == 'yes' else False,
question=question)
answer.save()
return redirect('teacher-detail', request.user.id)
def handle(self, *args, **options):
Quiz.objects.all().delete()
Options.objects.all().delete()
if not options['path']:
self.stderr.write(
self.style.ERROR(
"Please provide a valid path to a JSON Formatted Question File"
))
filepath = ''.join(options['path'])
filepath = filepath.replace('\u202a', '')
print(filepath)
with open(filepath, "r", encoding="utf-8") as sql_data:
data = json.loads(sql_data.read())
question_list = data['questions']
for question in question_list:
tempQuestion = Quiz(question=question['question'])
tempQuestion.save()
index = question['correct'] # Int / Array
if type(index) == int:
index = [index]
for option_index, option in enumerate(question['options']):
temp = Options(option=option,
is_correct=option_index in index)
temp.save()
tempQuestion.answers.add(temp)
tempQuestion.save()
self.stdout.write(
self.style.SUCCESS('Successfully loaded all Elements'))
def create_quiz(user, quiz_obj, act_xml):
quiz = Quiz()
quiz.owner = user
quiz.title = quiz_obj['title']
quiz.description = quiz_obj['description']
quiz.save()
# save gamification events
if act_xml.getElementsByTagName('gamification')[:1]:
events = parse_gamification_events(act_xml.getElementsByTagName('gamification')[0])
# remove anything existing for this course
QuizGamificationEvent.objects.filter(quiz=quiz).delete()
# add new
for event in events:
e = QuizGamificationEvent(user=user, quiz=quiz, event=event['name'], points=event['points'])
e.save()
quiz_obj['id'] = quiz.pk
# add quiz props
create_quiz_props(quiz, quiz_obj)
# add quiz questions
create_quiz_questions(user, quiz, quiz_obj)
return json.dumps(quiz_obj)
def create_quiz(user, quiz_obj, act_xml):
quiz = Quiz()
quiz.owner = user
quiz.title = quiz_obj['title']
quiz.description = quiz_obj['description']
quiz.save()
# save gamification events
if act_xml.getElementsByTagName('gamification')[:1]:
events = parse_gamification_events(
act_xml.getElementsByTagName('gamification')[0])
# remove anything existing for this course
QuizGamificationEvent.objects.filter(quiz=quiz).delete()
# add new
for event in events:
e = QuizGamificationEvent(user=user,
quiz=quiz,
event=event['name'],
points=event['points'])
e.save()
quiz_obj['id'] = quiz.pk
# add quiz props
create_quiz_props(quiz, quiz_obj)
# add quiz questions
create_quiz_questions(user, quiz, quiz_obj)
return json.dumps(quiz_obj)
def create_quiz(request):
user = request.user
if user.is_admin():
if request.method == 'POST':
# form is submitted
quiz_form = QuizForm(request.POST, request.user)
if quiz_form.is_valid:
# Create new instance of quiz
item = Quiz()
# Create random id and password
item.quiz_id = create_quiz_id(size=random.randint(5, 10))
item.quiz_password = get_random_string(
length=random.randint(8, 12))
# Fill other details of the Quiz Object
item.quiz_name = strip_tags(request.POST['quiz_name'])
item.description = strip_tags(request.POST['description'])
item.instructions = strip_tags(request.POST['instructions'])
item.duration = strip_tags(request.POST['duration'])
item.quiz_time = request.POST['quiz_time']
item.quizmaster = request.user
item.tags = strip_tags(request.POST['tags'])
# Save the Quiz object and mail the credentials
item.save()
send_mail(
'New Quiz Created:' + item.quiz_name,
'Here are the credentials\n' + 'Quiz_id=' + item.quiz_id +
'\nQuiz_password='******'*****@*****.**',
[user.email],
fail_silently=True,
)
return redirect('add_questions/' + item.quiz_id)
# errors are raised
else:
messages.error(request, 'Please correct the error below.')
return render(request, 'create_quiz.html', {
'title': 'Create Quiz',
'quiz_form': quiz_form
})
else:
# get request. We have to return the form so that user can fill it.
create_quiz_form = QuizForm()
return render(request, 'create_quiz.html', {
'title': 'Create Quiz',
'quiz_form': create_quiz_form
})
else:
messages.info(
request, 'You do not have the permissions required create a quiz')
return redirect('home')
def make_quiz(request, random=True, count=10):
name = uuid.uuid4().hex[:10]
q = Quiz(title=name, url=name, category=Category.objects.first(), random_order=True, answers_at_end=True, exam_paper=True, single_attempt=True)
q.save()
count = int(count)
questions = [randint(1,170) for _ in range(count)]
q.question_set = questions
out = redirect('/quiz/' + name + '/take/')
return out
def test_context_contains_quiz_select_form(self):
test_quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description='A great test quiz'
)
test_quiz.save()
response = self.client.get(reverse('home'))
self.assertTrue(response.context['has_quizzes'])
self.assertIsNot(None, response.context['form'])
def create_quiz(user, quiz_obj):
quiz = Quiz()
quiz.owner = user
quiz.title = clean_lang_dict(quiz_obj['title'])
quiz.description = clean_lang_dict(quiz_obj['description'])
quiz.save()
# add quiz questions
create_quiz_questions(user, quiz, quiz_obj)
return quiz
def test_render_after_submit(self):
quiz_ = Quiz()
quiz_.save()
user_ = User()
user_.user_text = 'test'
user_.user_point += 1
user_.quiz2 = quiz_
user_.save()
response = self.client.post('/%d/submit' % (quiz_.id, ),
data={'user_input': 'A new user'})
def create_new_quiz(request):
"""
Creates a new quiz and its default settings for the given request, and returns the quiz.
"""
quiz = Quiz() #New Quiz is created
quiz.resourceLinkId = lti.get_resource_link_id(request)
quiz.consumer_key = lti.get_oauth_consumer_key(request)
quiz.contextId = lti.get_context_id(request)
quiz.save() #Save the Quiz
quizSettings = QuizSettings(quiz=quiz)
quizSettings.save()
return quiz
def import_quiz_camtasia8(con_file, video):
"""
Doc
"""
#tree = ET.parse(fname)
tree = ET.fromstring(con_file.read())
rdf = '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}'
tscIQ = '{http://www.techsmith.com/xmp/tscIQ/}'
xmpDM = '{http://ns.adobe.com/xmp/1.0/DynamicMedia/}'
quiz_xpath = ".//" + rdf + "Description[@" + tscIQ + "questionSetName]"
for quiz in tree.findall(quiz_xpath):
title = quiz.attrib[tscIQ + "questionSetName"]
startTime = int(math.floor(float(quiz.attrib[xmpDM + "startTime"])/1000))
question_xpath = ".//" + rdf + "Description[@" + tscIQ + "id]"
quiz_obj = Quiz(title=title)
quiz_obj.save()
try:
marker = QuizMarker(video=video, time=startTime, quiz=quiz_obj)
marker.save()
qmodule_obj = QuestionModule(
title='Dummy Title',
quiz=quiz_obj,
dummy=True
)
qmodule_obj.save()
except Exception, e:
quiz_obj.delete()
try:
marker = QuizMarker.objects.get(video=video, time=startTime)
quiz_obj = marker.quiz
qmodule_obj = QuestionModule.objects.filter(quiz=quiz_obj)[0]
if(qmodule_obj.dummy):
qmodule_obj.dummy = False
qmodule_obj.title = quiz_obj.title
qmodule_obj.save()
quiz_obj.title = "Quiz : Multiple Questions"
quiz_obj.save()
qmodule_obj = QuestionModule(
title=title,
quiz=quiz_obj,
dummy=False
)
qmodule_obj.save()
except Exception,e:
marker = None
print "Some other error in marker creation at %d, %d" %(startTime, video.id)
print(e)
class QuizFormTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
self.quiz_result = QuizResult(name='J Doe', quiz=self.quiz)
self.quiz_result.save()
self.data = {}
for answer in self.quiz_result.answers.all():
question_text = answer.question.question
self.data['question_{0}'.format(answer.id)] = 'Yes'
def test_questions_are_populated_and_required(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
self.assertEqual(2, len(quiz_form.fields))
for key in quiz_form.fields.iterkeys():
self.assertTrue(quiz_form.fields[key].required)
def test_questions_marked_as_answered_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
quiz_form.save(self.quiz_result)
# Note: an unanswered question is represented by None
answers = self.quiz_result.answers.all()
for answer in answers:
self.assertNotEqual(None, answer.correct)
def test_quiz_completed_datetime_set_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
self.assertEqual(None, self.quiz_result.completed)
quiz_form.save(self.quiz_result)
self.assertNotEqual(None, self.quiz_result.completed)
def quizcreation(request):
# Récupère les données du quiz depuis le bouton quizData
context = {}
data = request.POST.get("quizData")
if data != None:
data = json.loads(data)
context["quiz"] = data
# Création des propriétés pour la sauvegarde dans la base de données
quizTitle = data["quesTitle"]
quiz = Quiz(title=quizTitle, data=data, user_id=1)
quiz.save()
return render(request, "quiz-creation.html", context)
def import_quiz_camtasia8(con_file, video):
"""
Doc
"""
#tree = ET.parse(fname)
tree = ET.fromstring(con_file.read())
rdf = '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}'
tscIQ = '{http://www.techsmith.com/xmp/tscIQ/}'
xmpDM = '{http://ns.adobe.com/xmp/1.0/DynamicMedia/}'
quiz_xpath = ".//" + rdf + "Description[@" + tscIQ + "questionSetName]"
for quiz in tree.findall(quiz_xpath):
title = quiz.attrib[tscIQ + "questionSetName"]
startTime = int(
math.floor(float(quiz.attrib[xmpDM + "startTime"]) / 1000))
question_xpath = ".//" + rdf + "Description[@" + tscIQ + "id]"
quiz_obj = Quiz(title=title)
quiz_obj.save()
try:
marker = QuizMarker(video=video, time=startTime, quiz=quiz_obj)
marker.save()
qmodule_obj = QuestionModule(title='Dummy Title',
quiz=quiz_obj,
dummy=True)
qmodule_obj.save()
except Exception, e:
quiz_obj.delete()
try:
marker = QuizMarker.objects.get(video=video, time=startTime)
quiz_obj = marker.quiz
qmodule_obj = QuestionModule.objects.filter(quiz=quiz_obj)[0]
if (qmodule_obj.dummy):
qmodule_obj.dummy = False
qmodule_obj.title = quiz_obj.title
qmodule_obj.save()
quiz_obj.title = "Quiz : Multiple Questions"
quiz_obj.save()
qmodule_obj = QuestionModule(title=title,
quiz=quiz_obj,
dummy=False)
qmodule_obj.save()
except Exception, e:
marker = None
print "Some other error in marker creation at %d, %d" % (
startTime, video.id)
print(e)
def add_quiz(self, request, pk=None):
concept = get_object_or_404(Concept, pk=pk)
self.check_object_permissions(request, concept.group.course)
serializer = AddQuizSerializer(data=request.DATA)
if serializer.is_valid():
quiz = Quiz(title=serializer.data['title'])
quiz.save()
concept.playlist = typed_playlist.append(quiz.id, concept.playlist,
1)
concept.quizzes.add(quiz)
concept.save()
return Response(QuizSerializer(quiz).data)
else:
content = serializer.errors
return Response(content, status.HTTP_400_BAD_REQUEST)
def add_quiz(self, request, pk=None):
concept = get_object_or_404(Concept, pk=pk)
self.check_object_permissions(request, concept.group.course)
serializer = AddQuizSerializer(data=request.DATA)
if serializer.is_valid():
quiz = Quiz(
title=serializer.data['title'])
quiz.save()
concept.playlist = typed_playlist.append(quiz.id, concept.playlist, 1)
concept.quizzes.add(quiz)
concept.save()
return Response(QuizSerializer(quiz).data)
else:
content = serializer.errors
return Response(content, status.HTTP_400_BAD_REQUEST)
def create_quiz(req, user, quiz_obj, act_xml, activity=None):
quiz = Quiz()
quiz.owner = user
quiz.title = quiz_obj['title']
quiz.description = quiz_obj['description']
quiz.save()
quiz_obj['id'] = quiz.pk
# add quiz props
create_quiz_props(quiz, quiz_obj)
# add quiz questions
create_quiz_questions(user, quiz, quiz_obj)
return json.dumps(quiz_obj)
def quiz():
category = Category()
category.name = "teste_category"
category.save()
question = Question()
question.question = "test_question"
question.answer_A = "test_A"
question.answer_B = "test_B"
question.answer_C = "test_C"
question.save()
quiz = Quiz()
quiz.title = "test_quiz"
quiz.category = category
quiz.save()
quiz.question.add(question)
return quiz
def quiz(request):
if request.method == 'POST':
session = str(uuid.uuid4())
validator = QuizValidator(json.loads(request.body))
valid, data = validator.validate()
if not valid:
return (data, 400)
quiz = Quiz(
session = session,
expected_return = data['expected_return'],
expected_life = data['expected_life'],
save_priority = data['save_priority'],
net_worth = data['net_worth']
)
quiz.save()
return quiz
return { 'hi' : ':)'}
def save(self, *args, **kwargs):
self.slug = slugify(unicode(self.title))
self.slug = self.slug[:49]
super(Lesson, self).save(*args, **kwargs)
if not self.sections.all():
section = LessonSection(content_type='topic', lesson=self)
section.save()
section = LessonSection(content_type='media', lesson=self)
section.save()
section = LessonSection(content_type='reading', lesson=self)
section.save()
section = LessonSection(content_type='apply', lesson=self)
section.save()
if not self.lesson_discussion.all():
try:
user = self.creator
except:
user = User.objects.filter(is_superuser=True)[0]
try:
thread = Post(text="Start a discussion!",
creator=user,
subject=self.title + ' Talk',
parent_post=None)
thread.save()
discussion = LessonDiscussion(thread=thread, lesson=self)
discussion.save()
except:
pass # Fail silently...
if not self.lesson_quiz.all():
try:
title = '%s Quiz' % (self.title)
quiz = Quiz(title=title,
url=title,
random_order=False,
answers_at_end=True)
quiz.save()
lesson_quiz = LessonQuiz(quiz=quiz, lesson=self)
lesson_quiz.save()
except Exception as e:
pass # Fail silently...
def test_answer_question_and_points_collect(self):
first_question = Quiz()
first_question.question = '2+2*0+1=1'
first_question.answer = False
first_question.wrong_ans = 0
first_question.correct_ans = 0
first_question.save()
# 2 correct answer
first_question.correct_ans += 1
first_question.correct_ans += 1
# 1 wrong answer
first_question.wrong_ans += 1
first_question.save()
saved_question = Quiz.objects.first()
self.assertEqual(saved_question.correct_ans, 2)
self.assertEqual(saved_question.wrong_ans, 1)
def create(self, validated_data):
name = validated_data.get('name')
duration = validated_data.get('duration')
start_time = validated_data.get('start_time')
end_time = validated_data.get('end_time')
max_attempts = validated_data.get('max_attempts')
classroom = validated_data.get('classroom')
owner = validated_data.get('owner')
instance = Quiz(
classroom = classroom,
owner = owner,
name = name,
duration = duration,
start_time = start_time,
end_time = end_time,
max_attempts = max_attempts,
)
instance.save()
return instance
def test_saving_and_retrieving_quizs(self):
first_quiz = Quiz()
first_quiz.ques = 'The first quiz 1+1=2'
first_quiz.ans = True
first_quiz.save()
second_quiz = Quiz()
second_quiz.ques = 'The second quiz 2+2=3'
second_quiz.ans = False
second_quiz.save()
saved_quizs = Quiz.objects.all()
self.assertEqual(saved_quizs.count(), 2)
first_saved_quiz = saved_quizs[0]
second_saved_quiz = saved_quizs[1]
self.assertEqual(first_saved_quiz.ques, 'The first quiz 1+1=2')
self.assertEqual(first_saved_quiz.ans, True)
self.assertEqual(second_saved_quiz.ques, 'The second quiz 2+2=3')
self.assertEqual(second_saved_quiz.ans, False)
class QuizTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description='Test Quiz'
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
def test_should_404_if_quiz_doesnt_exist(self):
response = self.client.get(reverse('quiz', args=(111,)))
self.assertEqual(404, response.status_code)
def test_should_redirect_home_if_quiz_is_taken(self):
quiz_result = QuizResult(
name='John Doe',
quiz=self.quiz,
completed=timezone.now()
)
quiz_result.save()
response = self.client.get(reverse('quiz', args=(quiz_result.id,)))
self.assertEqual(302, response.status_code)
def test_should_contain_form_in_context(self):
quiz_result = QuizResult(
name='John Doe',
quiz=self.quiz
)
quiz_result.save()
response = self.client.get(reverse('quiz', args=(quiz_result.id,)))
self.assertEqual(200, response.status_code)
self.assertIsNot(None, response.context['form'])
def test_create_and_saving_question(self):
first_question = Quiz()
first_question.question = '2+2*0+1=1'
first_question.answer = False
first_question.save()
second_question = Quiz()
second_question.question = 'Tomatoes is vegetable'
second_question.answer = False
second_question.save()
saved_question = Quiz.objects.all()
self.assertEqual(saved_question.count(), 2)
first_saved_question = saved_question[0]
second_saved_question = saved_question[1]
self.assertEqual(first_saved_question.question, '2+2*0+1=1')
self.assertEqual(first_saved_question.answer, False)
self.assertEqual(second_saved_question.question,
'Tomatoes is vegetable')
self.assertEqual(second_saved_question.answer, False)
def post(self, request, *args, **kwargs):
file = request.data['myFile']
file_name = default_storage.save(file.name, file)
parsed_pdf = parser.from_file(file_name)
data = re.sub('[^a-zA-Z0-9-_*. ?:()!]', '', parsed_pdf['content'])
logger.error(data)
quiz = Quiz(name=data[slicer(data, "docx"):data.index("1)")] +
"- Sample")
quiz.save()
data = data[data.index("1)"):]
blocks = re.split(r'[ ](?=[0-9]+\))', data)
question_num = int(len(blocks) / 2)
for i, elem in enumerate(blocks[:question_num]):
if ("ANSWER KEY" in elem):
elem = elem[:elem.index("ANSWER KEY")]
question = elem[:elem.index("A)")]
q = Question(label=question,
quiz=quiz,
order=int(question[:question.index(")")]))
q.save()
letters = ["A", "B", "C", "D"]
for index, char in enumerate(letters):
label = ""
if index == len(letters) - 1:
label = elem[elem.index(char + ")"):]
else:
label = elem[elem.index(char +
")"):elem.index(letters[index +
1] + ")")]
Answer.objects.create(
question=q,
label=label,
is_correct=blocks[question_num + i].find(char) > -1)
return Response(QuizListSerializer(quiz).data)
def save(self, *args, **kwargs):
self.slug = slugify(unicode(self.title))
self.slug = self.slug[:49]
super(Lesson, self).save(*args, **kwargs)
if not self.sections.all():
section = LessonSection(content_type='topic', lesson=self)
section.save()
section = LessonSection(content_type='media', lesson=self)
section.save()
section = LessonSection(content_type='reading', lesson=self)
section.save()
section = LessonSection(content_type='apply', lesson=self)
section.save()
if not self.lesson_discussion.all():
try:
user = self.creator
except:
user = User.objects.filter(is_superuser=True)[0]
try:
thread = Post(text="Start a discussion!", creator=user, subject=self.title+' Talk', parent_post=None)
thread.save()
discussion = LessonDiscussion(thread=thread, lesson=self)
discussion.save()
except:
pass # Fail silently...
if not self.lesson_quiz.all():
try:
title = '%s Quiz'% (self.title)
quiz = Quiz(title=title, url=title, random_order=False, answers_at_end=True)
quiz.save()
lesson_quiz = LessonQuiz(quiz=quiz, lesson=self)
lesson_quiz.save()
except Exception as e:
pass # Fail silently...
def setup_method(self, test_method):
username = '******'
quiz_title = u'PyTest Quiz'
try:
u = User.objects.get(username=username)
except User.DoesNotExist:
u = User(username=username, first_name='Test', last_name='User')
u.set_password('testuserpass')
u.save()
try:
q = Quiz.objects.get(title=quiz_title)
except Quiz.DoesNotExist:
q = Quiz(title=quiz_title, instruction='PyTest creating a quiz', quiz_type=1)
q.save()
self.user = u
self.quiz = q
self.quiz_title = quiz_title
self.username = username
self._create_questions()
class TestModels(TestCase):
def setUp(self):
self.quiz = Quiz(name='TestQuiz',
expires=strptime('2100-01-01 00:00:00'))
self.quiz.save()
def testQuizExpires(self):
self.assertFalse(self.quiz.is_expired())
self.quiz.expires = strptime('3150-05-10 17:06:00')
self.quiz.save()
self.assertFalse(self.quiz.is_expired())
self.quiz.expires = strptime('1980-01-02 12:12:12')
self.quiz.save()
self.assertTrue(self.quiz.is_expired())
self.quiz.expires = strptime('1980-01-02 12:12:12')
self.assertTrue(self.quiz.is_expired())
Quiz.objects.all().delete()
with open("questions1_20000.tsv", "r", encoding="utf8") as f:
data = f.readlines()
current_quiz = None
for line_number, line in enumerate(data):
line = line.split('\t')
if line[0] == '':
continue
if line[1].startswith('id: +'):
quiz_title = line[0]
current_quiz = Quiz(user_id=1,
category='not set',
difficulty=1,
description='No description')
current_quiz.name = quiz_title
current_quiz.save()
continue
quiz_question = line[0]
question_list = []
current_question = Question(quiz=current_quiz, text=quiz_question)
current_question.save()
question_list.append(current_question)
answer_list = []
for it, answer in enumerate(line[1:]):
if answer == '':
is_result = True
for correct in [l for l in line[it + 3:] if l != '\n']:
good_answer = correct
for ans in answer_list:
if ans.text == good_answer:
ans.is_correct = True
def update(self, instance, validated_data, user=None):
quiz = Quiz(id=instance.id, **validated_data, user=instance.user)
quiz.save()
return quiz
def update(self, request):
meeting = Meeting.objects.get(id = request.data.get('meeting'))
meeting.title = request.data.get('title')
meeting.subject_matter = request.data.get('subject_matter')
meeting.status = request.data.get('status')
meeting.initial_date = request.data.get('initial_date')
meeting.final_date = request.data.get('final_date')
meeting.initial_hour = request.data.get('initial_hour')
meeting.final_hour = request.data.get('final_hour')
meeting.save()
if request.data.get('topics') != None:
for topic in request.data.get('topics'):
new_topic = Topic()
new_topic.title = topic['title']
if Topic.objects.all().filter(title = new_topic.title) != True:
new_topic.save()
meeting.topics.add(new_topic)
if request.data.get('rules') != None:
for rules in request.data.get('rules'):
new_rule = Rules()
new_rule.title = rules['title']
if Rules.objects.all().filter(title = new_rule.title) != True:
new_rule.save()
meeting.rules.add(new_rule)
if request.data.get('users') != None:
for users in request.data.get('users'):
new_user = User.objects.get(id = users['id'])
meeting.users.add(new_user)
if request.data.get('questtionaire') != None:
questtionaires = Questionnaire()
questtionaires.title = request.data.get('questtionaire').get('title')
questtionaires.save()
meeting.questtionaire.add(questtionaires)
order = 1
for quiz in request.data.get('questtionaire').get('questions'):
new_quiz = Quiz()
new_quiz.title = quiz['title']
new_quiz.order = order
new_quiz.save()
for user in meeting.users.all():
if user.name == str(meeting.meeting_leader):
print('Usuário é o Líder da Reunião')
else:
new_quiz.users.add(user)
for choice in quiz.get('choices'):
new_choice = Choice()
new_choice.title = choice
new_choice.save()
new_quiz.choices.add(new_choice)
new_quiz.questtionaire = questtionaires
new_quiz.save()
order += 1
return meeting
def create(request):
"""
View dedicated to the creation of the quiz using formsets.
The user has to add at least one question for it to be valid.
"""
TF_Formset = formset_factory(CreationTrueFalseForm)
MC_Formset = formset_factory(CreationMultiChoiceForm)
if request.method == "GET":
logger.info("{levelname} {asctime} - User accessed create page")
quiz_form = QuizForm(request.GET or None, prefix="quiz")
tf_formset = TF_Formset(request.GET or None, prefix="tf")
mc_formset = MC_Formset(request.GET or None, prefix="mc")
elif request.method == "POST":
logger.info("{levelname} {asctime} - User wants to create a quiz")
quiz_form = QuizForm(request.POST, prefix="quiz")
tf_formset = TF_Formset(request.POST or None, prefix="tf")
mc_formset = MC_Formset(request.POST or None, prefix="mc")
if quiz_form.is_valid() and ((tf_formset.is_valid()
and mc_formset.is_valid())):
logger.info("{levelname} {asctime} - Quiz is valid")
quiz_cd = quiz_form.cleaned_data
category = Category.objects.get(id=quiz_cd["category"])
category_name = (category.category.replace(" ", "-").replace(
"ç", "c").replace("é", "e"))
if quiz_cd["sub_category"]:
sub_category = SubCategory.objects.get(
id=quiz_cd["sub_category"])
else:
sub_category = None
new_quiz = Quiz(
title=quiz_cd["title"],
description=quiz_cd["description"],
creator=request.user,
url="placeholder",
category=category,
category_name=category_name,
sub_category=sub_category,
random_order=quiz_cd["random_order"],
difficulty=0,
)
new_quiz.save()
mean_difficulty = 0
n = 0
if tf_formset:
for question in tf_formset:
cd = question.cleaned_data
n += 1
mean_difficulty += int(cd["difficulty"])
new_tf = TF_Question(
content=cd["content"],
difficulty=cd["difficulty"],
theme1=cd["theme1"],
theme2=cd["theme2"],
theme3=cd["theme3"],
order=cd["order"],
correct=cd["correct"],
quiz=new_quiz,
)
new_tf.save()
if mc_formset:
for question in mc_formset:
cd = question.cleaned_data
n += 1
mean_difficulty += int(cd["difficulty"])
new_mc = MCQuestion(
content=cd["content"],
difficulty=cd["difficulty"],
theme1=cd["theme1"],
theme2=cd["theme2"],
theme3=cd["theme3"],
order=cd["order"],
answer1=cd["answer1"],
answer2=cd["answer2"],
answer3=cd["answer3"],
answer1_correct=cd["answer1_correct"],
answer2_correct=cd["answer2_correct"],
answer3_correct=cd["answer3_correct"],
quiz=new_quiz,
)
new_mc.save()
mean_difficulty /= n
# Calculation of the difficulty
if mean_difficulty < 1.667:
quiz_difficulty = 1
elif mean_difficulty > 2.333:
quiz_difficulty = 3
else:
quiz_difficulty = 2
new_quiz.difficulty = quiz_difficulty
new_quiz.url = slugify(quiz_cd["title"]) + "-" + str(new_quiz.id)
new_quiz.save()
return redirect("profile")
return render(
request,
"quiz/create.html",
{
"quiz_form": quiz_form,
"tf_form": tf_formset,
"mc_form": mc_formset
},
)
def setUp(self):
options = Options()
options.headless = True
self.browser = webdriver.Firefox(options=options)
# Create Categories and SubCategories
sc = Category.objects.create(category="Sciences")
ph = SubCategory.objects.create(category=sc, sub_category="Physique")
ch = SubCategory.objects.create(category=sc, sub_category="Chimie")
svt = SubCategory.objects.create(
category=sc, sub_category="Sciences de la Vie et de la Terre")
bio = SubCategory.objects.create(category=sc, sub_category="Biologie")
info = SubCategory.objects.create(category=sc,
sub_category="Informatique")
tec = SubCategory.objects.create(category=sc,
sub_category="Technologie")
si = SubCategory.objects.create(category=sc,
sub_category="Sciences de l'Ingénieur")
math = SubCategory.objects.create(category=sc,
sub_category="Mathématiques")
sc_au = SubCategory.objects.create(category=sc, sub_category="Autres")
fr = Category.objects.create(category="Francais")
ortho = SubCategory.objects.create(category=fr,
sub_category="Orthographe")
gram = SubCategory.objects.create(category=fr,
sub_category="Grammaire")
voc = SubCategory.objects.create(category=fr,
sub_category="Vocabulaire")
lit = SubCategory.objects.create(category=fr,
sub_category="Littérature")
fr_au = SubCategory.objects.create(category=fr, sub_category="Autres")
lg = Category.objects.create(category="Langues")
an = SubCategory.objects.create(category=lg, sub_category="Anglais")
it = SubCategory.objects.create(category=lg, sub_category="Italien")
es = SubCategory.objects.create(category=lg, sub_category="Espagnol")
de = SubCategory.objects.create(category=lg, sub_category="Allemand")
po = SubCategory.objects.create(category=lg, sub_category="Portugais")
lg_au = SubCategory.objects.create(category=lg, sub_category="Autres")
hg = Category.objects.create(category="Histoire-Geographie")
hi = SubCategory.objects.create(category=hg, sub_category="Histoire"),
geo = SubCategory.objects.create(category=hg,
sub_category="Géographie"),
emc = SubCategory.objects.create(
category=hg, sub_category="Enseignement Moral et Civique"),
ses = SubCategory.objects.create(
category=hg, sub_category="Sciences Economiques et Sociales")
hg_au = lg_au = SubCategory.objects.create(category=hg,
sub_category="Autres")
au = Category.objects.create(category="Autres")
# create a user :
user_A = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
# create a quiz :
quiz = Quiz(title="Titre du quiz",
description="Quiz crée pour les tests fonctionnels",
creator=user_A,
url="titre-du-quiz-1",
category=sc,
category_name="Sciences",
sub_category=ph,
random_order=False,
created=datetime.now(),
difficulty=2)
quiz.save()
tf1 = TF_Question.objects.create(quiz=quiz,
difficulty=1,
order=0,
content="Question 1",
theme1="t1",
theme2="t2",
theme3="",
correct=True)
mc1 = MCQuestion.objects.create(quiz=quiz,
difficulty=2,
order=1,
content="Question 2",
theme1="t1",
theme2="t3",
theme3="",
answer1="réponse fausse",
answer1_correct=False,
answer2="réponse vraie",
answer2_correct=True,
answer3="réponse vraie",
answer3_correct=True)
tf2 = TF_Question.objects.create(quiz=quiz,
difficulty=3,
order=2,
content="Question 3",
theme1="t1",
theme2="t2",
theme3="t3",
correct=False)
