def get_questions(page, category):
if category == 'all':
questions = Question.query.all()
else:
if Category.query.filter(Category.type == category).count() == 0:
abort(404)
category_id = Category.query.filter(
Category.type == category).first().id
questions = Question.query.filter(
Question.category_id == category_id).all()
questions_per_page = 10
first_question_index = (page - 1) * questions_per_page
if len(questions) < first_question_index:
abort(404)
return get_response({
'current_category':
category,
'categories':
get_categories_as_list(),
'question_count':
len(questions),
'questions':
serialize_questions(
questions[first_question_index:(first_question_index +
questions_per_page)])
})
def add_result(user_id, question_id, success):
verify_user_id_exist_or_neg1(user_id)
verify_question_id_exists(question_id)
question = Question.query.filter(Question.id == question_id).first()
question.answer_attempt_count = Question.answer_attempt_count + 1
if success:
question.answer_success_count = Question.answer_success_count + 1
if user_id != -1:
user = User.query.filter(User.id == user_id).first()
user.questions_total = User.questions_total + 1
if success:
user.questions_won = User.questions_won + 1
db.session.commit()
question_info = serialize_question(
Question.query.filter(Question.id == question_id).first())
if user_id != -1:
user_info = serialize_user(
User.query.filter(User.id == user_id).first())
else:
user_info = 'None'
return get_response({'user': user_info, 'question': question_info})
def create_new_category(name):
verify_category_does_not_exists(name)
new_category = Category()
new_category.type = name
save(new_category)
return get_response({'category': name})
def delete_question(question_id):
q = Question.query.get(question_id)
if q is None:
abort(404)
delete(q)
return get_response({'question': question_id})
def create_test(name):
test = Test.query.filter(Test.name == name).first()
if test is None:
new_test = Test()
new_test.name = name
db.session.add(new_test)
db.session.commit()
return get_response(test_to_short_string(new_test))
else:
abort(422, "Name already exists")
def create_new_user(name):
verify_user_does_not_exist(name)
new_user = User()
new_user.name = name
new_user.questions_total = 0
new_user.questions_won = 0
save(new_user)
return get_response({'name': name})
def register_test_result(user_id, test_id, time, value):
if Test.query.get(test_id) is None:
abort(404)
result = TestResult()
result.user_id = user_id
result.test_id = test_id
result.time = parser.parse(time)
result.value = value
db.session.add(result)
db.session.commit()
return get_response(result_to_short_string(result))
def get_random_question(used_questions, category):
if category == 'all':
questions = Question.query.filter(
~Question.id.in_(used_questions)).all()
else:
verify_category_exists(category)
cat_id = Category.query.filter(Category.type == category).first().id
questions = Question.query.filter(Question.category_id == cat_id) \
.filter(~Question.id.in_(used_questions)).all()
if len(questions) <= 0:
abort(404, 'No suitable question found')
return get_response(serialize_question(random.choice(questions)))
def delete_result(user_id, result_id):
result = TestResult.query.get(result_id)
if result is None:
abort(404)
if result.user_id != user_id:
raise AuthError(
{
'code': 'unauthorized',
'description': 'Test result belongs to another user.'
}, 403)
db.session.delete(result)
db.session.commit()
return get_response(result_id)
def create_new_question(question, answer, category, difficulty):
verify_category_exists(category)
if difficulty not in [1, 2, 3, 4, 5]:
abort(422, "difficulty must be an integer between 1-5")
cat_id = Category.query.filter(Category.type == category).first().id
new_question = Question()
new_question.question = question
new_question.answer = answer
new_question.category_id = cat_id
new_question.difficulty = difficulty
new_question.answer_success_count = 0
new_question.answer_attempt_count = 0
save(new_question)
return get_response({'question': serialize_question(new_question)})
def search_for_question(search_term, page):
questions = Question.query.filter(
Question.question.ilike('%{}%'.format(search_term))).all()
questions_per_page = 10
first_question_index = (page - 1) * questions_per_page
if len(questions) <= first_question_index:
abort(404)
return get_response({
'question_count':
len(questions),
'questions':
serialize_questions(
questions[first_question_index:(first_question_index +
questions_per_page)])
})
def update_test_result(user_id, result_id, time, value):
result = TestResult.query.get(result_id)
if result is None:
abort(404)
if result.user_id != user_id:
raise AuthError(
{
'code': 'unauthorized',
'description': 'Test result belongs to another user.'
}, 403)
if time != '':
result.time = parser.parse(time)
if value != '':
result.value = value
db.session.commit()
return get_response(result_to_short_string(result))
def get_test_results(user_id, test_id):
if User.query.get(user_id) is None:
abort(404)
if test_id == -1:
results = TestResult.query.filter(TestResult.user_id == user_id).all()
else:
if Test.query.get(test_id) is None:
abort(404)
results = TestResult.query.filter(
TestResult.user_id == user_id).filter(
TestResult.test_id == test_id).all()
data = []
for result in results:
data.append(result_to_short_string(result))
# todo: test_id and user_id are duplications...
return get_response({'test_id': test_id, 'user_id': user_id, 'data': data})
def get_categories():
return get_response(get_categories_as_list())
def unprocessable(error):
return get_response("Unprocessable: " + error.description, False, 422), 422
def get_users():
data = []
for user in User.query.all():
data.append(serialize_user(user))
return get_response(data)
def get_tests():
tests = Test.query.all()
data = []
for test in tests:
data.append(test_to_short_string(test))
return get_response(data)
def update_profile(user_id, name):
user = User.query.get(user_id)
user.name = name
db.session.commit()
return get_response(user_to_short_string(user))
def get_profile(user_id):
user = User.query.get(user_id)
return get_response(user_to_short_string(user))
def get_available_users():
users = User.query.all()
result = []
for user in users:
result.append(user_to_short_string(user))
return get_response(result)
def not_found(error):
return get_response("Not found: " + error.description, False, 404), 404
def not_implemented(error):
return get_response("Not Implemented: " + error.description, False,
501), 501
