def get_activity(self):
activity = db.session.query(Activity).filter_by(tid=self.tid).order_by(Activity.timestamp.desc()).all()
result = [ ]
for a in activity:
result.append({
"timestamp": utils.isoformat(a.timestamp),
"message": a.get_message()
})
return result
def problem_solves():
params = utils.flat_multi(request.form)
pid = params.get("pid")
solves_return = []
solves = Solves.query.filter_by(pid=pid,correct=True).order_by("date asc").all()
for solve in solves:
data = {
"teamname": Teams.query.filter_by(tid=solve.tid).first().teamname,
"date": utils.isoformat(float(solve.date))
}
solves_return.append(data)
return { "success": 1, "solves": solves_return }
def get_solves(self):
solves = Solves.query.filter_by(tid=self.tid, correct=True).all()
result = []
for solve in solves:
prob = Problems.query.filter_by(pid=solve.pid).first()
result.append({
"date": utils.isoformat(float(solve.date)),
"problem": prob.title,
"value": solve.get_value(),
"solved_by": Users.query.filter_by(uid=solve.uid).first().username
})
return result
def get_submissions():
submissions_return = []
tid = session.get("tid")
submissions = ProgrammingSubmissions.query.filter_by(tid=tid).order_by(ProgrammingSubmissions.psid.desc()).all()
if submissions is not None:
for submission in submissions:
_problem = problem.get_problem(pid=submission.pid).first()
submissions_return.append({
"psid": submission.psid,
"title": _problem.title if _problem else "",
"message": submission.message,
"log": submission.log,
"date": utils.isoformat(submission.date),
"number": submission.number,
"duration": submission.duration
})
return { "success": 1, "submissions": submissions_return }
def get_replies(self):
replies = []
for reply in TicketReplies.query.filter_by(htid=self.htid).all():
uid = reply.author
user = Users.query.filter_by(uid=uid).first()
if user is not None:
username = user.username
else:
username = ""
replies.append({
"trid": reply.trid,
"body": markdown2.markdown(reply.body),
"date": utils.isoformat(reply.date),
"uid": uid,
"username": username
})
return replies
def transmit_to_s3(timestamp, records):
"""Transmit logfiles to S3 with default config."""
# No need to configure credentials, we've already confirmed they are in the environment.
s3 = boto3.client('s3', region_name=s3config['region'])
# Grouping in the key is important, we need this to zoom into an interesting
# log period.
key = s3config.get('prefix', '') + utils.isoformat(timestamp).replace(
'T', '/') + s3config.get('postfix', '') + '.jsonl'
# Store as json-lines format
body = '\n'.join(json.dumps(r) for r in records)
s3.put_object(
Bucket=s3config['bucket'],
Key=key,
StorageClass='STANDARD_IA', # Cheaper, applicable for logs
Body=body)
logging.debug(
f'Wrote {len(records)} query logs to s3://{s3config["bucket"]}/{key}'
)
def user_twofactor_verify():
_user = get_user().first()
if _user is None:
raise WebException("User not found.")
params = utils.flat_multi(request.form)
pwd = params.get("password")
if pwd is None:
raise WebException("Please enter your password.")
if not utils.check_password(_user.password, pwd):
raise WebException("Incorrect password.")
if "token" not in params:
raise WebException("Invalid token.")
token = params.get("token")
if not(_user.verify_totp(int(token))):
raise WebException("Invalid token. Current server time: %s" % utils.isoformat(float(utils.get_time_since_epoch())))
with app.app_context():
Users.query.filter_by(uid=_user.uid).update({ "otp_confirmed": True })
db.session.commit()
db.session.close()
return { "success": 1, "message": "Confirmed!" }
def ticket_data():
opened = []
closed = []
_user = user.get_user().first()
if _user is None:
raise WebException("User does not exist.")
params = utils.flat_multi(request.args)
htid = params.get("htid")
if htid is not None:
result = get_ticket(htid=htid).first()
elif user.is_admin():
result = get_ticket().all()
else:
result = get_ticket(author=_user.uid).all()
if result is not None:
if htid is not None:
tickets = [result]
else:
tickets = result
for ticket in tickets:
tmp = user.get_user(uid=ticket.author).first()
if tmp is not None:
username = tmp.username
uid = tmp.uid
else:
username = ""
uid = ""
replies = ticket.get_replies()
d = {
"htid":
ticket.htid,
"date":
utils.isoformat(ticket.date),
"opened":
ticket.opened,
"username":
username,
"uid":
uid,
"title":
ticket.title,
"body":
markdown2.markdown(ticket.body),
"replies":
replies,
"participants":
list(set([username] + [reply["username"]
for reply in replies])),
"you": {
"username": _user.username,
"uid": _user.uid
}
}
if htid is None:
if d["opened"] == True:
opened.append(d)
else:
closed.append(d)
else:
data = d
else:
data = {}
if htid is None:
data = [opened, closed]
return {"success": 1, "data": data}
def submit_program():
params = utils.flat_multi(request.form)
pid = params.get("pid")
tid = session.get("tid")
_user = user.get_user().first()
language = params.get("language")
submission_contents = params.get("submission")
_problem = problem.get_problem(pid=pid).first()
if _problem is None:
raise WebException("Problem does not exist.")
if _problem.category != "Programming":
raise WebException("Can't judge this problem.")
if language not in extensions:
raise WebException("Language not supported.")
solved = Solves.query.filter_by(pid=pid, tid=tid, correct=1).first()
if solved:
raise WebException("You already solved this problem.")
judge_folder = os.path.join(app.config["GRADER_FOLDER"], pid)
if not os.path.exists(judge_folder):
os.makedirs(judge_folder)
submission_folder = os.path.join(judge_folder, utils.generate_string())
while os.path.exists(submission_folder):
submission_folder = os.path.join(judge_folder, utils.generate_string())
os.makedirs(submission_folder)
submission_path = os.path.join(submission_folder, "program.%s" % extensions[language])
open(submission_path, "w").write(submission_contents)
message, log, duration = judge(submission_path, language, pid)
number = ProgrammingSubmissions.query.filter_by(tid=tid).with_entities(ProgrammingSubmissions.number).order_by(ProgrammingSubmissions.number.desc()).first()
if number is None:
number = 1
else:
number = number[0] + 1
submission = ProgrammingSubmissions(pid, tid, submission_path, message, log, number, duration)
correct = message == "Correct!"
with app.app_context():
solve = Solves(pid, _user.uid, tid, submission_path, correct)
db.session.add(solve)
db.session.add(submission)
db.session.commit()
if correct:
# Wait until after the solve has been added to the database before adding bonus
solves = problem.get_solves(pid=pid)
solve.bonus = [-1, solves][solves < 3]
db.session.add(solve)
cache.invalidate_memoization(problem.get_solves, pid)
if _user:
activity = UserActivity(_user.uid, 3, tid=tid, pid=pid)
db.session.add(activity)
db.session.commit()
new = {
"psid": submission.psid,
"title": _problem.title,
"message": submission.message,
"log": submission.log,
"date": utils.isoformat(submission.date),
"number": submission.number
}
shutil.rmtree(submission_folder)
return { "success": message == "Correct!", "message": message , "new_submission": new }
def ticket_data():
opened = []
closed = []
_user = user.get_user().first()
if _user is None:
raise WebException("User does not exist.")
params = utils.flat_multi(request.args)
htid = params.get("htid")
if htid is not None:
result = get_ticket(htid=htid).first()
elif user.is_admin():
result = get_ticket().all()
else:
result = get_ticket(author=_user.uid).all()
if result is not None:
if htid is not None:
tickets = [result]
else:
tickets = result
for ticket in tickets:
tmp = user.get_user(uid=ticket.author).first()
if tmp is not None:
username = tmp.username
uid = tmp.uid
else:
username = ""
uid = ""
replies = ticket.get_replies()
d = {
"htid": ticket.htid,
"date": utils.isoformat(ticket.date),
"opened": ticket.opened,
"username": username,
"uid": uid,
"title": ticket.title,
"body": markdown2.markdown(ticket.body),
"replies": replies,
"participants": list(set([username] + [reply["username"] for reply in replies])),
"you": {
"username": _user.username,
"uid": _user.uid
}
}
if htid is None:
if d["opened"] == True:
opened.append(d)
else:
closed.append(d)
else:
data = d
else:
data = {}
if htid is None:
data = [opened, closed]
return { "success": 1, "data": data }
def submit_program():
params = utils.flat_multi(request.form)
pid = params.get("pid")
tid = session.get("tid")
_user = user.get_user().first()
language = params.get("language")
submission_contents = params.get("submission")
_problem = problem.get_problem(pid=pid).first()
if _problem is None:
raise WebException("Problem does not exist.")
if _problem.category != "Programming":
raise WebException("Can't judge this problem.")
if language not in extensions:
raise WebException("Language not supported.")
solved = Solves.query.filter_by(pid=pid, tid=tid, correct=1).first()
if solved:
raise WebException("You already solved this problem.")
judge_folder = os.path.join(app.config["GRADER_FOLDER"], pid)
if not os.path.exists(judge_folder):
os.makedirs(judge_folder)
submission_folder = os.path.join(judge_folder, utils.generate_string())
while os.path.exists(submission_folder):
submission_folder = os.path.join(judge_folder, utils.generate_string())
os.makedirs(submission_folder)
submission_path = os.path.join(submission_folder,
"program.%s" % extensions[language])
open(submission_path, "w").write(submission_contents)
message, log, duration = judge(submission_path, language, pid)
number = ProgrammingSubmissions.query.filter_by(tid=tid).with_entities(
ProgrammingSubmissions.number).order_by(
ProgrammingSubmissions.number.desc()).first()
if number is None:
number = 1
else:
number = number[0] + 1
submission = ProgrammingSubmissions(pid, tid, submission_path, message,
log, number, duration)
correct = message == "Correct!"
with app.app_context():
solve = Solves(pid, _user.uid, tid, submission_path, correct)
db.session.add(solve)
db.session.add(submission)
db.session.commit()
if correct:
# Wait until after the solve has been added to the database before adding bonus
solves = problem.get_solves(pid=pid)
solve.bonus = [-1, solves][solves < 3]
db.session.add(solve)
cache.invalidate_memoization(problem.get_solves, pid)
if _user:
activity = UserActivity(_user.uid, 3, tid=tid, pid=pid)
db.session.add(activity)
db.session.commit()
new = {
"psid": submission.psid,
"title": _problem.title,
"message": submission.message,
"log": submission.log,
"date": utils.isoformat(submission.date),
"number": submission.number
}
shutil.rmtree(submission_folder)
return {
"success": message == "Correct!",
"message": message,
"new_submission": new
}
def get_stats(self):
result = { "problems": [] }
n_solved = [0, 0]
for solve in list(Solves.query.filter_by(uid=self.uid).all()):
if solve.correct == True:
n_solved[0] += 1
problem = Problems.query.filter_by(pid=solve.pid).first()
result["problems"].append({ "title": problem.title, "value": solve.get_value(), "category": problem.category, "date": utils.isoformat(float(solve.date)) })
n_solved[1] += 1
result["correct_submissions"] = n_solved[0]
result["total_submissions"] = n_solved[1]
return result
def get_stats(self):
result = { "problems": [] }
n_solved = [0, 0]
for solve in list(Solves.query.filter_by(uid=self.uid).all()):
if solve.correct == True:
n_solved[0] += 1
problem = Problems.query.filter_by(pid=solve.pid).first()
result["problems"].append({ "title": problem.title, "value": solve.get_value(), "category": problem.category, "date": utils.isoformat(float(solve.date)) })
n_solved[1] += 1
result["correct_submissions"] = n_solved[0]
result["total_submissions"] = n_solved[1]
return result
