def home():
""" Display home page """
return {
"user": get_user(),
"base": "Welcome to the home page. It is underconstruction",
"admin": user_is_admin(get_user())
}
def submit(db, pid):
"""Submits student uploaded solution"""
ct = datetime.now()
user = get_user()
#gets solution from form and checks language
solution = request.files.get("solution")
name, ext = os.path.splitext(solution.filename)
if ext not in ('.py'):
return "File extension not allowed."
#gets input and output for the specific problem
fb = [pid]
db.execute(
"""select name, sampleIn, sampleOut from problems where id = %s""", fb)
result = db.fetchall()
for name, sampleIn, sampleOut in result:
name = name
sampleIn = sampleIn
sampleOut = sampleOut
#saves file into a tmp folder
solution_save_path = f"COMP523/container/submissions"
solution_file_path = "{path}/{file}".format(path=solution_save_path,
file=solution.filename)
solution.save(solution_file_path)
with open("COMP523/container/submissions/sampleInput.txt",
"w") as input_file:
print(f"{sampleIn}", file=input_file)
#TO DO: add different functions depending on language submitted. just need to create a check_ouput for each language
#runs uploaded script with sampleIn and tests that the script output matches sampleOut
try:
script_output = run_submission(solution.filename)
script_output = " ".join(script_output.split())
sampleOut = " ".join(sampleOut.split())
check_submission = (script_output == sampleOut)
except:
#if error, submission check is false
check_submission = False
#insert this submission instance into db
fb = [ct, name, user, True, check_submission]
db.execute(
"""insert into user_submissions (date, name, onyen, submitted, correct)
values(%s, %s, %s, %s, %s)""",
fb,
)
#deletes the file from the tmp folder
if os.path.exists(solution_file_path):
os.remove(solution_file_path)
return template(
'Successfully Submitted "{{name}}" for {{user}}! You may close this tab.',
name=name,
user=user)
def not_found(db):
"""Return a custom 404 message"""
user = get_user()
now = datetime.now()
ip = request.remote_addr
url = request.url
db.execute("""insert into notfound (time, onyen, ip, url) values (%s, %s, %s, %s)""",
[now, user, ip, url])
db.connection.commit() # Need to commit as 404 is a bad return code
msg = f"""Sorry {user}: File not found. Every access is recorded."""
raise bottle.HTTPError(404, msg)
def renderTemplate(name, **kwargs):
"""Render a template being careful to handle errors"""
try:
result = template(name, dotenv_values, **kwargs)
return result
except:
user = get_user()
if user_is_admin(user):
result = html.escape(traceback.format_exc())
result = f"\n<pre>{result}</pre>"
return result
raise
def get_team(db):
''' Get the user's team number '''
user = get_user()
db.execute("""
select R.onyen, R.name
from roll R, teams T
where T.onyen = R.onyen and
T.number = (select number from teams where onyen = %s)
order by R.name
""",
[user],
)
result = db.fetchall()
return result
def submissions(db, name):
"""Gets submissions for certain problem from db given user"""
user = get_user()
fb = [user, name]
db.execute(
"""select id, date, onyen, name, submitted, correct from user_submissions where onyen = %s and name = %s order by date desc""",
fb,
)
result = db.fetchall()
submissions = []
for id, date, onyen, name, submitted, correct in result:
submissions.append({
"id": id,
"date": date,
"onyen": onyen,
"name": name,
"submitted": submitted,
"correct": correct
})
return dict(data=submissions)
def syllabi(page_name, db):
"""Render a page such as the syllabus, help, etc."""
user = get_user()
if user_is_admin(user) and request.query.user:
original_user = user
user = request.query.user
else:
original_user = ''
if not user_in_roll(user, db):
log(f"syllabi: {user} not enrolled in COMP523.")
path = f"views/COMP523/{page_name}.html"
if not osp.exists(path):
not_found(db)
title = ""
with open(path, "rt") as fp:
top = fp.readline()
if top.startswith("# "):
title = title + top[2:].strip()
content = renderTemplate(path, user=user, title=title)
content = renderMarkdown(content)
if original_user == '':
db.execute(
"""
insert into fetched (time, onyen, key, ip, pages, url) values (%s, %s, %s, %s, %s, %s)""",
[
datetime.now(), user, page_name, request.remote_addr, [],
request.url
],
)
return {
"base": content,
"title": title,
"user": user,
"admin": user_is_admin(user),
"agenda_type": 'student'
}
def not_allowed():
"""Return a custom 405 message"""
user = get_user()
msg = f"""Sorry {user}: It appears you are not registered for this class."""
raise bottle.HTTPError(405, msg)
def get_token():
"""Give the token to an admin"""
user = get_user()
return {"user": user, "token": makeToken(user)}
def get_questions(key, db): # pylint: disable=too-many-statements
"""
Allow rendering a set of questions from a template stored in
the questions folder.
"""
user = get_user()
if 'userid' in request.query:
raise bottle.HTTPError(401, "Invalid parameter userid")
if 'onyen' in request.query:
raise bottle.HTTPError(401, "Invalid parameter onyen")
if user_is_admin(user) and request.query.user:
original_user = user
user = request.query.user
else:
original_user = ''
if not user_in_roll(user, db):
not_allowed()
path = f"content/{course_name}/{request.path}.tmd"
now = datetime.now()
if not osp.exists(path):
log(f"mypoll{request.path}: path {path} not found")
not_found(db)
ip = request.remote_addr
inp = inputs(key)
db.execute(
"""
select extended, section, rid, zwsp
from roll
where onyen = %s """, [user])
row = db.fetchone()
section = row and row.section
extended = row and row.extended
zwsp = row and row.zwsp # pylint: disable=possibly-unused-variable
rid = row and row.rid
# get the answers as a json formatted string
db.execute(
"""
select info, questions from rubrics
where key = %s""",
[key],
)
row = db.fetchone()
if row is None:
rubrics = {}
pages = []
info = {}
print("no rubrics")
else:
rubrics = editRubrics(row.questions)
info = row.info
pages = info.get('pages', [])
pages = get_activePages(db, key, user, section, pages)
if (('pages' in info) and (pages is not None) and (len(pages) == 0)):
log(f"mypoll/{request.path}: pages=({pages}) so no page shown")
not_found(db)
base = renderTemplate(path,
user=user,
key=key,
pages=pages,
rid=rid,
section=section,
constant_e=math.e,
constant_pi=math.pi,
log=math.log,
**inp.env())
if base.startswith("\n<pre>"):
# renderTemplate raised an exception
return base
base = renderMarkdown(base)
# Collect up info variables for psform
# pylint: disable=possibly-unused-variable
exam = inp.info.get("exam")
autosave = ((request.path.find("/exams/") == 0)
or (request.path.find("/quizzes/") == 0)
or (request.path.find("/worksheets/") == 0))
includeTimer = extended and exam
due = inp.info.get("due")
result = renderTemplate("psform", **locals())
# hold the lock for as little time as possible
if original_user == '':
db.execute(
"""
insert into fetched (time, onyen, key, ip, pages, url) values (%s, %s, %s, %s, %s, %s)""",
[now, user, key, ip, pages, request.url],
)
return result
