def parse():
"""
Parses an excel spreadsheet and returns students
"""
try:
if "excel_doc" not in request.files:
return bad_request()
excel_doc = request.files["excel_doc"]
if not models.allowed_file(excel_doc.filename):
return bad_request()
file_path = models.save_excel_doc(excel_doc)
students = models.parse_students(file_path)
os.remove(file_path)
except ValueError as e:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success(students)
def edit_quiz(quiz_id):
"""
Changes quiz info
"""
try:
body = request.get_json()
name = body["name"]
start_date = body["start_date"]
end_date = body["end_date"]
description = body["description"]
language = body["language"]
if not models.check_dates(
start_date, end_date) and not models.check_languages(language):
return bad_request()
models.edit_quiz(quiz_id, name, start_date, end_date, description,
language)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success()
def create_quiz(course_id):
"""
Creates a quiz
"""
try:
body = request.get_json()
name = body["name"]
start_date = body["start_date"]
end_date = body["end_date"]
description = body["description"]
language = body["language"]
if not models.check_dates(
start_date, end_date) and not models.check_languages(language):
return bad_request()
quiz_id = models.insert_quiz(course_id, name, start_date, end_date,
description, language)
except KeyError:
return bad_request()
except Exception:
return server_error()
return created({"quiz_id": quiz_id})
def activate():
"""
Activates a student account and set's there password
"""
try:
body = request.get_json()
activate_token = body["activate_token"]
password = body["password"]
if len(password) < 3 or len(password) > 50:
return bad_request()
if not models.token_exists(activate_token):
return bad_request()
student_hash = models.create_hash(password)
models.save_hash(student_hash, activate_token)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return created()
def signin():
"""
Signs in either a teacher or a student
"""
try:
body = request.get_json()
email = body["email"]
password = body["password"]
# Returns the user_id (either teacher or student) and if the user is a teacher or a student
user_id, is_teacher = models.id_from_credentials(email, password)
if not user_id:
return bad_request()
token = models.create_token()
models.save_token(token, user_id, is_teacher)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({
"token": token,
"teacher_id" if is_teacher else "student_id": user_id
})
def precheck(qc_id, question_id):
"""
Adds one question to a quiz
"""
try:
student_id = request.student_id if hasattr(
request, "student_id") else str(uuid.uuid4().hex)
body = request.get_json()
code = body["code"]
filename = models.precheck_file_name(student_id, qc_id, question_id)
filepath = os.path.join("app", "packages", "quizzes", "question_files",
filename)
with open(filepath, "w") as f:
f.write(code)
bashCommand = "pylint --errors-only {}".format(filepath)
process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
process.wait()
output, _ = process.communicate()
os.remove(filepath)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({"output": output.decode()})
def change_class(class_id):
"""
Changes information about a class
"""
try:
body = request.get_json()
name = body["name"]
if not name:
return bad_request()
models.change_class(class_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return success()
def change_course(course_id):
"""
Changes name of a course
"""
try:
body = request.get_json()
name = body["name"]
if not name:
return bad_request()
models.change_course(course_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return success()
def create():
"""
Creates a class
"""
try:
body = request.get_json()
teacher_id = request.teacher_id
name = body["name"]
if not name:
return bad_request()
class_id = models.insert_class(teacher_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return created({"class_id": class_id})
def add_class(course_id):
"""
Adds a class to a course
"""
try:
body = request.get_json()
teacher_id = request.teacher_id
class_id = body["id"]
if not models.class_exists(teacher_id, class_id):
return bad_request()
models.add_class(course_id, class_id)
except KeyError:
return bad_request()
except Exception:
return server_error()
return success()
def check(qc_id, question_id):
"""
Checks students code for a particular question against test cases
"""
try:
# If user is not a student, assign them random uuid for filename
student_id = request.student_id if hasattr(
request, "student_id") else str(uuid.uuid4().hex)
body = request.get_json()
code = body["code"]
code_runner = CodeRunner(student_id, qc_id, question_id)
code_runner.write_code(code) # Writes students code to file
test_cases = models.get_test_cases(question_id)
# question_worth, total_negated and last_attempt_wrong only valid for free quiz!
results, question_worth, total_negated, last_attempt_wrong = code_runner.run(
test_cases)
code_runner.remove_code() # Deletes students code
# If user is not student or the quiz is a free quiz, then don't save their attempt
if hasattr(request, "is_free_quiz"):
return success({
"results": results,
"question_worth": question_worth,
"total_negated": total_negated,
"last_attempt_wrong": last_attempt_wrong
})
attempt_id = models.insert_attempt(question_id, student_id)
models.insert_test_cases(results, attempt_id)
question_worth, total_negated, last_attempt_wrong = models.get_mark_worth(
question_id, student_id)
except KeyError as e:
print(e)
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({
"results": results,
"question_worth": question_worth,
"total_negated": total_negated,
"last_attempt_wrong": last_attempt_wrong
})
def signup():
"""
Signs a teacher up and returns their id
"""
try:
body = request.get_json()
name = body["name"]
email = body["email"]
password = body["password"]
# Checks if email is taken in the teacher or student table
if models.taken_email(email):
return bad_request()
teacher_hash = models.create_hash(password)
teacher_id = models.insert_teacher(name, email, teacher_hash)
except KeyError:
return bad_request()
except Exception:
return server_error()
return created({"teacher_id": teacher_id})
def create_free_quizzes():
"""
Creates a free quiz
"""
try:
json = request.get_json()
quiz_name = json["quiz_name"]
quiz_language_id = json["quiz_language_id"]
quiz_short_desc = json["quiz_short_desc"]
models.create_free_quiz(quiz_name, quiz_language_id, quiz_short_desc)
except KeyError as e:
print(e)
return bad_request()
# Error checking will be done in create_free_quiz route and will return ValueError if so
except ValueError as e:
print(e)
return bad_request()
except Exception:
return server_error()
return created()
def questions(quiz_id):
"""
Adds one question to a quiz
"""
try:
json = request.get_json()
description = json["description"]
question_id = models.add_question(quiz_id, description)
except KeyError:
return bad_request()
except Exception as e:
return server_error()
return created({"question_id": question_id})
def update_question(quiz_id, question_id):
"""
Updates a question from a quiz
"""
try:
json = request.get_json()
question_description = json["question_description"]
models.update_description(question_description, question_id)
except (KeyError, ValueError):
return bad_request()
except Exception as e:
return server_error()
return success()
def create_test_case(quiz_id, question_id):
"""
Creates a test case
"""
try:
json = request.get_json()
test_input = json["test_input"]
test_expected = json["test_expected"]
test_id = models.create_test_case(question_id, test_input,
test_expected)
except (KeyError, ValueError):
return bad_request()
except Exception as e:
print(e)
return server_error()
return created({"test_id": test_id})
def add_students(class_id):
"""
Adds students to the database
"""
try:
body = request.get_json()
teacher_id = request.teacher_id
students = body["students"]
emails = []
for email in students:
emails.append(email["email"])
models.insert_students(students, teacher_id)
models.delete_unique()
models.insert_into_class(class_id, tuple(emails))
except KeyError:
return bad_request()
except Exception:
return server_error()
return created()
