def random_id(id=None, course=None, exam=None):
"""
Returns a random id from questions that have not been answered.
Returns a random number if none available
"""
# All questions
questions = all_questions(course, exam)
# Already answered questions
if exam:
query = models.Stats.exam(get_user(), course, exam)
else:
query = models.Stats.course(get_user(), course)
answered = set(query.with_entities(models.Stats.question_id).all())
# List of indexes for unanswered questions
indexes = [
i + 1 for i, question in enumerate(questions)
if (i + 1) != id and question not in answered
]
# Ignore current question
if indexes:
# Select random index
return random.choice(indexes)
else:
# All questions have been answered
return random.randint(1, len(questions) + 1)
def post(self):
try:
question_id = int(request.form.get('question'))
except ValueError:
return error('Missing question')
question = models.Question.query.get_or_404(question_id)
if question.multiple:
try:
answer_alt = set(map(int, request.form.getlist('alternative')))
except ValueError:
return error('Missing alternative')
correct_alt = correct_alternatives(question)
# Checking if all alternatives are correct
correct = correct_alt == answer_alt
else:
# Yes/No
answer = request.form.get('correct', False) == 'true'
correct = question.correct == answer
user = get_user()
answered = models.Stats.answered(user, question)
if not answered:
stat = models.Stats(user, question, correct)
models.db.session.add(stat)
models.db.session.commit()
return {'success': not answered, 'correct': correct}
def post(self):
try:
question_id = int(request.form.get('question'))
except ValueError:
return error('Missing question')
question = models.Question.query.get_or_404(question_id)
if question.multiple:
try:
answer_alt = set(map(int, request.form.getlist('alternative')))
except ValueError:
return error('Missing alternative')
correct_alt = correct_alternatives(question)
# Checking if all alternatives are correct
if question.exam.multiple_correct:
correct = correct_alt == answer_alt
else:
correct = correct_alt >= answer_alt
else:
# Yes/No
answer = request.form.get('correct', False) == 'true'
correct = question.correct == answer
user = get_user()
answered = models.Stats.answered(user, question)
if not answered:
stat = models.Stats(user, question, correct)
models.db.session.add(stat)
models.db.session.commit()
return {'success': not answered, 'correct': correct}
def serialize(self):
if self.exam.hidden:
user = get_user()
if not user.admin:
return None
response = {
'id': self.id,
'text': self.text,
'exam_id': self.exam_id,
'multiple': self.multiple,
'type': self.type.code
}
if self.multiple:
response['alternatives'] = []
for alt in self.alternatives:
alt_dict = alt.serialize()
del alt_dict['question_id']
response['alternatives'].append(alt_dict)
else:
response['correct'] = self.correct
if self.image:
if self.image.startswith('http://'):
response['image'] = self.image
else:
# this is not efficient
response['image'] = url_for(
'static',
filename='img/' + self.course.code + '/' + self.image)
return response
def serialize(self):
if self.exam.hidden:
user = get_user()
if not user.admin:
return None
response = {
'id': self.id,
'text': self.text,
'exam_id': self.exam_id,
'multiple': self.multiple,
'type': self.type.code
}
if self.multiple:
response['alternatives'] = []
for alt in self.alternatives:
alt_dict = alt.serialize()
del alt_dict['question_id']
response['alternatives'].append(alt_dict)
else:
response['correct'] = self.correct
if self.image:
if self.image.startswith('http://'):
response['image'] = self.image
else:
# this is not efficient
response['image'] = url_for('static', filename='img/' + self.course.code + '/' + self.image)
return response
def save_user(self, form):
user = get_user()
user.name = form.name.data
user.username = form.username.data
user.password = form.password.data
user.registered = True
models.db.session.add(user)
models.db.session.commit()
def save_user(self, form):
user = get_user()
user.name = form.name.data
user.username = form.username.data
user.password = form.password.data
user.registered = True
models.db.session.add(user)
models.db.session.commit()
def reset_stats_exam(course, exam):
"""Reset stats for a course"""
course = models.Course.query.filter_by(code=course).first_or_404()
exam = models.Exam.query.filter_by(course=course, name=exam).first_or_404()
stats_query = models.Stats.exam(get_user(), course.code, exam.name).with_entities(models.Stats.id).subquery()
models.Stats.query.filter(models.Stats.id.in_(stats_query)).\
update({models.Stats.reset: True}, synchronize_session=False)
models.db.session.commit()
return redirect(url_for('quiz.exam', course=course.code, exam=exam.name))
def reset_stats_course(course):
"""Reset stats for a course"""
# Check if course exists
course = models.Course.query.filter_by(code=course).first_or_404()
stats_query = models.Stats.course(get_user(), course.code).with_entities(models.Stats.id).subquery()
models.Stats.query.filter(models.Stats.id.in_(stats_query)).\
update({models.Stats.reset: True}, synchronize_session=False)
models.db.session.commit()
return redirect(url_for('quiz.course', course=course.code))
def reset_stats_course(course):
"""Reset stats for a course"""
# Check if course exists
course = models.Course.query.filter_by(code=course).first_or_404()
stats_query = models.Stats.course(get_user(), course.code).with_entities(
models.Stats.id).subquery()
models.Stats.query.filter(models.Stats.id.in_(stats_query)).\
update({models.Stats.reset: True}, synchronize_session=False)
models.db.session.commit()
return redirect(url_for('quiz.course', course=course.code))
def reset_stats_exam(course, exam):
"""Reset stats for a course"""
course = models.Course.query.filter_by(code=course).first_or_404()
exam = models.Exam.query.filter_by(course=course, name=exam).first_or_404()
stats_query = models.Stats.exam(get_user(), course.code,
exam.name).with_entities(
models.Stats.id).subquery()
models.Stats.query.filter(models.Stats.id.in_(stats_query)).\
update({models.Stats.reset: True}, synchronize_session=False)
models.db.session.commit()
return redirect(url_for('quiz.exam', course=course.code, exam=exam.name))
def serialize(self):
# Hack to hide hidden exams
if self.hidden:
user = get_user()
if not user.admin:
return None
return {
'id': self.id,
'name': self.name,
'course_id': self.course_id,
'multiple_correct': self.multiple_correct,
}
def serialize(self):
# Hack to hide hidden exams
if self.hidden:
user = get_user()
if not user.admin:
return None
return {
'id': self.id,
'name': self.name,
'course_id': self.course_id,
'multiple_correct': self.multiple_correct,
}
def random_id(id=None, course=None, exam=None):
"""
Returns a random id from questions that have not been answered.
Returns a random number if none available
"""
# All questions
questions = all_questions(course, exam)
# Already answered questions
if exam:
query = models.Stats.exam(get_user(), course, exam)
else:
query = models.Stats.course(get_user(), course)
answered = set(query.with_entities(models.Stats.question_id).all())
# List of indexes for unanswered questions
indexes = [i + 1 for i, question in enumerate(questions) if (i + 1) != id and question not in answered]
# Ignore current question
if indexes:
# Select random index
return random.choice(indexes)
else:
# All questions have been answered
return random.randint(1, len(questions) + 1)
def delete(self, object_id):
response = {}
user = get_user()
if not user.admin:
response['errors'] = [error('Admin access required')]
return response
object = self.model.query.get(object_id)
if object:
models.db.session.delete(object)
models.db.session.commit()
# Deleting cache
cache.clear()
return {'success': bool(object)}
def remove_admin_fields(self):
user = get_user()
delete_fields = []
for field in self:
name = field.name
model_field = getattr(field.meta.model, name, None)
if not model_field:
continue
if 'admin' in model_field.info and model_field.info['admin']:
if not user.admin:
delete_fields.append(name)
for field in delete_fields:
delattr(self, field)
def remove_admin_fields(self):
user = get_user()
delete_fields = []
for field in self:
name = field.name
model_field = getattr(field.meta.model, name, None)
if not model_field:
continue
if 'admin' in model_field.info and model_field.info['admin']:
if not user.admin:
delete_fields.append(name)
for field in delete_fields:
delattr(self, field)
def generate_stats(course_code, exam_name=None):
stats_data = {}
if not exam_name:
stats_data['max'] = max_questions_course(course_code)
stats = models.Stats.course(get_user(), course_code)
else:
stats_data['max'] = max_questions_exam(course_code, exam_name)
stats = models.Stats.exam(get_user(), course_code, exam_name)
stats_all = stats.all()
stats_data['total'] = len(stats_all)
stats_data['points'] = len(list(filter(lambda stat: stat.correct, stats_all)))
stats_data['grade'] = grade(stats_data['points'], stats_data['total'])
stats_data['percentage'] = percentage(stats_data['points'], stats_data['total'])
combo = 0
for stat in reversed(stats_all):
if stat.correct:
combo += 1
else:
break
stats_data['combo'] = combo
return stats_data
def delete(self, object_id):
response = {}
user = get_user()
if not user.admin:
response['errors'] = [error('Admin access required')]
return response
object = self.model.query.get(object_id)
if object:
models.db.session.delete(object)
models.db.session.commit()
# Deleting cache
cache.clear()
return {'success': bool(object)}
def generate_stats(course_code, exam_name=None):
stats_data = {}
if not exam_name:
stats_data['max'] = max_questions_course(course_code)
stats = models.Stats.course(get_user(), course_code)
else:
stats_data['max'] = max_questions_exam(course_code, exam_name)
stats = models.Stats.exam(get_user(), course_code, exam_name)
stats_all = stats.all()
stats_data['total'] = len(stats_all)
stats_data['points'] = len(
list(filter(lambda stat: stat.correct, stats_all)))
stats_data['grade'] = grade(stats_data['points'], stats_data['total'])
stats_data['percentage'] = percentage(stats_data['points'],
stats_data['total'])
combo = 0
for stat in reversed(stats_all):
if stat.correct:
combo += 1
else:
break
stats_data['combo'] = combo
return stats_data
def login():
user = get_user()
if user.registered:
flash('Du er allerede logget inn', 'error')
return redirect(url_for('quiz.main'))
if request.method == 'POST':
form = forms.LoginForm(request.form)
if form.validate():
# Login
user = models.User.query.filter_by(username=form.username.data).first()
if user and user.password == form.password.data:
session['user'] = user.id
return redirect(url_for('quiz.main'))
else:
form = forms.LoginForm()
context = dict(form=form)
return render_template('quiz/login.html', **context)
def login():
user = get_user()
if user.registered:
flash('you are already logged in', 'error')
return redirect(url_for('quiz.main'))
if request.method == 'POST':
form = forms.LoginForm(request.form)
if form.validate():
# Login
user = models.User.query.filter_by(
username=form.username.data).first()
if user and user.password == form.password.data:
session['user'] = user.id
return redirect(url_for('quiz.main'))
else:
form = forms.LoginForm()
context = dict(form=form)
return render_template('quiz/login.html', **context)
def post(self):
response = {}
user = get_user()
if not user.registered:
response['errors'] = [error('Not logged in')]
return response
form = self.form(request.form)
response['success'] = form.validate()
if form.validate():
# Inserting
object = self.model()
form.populate_obj(object)
models.db.session.add(object)
models.db.session.commit()
# Deleting cache
cache.clear()
else:
response['errors'] = form.errors
return response
def post(self):
response = {}
user = get_user()
if not user.registered:
response['errors'] = [error('Not logged in')]
return response
form = self.form(request.form)
response['success'] = form.validate()
if form.validate():
# Inserting
object = self.model()
form.populate_obj(object)
models.db.session.add(object)
models.db.session.commit()
# Deleting cache
cache.clear()
else:
response['errors'] = form.errors
return response
def put(self, object_id):
response = {'success': False}
user = get_user()
if not user.registered:
response['errors'] = [error('Not logged in')]
return response
object = self.model.query.get(object_id)
if not object:
response['errors'] = [error('Item not found')]
return response
form = self.form(request.form, obj=object)
form.populate_obj(object)
response['success'] = form.validate()
if response['success']:
models.db.session.add(object)
models.db.session.commit()
# Deleting cache
cache.clear()
else:
response['errors'] = form.errors
return response
def put(self, object_id):
response = {'success': False}
user = get_user()
if not user.registered:
response['errors'] = [error('Not logged in')]
return response
object = self.model.query.get(object_id)
if not object:
response['errors'] = [error('Item not found')]
return response
form = self.form(request.form, obj=object)
form.populate_obj(object)
response['success'] = form.validate()
if response['success']:
models.db.session.add(object)
models.db.session.commit()
# Deleting cache
cache.clear()
else:
response['errors'] = form.errors
return response
def post(self, *args, **kwargs):
self.get(*args, **kwargs)
answer = request.form.get('answer')
if answer:
self.answered = True
if self.question.multiple:
self.success = self.alternatives_correct()
else:
bool_answer = answer.lower() == 'true'
self.success = self.question.correct == bool_answer
user = get_user()
# Checking if question has already been answered
if not models.Stats.answered(user, self.question):
self.save_answer(user, self.success)
elif self.success:
flash('Du har allerede svart på dette spørsmålet så du får ikke noe poeng. :-)', 'info')
else:
flash('Blankt svar', 'error')
# Preserving order on submit
ordering = request.form.get('order')
if ordering:
self.reorder_alternatives(ordering)
def post(self, *args, **kwargs):
self.get(*args, **kwargs)
answer = request.form.get('answer')
if answer:
self.answered = True
if self.question.multiple:
self.success = self.alternatives_correct()
else:
bool_answer = answer.lower() == 'true'
self.success = self.question.correct == bool_answer
user = get_user()
# Checking if question has already been answered
if not models.Stats.answered(user, self.question):
self.save_answer(user, self.success)
elif self.success:
flash(
'Du har allerede svart på dette spørsmålet så du får ikke noe poeng. :-)',
'info')
else:
flash('Blankt svar', 'error')
# Preserving order on submit
ordering = request.form.get('order')
if ordering:
self.reorder_alternatives(ordering)
def post(self, *args, **kwargs):
self.get(*args, **kwargs)
answer = request.form.get('answer')
if answer:
self.answered = True
if self.question.multiple:
self.success = self.alternatives_correct()
else:
bool_answer = answer.lower() == 'true'
self.success = self.question.correct == bool_answer
user = get_user()
# Checking if question has already been answered
if not models.Stats.answered(user, self.question):
self.save_answer(user, self.success)
elif self.success:
flash(
'you have already answered this question so you will not get any points',
'info')
else:
flash('blank answer', 'error')
# Preserving order on submit
ordering = request.form.get('order')
if ordering:
self.reorder_alternatives(ordering)
def fetch_current_user_id():
# Return None if we are outside of request context.
if _request_ctx_stack.top is None:
return
return getattr(get_user(), 'id', None)
def get(self):
user = get_user()
if user.registered:
flash('Du er allerede logget inn', 'error')
return redirect(url_for('quiz.main'))
self.form = forms.RegisterForm()
def fetch_current_user_id():
# Return None if we are outside of request context.
if _request_ctx_stack.top is None:
return
return getattr(get_user(), 'id', None)
def get(self):
user = get_user()
if user.registered:
flash('Du er allerede logget inn', 'error')
return redirect(url_for('quiz.main'))
self.form = forms.RegisterForm()
def get(self):
user = get_user()
if user.registered:
flash('you are already logged in', 'error')
return redirect(url_for('quiz.main'))
self.form = forms.RegisterForm()
def utility_processor():
return dict(percentage=percentage, grade=grade, user=get_user())
