async def organize(self,
ctx,
quiz_type: str = None,
team_size: str = None):
if ctx.channel.name != text(CHANNEL_SETUP):
return
if quiz_type not in ['normal', 'jeopardy', 'only connect']:
quiz_type = 'normal'
if not team_size:
team_size = 2
team_size = min(max(int(team_size), 2), 8)
self._quiz = Quiz(quiz_type, ctx.message.author, team_size)
self._quiz_message = await ctx.send(self._quiz.organization_text())
await self._quiz_message.add_reaction(EMOJI_OK)
await self._quiz_message.add_reaction(EMOJI_ACCEPT)
await self._quiz_message.add_reaction(EMOJI_DECLINE)
try:
for team_id in range(1, team_size + 1):
role = await self._management.get_or_create_role('Team ' +
str(team_id))
team = Team(role, team_id)
self._quiz.add_team(team)
await self._quiz_message.add_reaction(EMOJI_TEAM[team_id - 1])
except Exception as e:
print(e)
await ctx.message.delete()
def test_question_model(self):
"""Test basic question model"""
q = Quiz(num_questions=10, family='Test2 family')
db.session.add(q)
for i in range(10):
question = Question(url='test_url',
correct_answer='right answer',
wrong_answer_1='wrong one',
wrong_answer_2='wrong too',
wrong_answer_3='wrong 3',
slug='test-slug')
q.questions.append(question)
db.session.commit()
qq = q.questions[0]
self.assertEqual(len(q.questions), 10)
self.assertEqual(qq.url, 'test_url')
self.assertEqual(qq.correct_answer, 'right answer')
self.assertEqual(qq.wrong_answer_2, 'wrong too')
self.assertEqual(qq.search_slug, 'test+slug')
self.assertEqual(len(Question.query.all()), 30)
self.assertEqual(
len(Question.query.filter(Question.url == 'test_url').all()), 10)
self.assertEqual(len(qq.part_of), 1)
self.assertEqual(qq.part_of[0].id, q.id)
def test_quiz_can_be_added(self):
self.test_quiz_2 = Quiz("2020-02-02", 10, "MEDIUM", "Geography", [])
self.assertEqual("2020-02-02", self.test_quiz_2.date)
self.assertEqual(10, self.test_quiz_2.number_of_questions)
self.assertEqual("MEDIUM", self.test_quiz_2.difficulty)
self.assertEqual("Geography", self.test_quiz_2.topic)
self.assertEqual([], self.test_quiz_2.question_list)
async def load_quiz(self, ctx):
io = BytesIO()
await ctx.message.attachments[0].save(io)
with session_scope() as session:
instances = [Quiz(**instance) for instance in json.load(io)]
session.add_all(instances)
await ctx.send(f"`{len(instances)}`개 데이터를 추가했습니다.")
def test_next_question_causes_finish():
Quiz.max_time_in_seconds = 0.1
quiz = Quiz(FakeSource, 1234, "easy", "9", None)
quiz.start()
for _ in range(10):
sleep(0.1)
quiz.next_question()
assert quiz.is_finished
def select_all():
quizzes = []
sql = "SELECT * FROM quizzes"
results = run_sql(sql)
for result in results:
difficulty = difficulty_repository.select(result["difficulty_id"])
topic = topic_repository.select(result["topic_id"])
quiz = Quiz(result["date"], result["number_of_questions"], difficulty,
topic, result["question_list"], result["id"])
quizzes.append(quiz)
return quizzes
def test_next_question():
Quiz.max_time_in_seconds = 0.1
quiz = Quiz(FakeSource, 1234, "easy", "9", None)
quiz.start()
start_question = quiz.current_question
sleep(0.1)
quiz.next_question()
second_question = quiz.current_question
assert start_question is second_question - 1
def select(id):
quiz = None
sql = "SELECT * FROM quizzes WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
difficulty = difficulty_repository.select(result["difficulty_id"])
topic = topic_repository.select(result["topic_id"])
if result is not None:
quiz = Quiz(result["date"], result["number_of_questions"], difficulty,
topic, result["question_list"])
return quiz
def create_quiz(self,
source,
difficulty=None,
category=None,
max_questions=None):
"""creates a new quiz and adds it to the store"""
# Get the lowest available code
code = 1
if len(self.questions) is not 0:
code = max([quiz.code for quiz in self.quizes.values()]) + 1
new_quiz = Quiz(source, code, difficulty, category, max_questions)
self.quizes[new_quiz.quiz_id] = new_quiz
return new_quiz.quiz_id
def add_questions(file_path, family):
"""Add new quizzes to existing database from CSV of questions"""
with open(f'{file_path}', newline="") as csvfile:
questions = DictReader(csvfile)
count = 0
for question in questions:
if count % 10 == 0:
new_quiz = Quiz(family=family, num_questions=10)
db.session.add(new_quiz)
new_question = Question(**question)
new_quiz.questions.append(new_question)
db.session.add(new_question)
count += 1
db.session.commit()
def update_quiz(id):
date = request.form["date"]
number_of_questions = request.form["number_of_questions"]
difficulty_id = request.form["difficulty_id"]
difficulty = difficulty_repository.select(difficulty_id)
topic_id = request.form["topic_id"]
topic = topic_repository.select(topic_id)
question_list = request.form["question_list"]
quiz = Quiz(date, number_of_questions, difficulty, topic, question_list,
id)
quiz_repository.update(quiz)
return redirect("/quizzes")
def test_quiz_model(self):
"""Test basic quiz model"""
q = Quiz(num_questions=10, family='Test2 family')
db.session.add(q)
db.session.commit()
self.assertEqual(len(q.questions), 0)
self.assertEqual(q.num_questions, 10)
self.assertEqual(q.family, 'Test2 family')
self.assertEqual(len(Quiz.query.all()), 3)
self.assertEqual(
len(Quiz.query.filter(Quiz.family == 'Test2 family').all()), 1)
self.assertEqual(
len(Quiz.query.filter(Quiz.family == 'test family').all()), 2)
self.assertEqual(q.num_by_family, 1)
def create_quiz():
date = request.form["date"]
number_of_questions = request.form["number_of_questions"]
difficulty_id = request.form["difficulty"]
difficulty = difficulty_repository.select(difficulty_id)
topic_id = request.form["topic"]
topic = topic_repository.select(topic_id)
for question in number_of_questions:
question_list.append(question)
return question_list
new_quiz = Quiz(date, number_of_questions, difficulty, topic,
question_list)
quiz_repository.save(new_quiz)
return redirect("/quizzes")
def quiz_dashboard(qid=None):
if not current_user.is_authenticated:
flash('Login is Required for this action!')
return redirect('/', 302)
if not current_user.is_admin:
flash('You need to be an Admin for Performing this action!')
return redirect('/', 302)
template = "_question.html"
req_path = request.path.split('/')[-1]
if qid and len(qid) > 24:
return render_template('404.html')
if req_path == qid:
req_path = request.path.split('/')[-2]
if req_path == 'add':
form = AddQuestion()
if request.method == "POST":
if form.validate():
sol = {
1: form.option1.data,
2: form.option2.data,
3: form.option3.data,
4: form.option4.data,
}
Quiz(question=form.question.data,
options=[
form.option1.data,
form.option2.data,
form.option3.data,
form.option4.data,
],
answer=sol.get(form.solution.data)).save_quiz()
flash('Question Saved Successfully!')
return redirect('/admin/dashboard/Quiz/edit')
return render_template('add' + template, form=form)
elif req_path == 'edit':
if not qid:
questions = Quiz.get_questions(userID=None,
show_history=True,
is_admin=True,
limit=1000)
for question in questions:
question._id = str(question._id)
return render_template('display_questions.html',
questions=questions)
form = EditQuestion()
question = Quiz.get_question(qid)
if request.method == "POST":
if form.validate_on_submit():
if question:
question.question = form.question.data
question.options = [
form.option1.data, form.option2.data,
form.option3.data, form.option4.data
]
sol = {
1: form.option1.data,
2: form.option2.data,
3: form.option3.data,
4: form.option4.data,
}
question.answer = sol.get(form.solution.data)
question.update_quiz_info()
# print('Quiz updated!')
flash('Question Edited Successfully!')
return redirect('/admin/dashboard/Quiz/edit')
else:
flash('Unable to find Question in DB')
return redirect('/')
else:
flash("Couldn't Validate form..")
# print(form.validate_on_submit())
return render_template('edit' + template, form=form)
if question:
form.solution.default = question.options.index(question.answer) + 1
form.process()
form.question.data = question.question
form.option1.data = question.options[0]
form.option2.data = question.options[1]
form.option3.data = question.options[2]
form.option4.data = question.options[3]
# form.process()
return render_template('edit' + template, form=form)
elif req_path == 'delete' or qid:
if request.method == "POST" and qid:
# print(help(Quiz.DB.CURSOR.delete_one))
Quiz.DB.CURSOR.Quiz.delete_one({'_id': ObjectId(qid)})
flash('Question Deleted!')
return redirect('/admin/dashboard/Quiz/delete')
if not qid:
questions = Quiz.get_questions(userID=None,
show_history=True,
is_admin=True,
limit=1000)
for question in questions:
question._id = str(question._id)
return render_template('display_questions.html',
questions=questions)
return render_template('delete_question.html')
else:
return render_template('404.html')
def setup(bot):
bot.add_cog(Quiz(bot))
from json import load
from models.quiz import Quiz
content = load(open('json_quiz.json'))
for question in content:
Quiz(question=question.get('question'),
options=question.get('options'),
answer=question.get('answer')).save_quiz()
def test_finish_quiz():
quiz = Quiz(FakeSource, 1234, "easy", "9", None)
quiz.finish()
assert quiz.is_finished is True
db.create_all()
with open('generator/general_5.csv') as questions:
db.session.bulk_insert_mappings(Question, DictReader(questions))
with open('generator/rose_3.csv') as questions:
db.session.bulk_insert_mappings(Question, DictReader(questions))
with open('generator/aster_3.csv') as questions:
db.session.bulk_insert_mappings(Question, DictReader(questions))
with open('generator/mint_3.csv') as questions:
db.session.bulk_insert_mappings(Question, DictReader(questions))
with open('generator/pea_3.csv') as questions:
db.session.bulk_insert_mappings(Question, DictReader(questions))
questions = Question.query.all()
family = ['general'] * 5 + ['Rose family'] * 3 + ['Aster family'] * 3
family = family + ['Mint family'] * 3 + ['Pea family'] * 3
for i in range(len(family)):
new_quiz = Quiz(family=family[i], num_questions=10)
for j in range(10):
questions[10 * i + j].family = family[i]
new_quiz.questions.append(questions[i * 10 + j])
db.session.add(new_quiz)
db.session.commit()
def setUp(self):
self.test_quiz = Quiz("2020-01-01", 5, "EASY", "General Knowledge", [])
def create_office_online(self):
module = Module(
'onedrive-and-office-online', 'One Drive & Office Online',
'In this introduction to OneDrive and Office Online, pupils will learn to create, edit, save and upload documents in the cloud so that they can <b>create and edit documents from school or home</b>.',
'one-drive-office-online')
lesson1 = Lesson(
'onedrive-and-office-online', 1, 'OneDrive & Office online',
'How to create, edit, save, upload and access documents using OneDrive and Office Online',
'None', 'None')
lesson1.setLearningObjectiveIds('ss02', 'oo02*')
lesson1.starter = """
<ul>
<li>Work in groups of 2's or 3's</li>
<li>Take one piece of paper per group.</li>
<li>Discuss and identify 3 difficulties of <b>using thumb drives</b></li>
</ul>"""
lesson1.resources = [
{
'url': '',
'text': 'Lesson Slides'
},
{
'url': '',
'text': 'Cheat Sheet'
},
]
q1 = Quiz('q1', 'Using OneDrive?')
q1.add_question(0, 'What is OneDrive?', [
'A house with one drive',
'A software service that can store files.'
], [False, True])
q1.add_question(1, 'Which software company creates OneDrive?',
['Microsoft', 'BISAK', 'Google', 'DropBox'],
[True, False, False, False])
q2 = Quiz('q2', 'Uploading Files.')
q2.add_question(0, 'Test Question 1?', ['Answer 1', 'Answer 2.'],
[False, True])
q2.add_question(1, 'Test Question 2?', ['Answer 1', 'Answer 2.'],
[True, False])
lesson1.addActivities(
Activity(
10, 'Starter', """
<h2>In pairs, create a list of the issues you may face when you use a thumbdrive to transport files to and from home.</h2>
"""),
VideoActivity(
10, 'What is OneDrive?',
'https://www.dropbox.com/s/tkjpefa581rsibg/Internet%20Safety%20-%20Newsround%20Caught%20In%20The%20Web%20%289%20Feb%202010%29.mp4?raw=1'
), QuizActivity(10, 'What is OneDrive?', q1),
Activity(15,
'Uploading and locating files in the Cloud.',
content=""), QuizActivity(10, 'Test Quiz?', q2),
Activity(0,
'(Extension) What is OneDrive Version History?',
content=""), RateProgressActivity(5,
'Rate your progress'),
RecapActivity(10, 'Recap'),
LoPuActivity(5, 'LoPu')
#,
# QuizItem ('00:45', f"CFU: {tlQuiz.title}", tlQuiz),
# TimelineItem('00:50', BringItAllTogetherItem('Bring It All Together'),
# TimelineItem('00:54', RateYourProgressItem('Rate Your Progress'),
# TimelineItem('00:57', NailItDown('Nail It Down'),
# TimelineItem('00:59', LOPU()),
)
lesson1.homework = """From `vle"""
module.add_lesson(lesson1)
self.modules[module.id] = module
question_005 = Question("Who wrote Catch-22?", "Joseph Heller",
"John Steinbeck", "Ernest Hemmingway", "Jane Austin",
difficulty_2, topic_05, user_topic_00, False)
question_repository.save(question_005)
question_006 = Question("Who shot Mr Burns?", "Maggie Simpson",
"Homer Simpson", "Marge Simpson", "Smithers",
difficulty_1, topic_06, user_topic_00, False)
question_repository.save(question_006)
question_007 = Question("Who painted The Salvator Mundi?", "Leonardo da Vinci",
"Vincent van Gogh", "Andy Worhol", "El Greco",
difficulty_3, topic_07, user_topic_00, False)
question_repository.save(question_007)
question_008 = Question("What was the first song played on BBC Radio 1?",
"Flowers in The Rain", "The Sound of Music",
"She Loves Me", "Time After Time", difficulty_4,
topic_08, user_topic_00, False)
question_repository.save(question_008)
quiz_01 = Quiz("2020-01-01", 5, difficulty_1, topic_00, [])
quiz_repository.save(quiz_01)
topic_repository.select_all()
user_topic_repository.select_all()
difficulty_repository.select_all()
question_repository.select_all()
quiz_repository.select_all()
pdb.set_trace()
