def problem_feedback_hook():
feedback = json.loads(request.form.get("feedback", ""))
pid = request.form.get("pid", None)
if feedback is None or pid is None:
return WebError("Please supply a pid and feedback.")
if not api.config.get_settings()["enable_feedback"]:
return WebError("Problem feedback is not currently being accepted.")
api.problem_feedback.add_problem_feedback(pid, api.auth.get_uid(), feedback)
return WebSuccess("Your feedback has been accepted.")
def create_simple_user_hook():
settings = api.config.get_settings()
new_uid = api.user.create_simple_user_request(
api.common.flat_multi(request.form))
#Only automatically login if we don't have to verify
if api.user.get_user(uid=new_uid)["verified"]:
session['uid'] = new_uid
return WebSuccess("User '{}' registered successfully!".format(
request.form["username"]))
def get_problem_data_hook():
has_instances = lambda p: len(p["instances"]) > 0
problems = list(
filter(has_instances, api.problem.get_all_problems(show_disabled=True)))
for problem in problems:
problem["reviews"] = api.problem_feedback.get_problem_feedback(
pid=problem["pid"])
data = {"problems": problems, "bundles": api.problem.get_all_bundles()}
return WebSuccess(data=data)
def reassign_teams_hook():
if not api.config.get_settings()["shell_servers"]["enable_sharding"]:
return WebError(
"Enable sharding first before assigning server numbers.")
else:
include_assigned = request.form.get("include_assigned", False)
count = api.shell_servers.reassign_teams(
include_assigned=include_assigned)
if include_assigned:
action = "reassigned."
else:
action = "assigned."
return WebSuccess(str(count) + " teams " + action)
def status_hook():
status = {
"logged_in": api.auth.is_logged_in(),
"admin": api.user.is_admin(),
"teacher": api.auth.is_logged_in() and api.user.is_teacher(),
"enable_teachers": api.config.enable_teachers,
"shell": api.config.enable_shell,
"enable_captcha": api.config.enable_captcha,
"competition_active": api.utilities.check_competition_active(),
"username": api.user.get_user()['username'] if api.auth.is_logged_in() else ""
}
return WebSuccess(data=status)
def get_group_score_hook():
name = request.args.get("group-name")
user = api.user.get_user()
roles = api.group.get_roles_in_group(gid, uid=user["uid"])
if not roles["teacher"]:
return WebError("You are not a teacher for this group.")
score = api.stats.get_group_scores(name=name)
if score is None:
return WebError("There was an error retrieving the group's score.")
return WebSuccess(data={'score': score})
def check_status_of_shell_server():
sid = request.args.get("sid", None)
if sid is None:
return WebError("Must provide sid to load from.")
all_online, data = api.shell_servers.get_problem_status_from_server(sid)
if all_online:
return WebSuccess("All problems are online", data=data)
else:
return WebError(
"One or more problems are offline. Please connect and fix the errors.",
data=data)
def submit_key_hook():
user_account = api.user.get_user()
tid = user_account['tid']
uid = user_account['uid']
pid = request.form.get('pid', '')
key = request.form.get('key', '')
ip = request.remote_addr
result = api.problem.submit_key(tid, pid, key, uid, ip)
if result['correct']:
return WebSuccess(result['message'], result['points'])
else:
return WebError(result['message'], {'code': 'wrong'})
def get_scoreboard_hook():
result = {}
result['public'] = api.stats.get_all_team_scores()
result['groups'] = []
if api.auth.is_logged_in():
for group in api.team.get_groups():
result['groups'].append({
'gid': group['gid'],
'name': group['name'],
'scoreboard': api.stats.get_group_scores(gid=group['gid'])
})
return WebSuccess(data=result)
def get_problem_solves_hook():
pid = request.args.get('pid', '')
solves = api.stats.get_problem_solves(pid=pid)
filtered = []
for solve in solves:
team = api.team.get_team(tid=solve["tid"])["team_name"]
date = solve["timestamp"].strftime("%B %d, %Y %I:%M %p")
data = {
"team": team,
"date": date
}
filtered.append(data)
return WebSuccess(data=filtered)
def force_leave_group_hook():
gid = request.form.get("gid")
tid = request.form.get("tid")
if gid is None or tid is None:
return WebError("You must specify a gid and tid.")
user = api.user.get_user()
roles = api.group.get_roles_in_group(gid, uid=user["uid"])
if not roles["teacher"]:
return WebError("You must be a teacher of a group to remove a team.")
api.group.leave_group(gid, tid)
return WebSuccess("Team has successfully left the group.")
def change_group_settings_hook():
gid = request.form.get("gid")
settings = json.loads(request.form.get("settings"))
user = api.user.get_user()
group = api.group.get_group(gid=gid)
roles = api.group.get_roles_in_group(gid=group["gid"], uid=user["uid"])
if roles["teacher"]:
api.group.change_group_settings(group["gid"], settings)
return WebSuccess(message="Group settings changed successfully.")
else:
return WebError(
message="You do not have sufficient privilege to do that.")
def bundle_dependencies():
bid = request.form.get("bid", None)
state = request.form.get("state", None)
if bid is None:
return WebError("Must provide bid to load from.")
if state is None:
return WebError("Must provide a state to set.")
state = bson.json_util.loads(state)
api.problem.set_bundle_dependencies_enabled(bid, state)
return WebSuccess(
"Dependencies are now {}.".format("enabled" if state else "disabled"))
def change_problem_availability_hook():
pid = request.form.get("pid", None)
desired_state = request.form.get("state", None)
state = None
# This feels really bad. Why doesn't Flask serialize it to the correct type?
if desired_state == "true":
state = True
elif desired_state == "false":
state = False
else:
return WebError("Problems are either enabled or disabled.")
api.admin.set_problem_availability(pid, state)
return WebSuccess(data="Problem state changed successfully.")
def get_flag_shares():
gid = request.args.get("gid", None)
if gid is None:
return WebError(
"You must specify a gid when looking at flag sharing statistics.")
user = api.user.get_user()
roles = api.group.get_roles_in_group(gid, uid=user["uid"])
if not roles["teacher"]:
return WebError(
"You must be a teacher of a group to see its flag sharing statistics."
)
return WebSuccess(data=api.stats.check_invalid_instance_submissions(
gid=gid))
def get_all_players_achievements_hook():
achievements = api.achievement.get_earned_achievement_instances()
for instance_achievement in achievements:
achievement = api.achievement.get_achievement(
aid=instance_achievement["aid"])
team = api.team.get_team(tid=instance_achievement["tid"])
#Make sure not to override name or description.
achievement.pop("name")
achievement.pop("description")
instance_achievement["team"] = team["team_name"]
instance_achievement.update(achievement)
instance_achievement.pop("data", None)
return WebSuccess(data=achievements)
def get_group_hook():
name = request.form.get("group-name")
owner = request.form.get("group-owner")
gid = request.form.get("gid")
owner_tid = None
if not gid or len(gid) == 0:
owner_tid = api.team.get_team(name=owner)["tid"]
group = api.group.get_group(gid=gid, name=name, owner_tid=owner_tid)
user = api.user.get_user()
roles = api.group.get_roles_in_group(gid=group["gid"], uid=user["uid"])
if not roles["member"] and not roles["teacher"]:
return WebError("You are not a member of this group.")
return WebSuccess(data=group)
def request_problem_hint_hook():
@log_action
def hint(pid, source):
return None
source = request.args.get("source")
pid = request.args.get("pid")
if pid is None:
return WebError("Please supply a pid.")
if source is None:
return WebError("You have to supply the source of the hint.")
tid = api.user.get_team()["tid"]
if pid not in api.problem.get_unlocked_pids(tid):
return WebError("Your team hasn't unlocked this problem yet!")
hint(pid, source)
return WebSuccess("Hint noted.")
def create_group_hook():
"""
Creates a new group. Validates forms.
All required arguments are assumed to be keys in params.
"""
params = api.common.flat_multi(request.form)
validate(register_group_schema, params)
# Current user is the prospective owner.
team = api.user.get_team()
if safe_fail(api.group.get_group,
name=params["group-name"],
owner_tid=team["tid"]) is not None:
raise WebException("A group with that name already exists!")
gid = api.group.create_group(team["tid"], params["group-name"])
return WebSuccess("Successfully created group.", data=gid)
def join_group_hook():
"""
Tries to place a team into a group. Validates forms.
All required arguments are assumed to be keys in params.
"""
params = api.common.flat_multi(request.form)
validate(join_group_schema, params)
owner_team = safe_fail(api.team.get_team, name=params["group-owner"])
if not owner_team:
raise WebException("No teacher exists with that name!")
if safe_fail(api.group.get_group,
name=params["group-name"],
owner_tid=owner_team["tid"]) is None:
raise WebException("No classroom exists with that name!")
group = api.group.get_group(name=params["group-name"],
owner_tid=owner_team["tid"])
group_settings = api.group.get_group_settings(gid=group["gid"])
team = api.team.get_team()
if group_settings["email_filter"]:
for member_uid in api.team.get_team_uids(tid=team["tid"]):
member = api.user.get_user(uid=member_uid)
if not api.user.verify_email_in_whitelist(
member["email"], group_settings["email_filter"]):
raise WebException(
"{}'s email does not belong to the whitelist for that classroom. Your team may not join this classroom at this time."
.format(member["username"]))
roles = api.group.get_roles_in_group(group["gid"], tid=team["tid"])
if roles["teacher"] or roles["member"]:
raise WebException("Your team is already a member of that classroom!")
api.group.join_group(group["gid"], team["tid"])
return WebSuccess("Successfully joined classroom")
def get_scoreboard_hook():
result = {}
result['public'] = api.stats.get_all_team_scores(eligible=True)
result['groups'] = []
if api.auth.is_logged_in():
user = api.user.get_user()
if not api.team.get_team(tid=user["tid"])["eligible"]:
result['ineligible'] = api.stats.get_all_team_scores(eligible=False)
for group in api.team.get_groups(uid=user["uid"]):
result['groups'].append({
'gid':
group['gid'],
'name':
group['name'],
'scoreboard':
api.stats.get_group_scores(gid=group['gid'])
})
return WebSuccess(data=result)
def leave_group_hook():
"""
Tries to remove a team from a group. Validates forms.
All required arguments are assumed to be keys in params.
"""
params = api.common.flat_multi(request.form)
validate(leave_group_schema, params)
owner_team = api.team.get_team(name=params["group-owner"])
group = api.group.get_group(name=params["group-name"],
owner_tid=owner_team["tid"])
team = api.user.get_team()
roles = api.group.get_roles_in_group(group["gid"], tid=team["tid"])
if not roles["member"] and not roles["teacher"]:
raise WebException("Your team is not a member of that class!")
api.group.leave_group(group["gid"], team["tid"])
return WebSuccess("Successfully left group.")
def get_single_problem_hook(pid):
problem_info = api.problem.get_problem(pid, tid=api.user.get_user()['tid'])
return WebSuccess(data=problem_info)
def get_unlocked_problems_hook():
return WebSuccess(
data=api.problem.get_unlocked_problems(api.user.get_user()['tid']))
def get_all_problems_count_hook(category):
return WebSuccess(data=api.problem.count_all_problems(category=category))
def get_visible_problems_hook(category):
return WebSuccess(data=api.problem.get_visible_problems(
api.user.get_user()['tid'], category=category))
def clear_all_submissions_hook():
api.problem.clear_all_submissions()
return WebSuccess("All submissions reset.")
def load_problems():
data = json.loads(request.form.get("competition_data", ""))
api.problem.load_published(data)
return WebSuccess("Inserted {} problems.".format(len(data["problems"])))
def problem_reviews_hook():
uid = api.user.get_user()['uid']
return WebSuccess(data=api.problem_feedback.get_problem_feedback(uid=uid))
def get_group_top_teams_score_progressions_hook():
gid = request.args.get("gid", None)
return WebSuccess(data=api.stats.get_top_teams_score_progressions(
gid=gid, eligible=True))