aboutsummaryrefslogtreecommitdiffstats
path: root/pysite/views
diff options
context:
space:
mode:
Diffstat (limited to 'pysite/views')
-rw-r--r--pysite/views/api/bot/user.py24
-rw-r--r--pysite/views/staff/jams/actions.py229
-rw-r--r--pysite/views/staff/jams/teams/__init__.py0
-rw-r--r--pysite/views/staff/jams/teams/view.py106
4 files changed, 352 insertions, 7 deletions
diff --git a/pysite/views/api/bot/user.py b/pysite/views/api/bot/user.py
index d9efb829..ced39306 100644
--- a/pysite/views/api/bot/user.py
+++ b/pysite/views/api/bot/user.py
@@ -41,6 +41,7 @@ class UserView(APIView, DBMixin):
infractions_table = "code_jam_infractions"
jams_table = "code_jams"
responses_table = "code_jam_responses"
+ teams_table = "code_jam_teams"
@api_key
@api_params(schema=SCHEMA, validation_type=ValidationTypes.json)
@@ -92,6 +93,16 @@ class UserView(APIView, DBMixin):
self.db.delete(self.responses_table, response["id"], durability="soft")
response_deletions += 1
+ teams = self.db.run(
+ self.db.query(self.teams_table).filter(lambda row: row["members"].contains(user_id)),
+ coerce=list
+ )
+
+ for team in teams:
+ team["members"].remove(user_id)
+
+ self.db.insert(self.teams_table, team, conflict="replace", durability="soft")
+
if banned:
self.db.insert(
self.infractions_table, {
@@ -116,6 +127,7 @@ class UserView(APIView, DBMixin):
self.db.sync(self.participants_table)
self.db.sync(self.responses_table)
self.db.sync(self.table_name)
+ self.db.sync(self.teams_table)
changes["deleted"] = deletions
changes["deleted_oauth"] = oauth_deletions
@@ -176,6 +188,18 @@ class UserView(APIView, DBMixin):
self.db.delete(self.responses_table, response["id"])
response_deletions += 1
+ teams = self.db.run(
+ self.db.query(self.teams_table).filter(lambda row: row["members"].contains(user_id)),
+ coerce=list
+ )
+
+ for team in teams:
+ team["members"].remove(user_id)
+
+ self.db.insert(self.teams_table, team, conflict="replace", durability="soft")
+
+ self.db.sync(self.teams_table)
+
if banned:
self.db.insert(
self.infractions_table, {
diff --git a/pysite/views/staff/jams/actions.py b/pysite/views/staff/jams/actions.py
index 24b31ce9..3cacbb50 100644
--- a/pysite/views/staff/jams/actions.py
+++ b/pysite/views/staff/jams/actions.py
@@ -1,19 +1,22 @@
from flask import jsonify, request
+from rethinkdb import ReqlNonExistenceError
from pysite.base_route import APIView
from pysite.constants import ALL_STAFF_ROLES, BotEventTypes, CHANNEL_JAM_LOGS, ErrorCodes, JAMMERS_ROLE
from pysite.decorators import csrf, require_roles
from pysite.mixins import DBMixin, RMQMixin
+from pysite.utils.words import get_word_pairs
-GET_ACTIONS = ["questions"]
-POST_ACTIONS = [
+GET_ACTIONS = ("questions",)
+POST_ACTIONS = (
"associate_question", "disassociate_question", "infraction", "questions", "state", "approve_application",
- "unapprove_application"
-]
-DELETE_ACTIONS = ["infraction", "question"]
-KEYS = ["action"]
+ "unapprove_application", "create_team", "generate_teams", "set_team_member",
+ "reroll_team"
+)
+DELETE_ACTIONS = ("infraction", "question", "team")
-QUESTION_KEYS = ["optional", "title", "type"]
+KEYS = ("action",)
+QUESTION_KEYS = ("optional", "title", "type")
class ActionView(APIView, DBMixin, RMQMixin):
@@ -25,6 +28,8 @@ class ActionView(APIView, DBMixin, RMQMixin):
infractions_table = "code_jam_infractions"
questions_table = "code_jam_questions"
responses_table = "code_jam_responses"
+ teams_table = "code_jam_teams"
+ users_table = "users"
@csrf
@require_roles(*ALL_STAFF_ROLES)
@@ -192,6 +197,204 @@ class ActionView(APIView, DBMixin, RMQMixin):
return jsonify({"id": result["generated_keys"][0]})
+ if action == "create_team":
+ jam = request.form.get("jam", type=int)
+
+ if not jam:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Jam number required"
+ )
+
+ jam_data = self.db.get(self.table_name, jam)
+
+ if not jam_data:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Unknown jam number"
+ )
+
+ word_pairs = get_word_pairs()
+ adjective, noun = list(word_pairs)[0]
+
+ team = {
+ "name": f"{adjective} {noun}".title(),
+ "members": []
+ }
+
+ result = self.db.insert(self.teams_table, team)
+ team["id"] = result["generated_keys"][0]
+
+ jam_obj = self.db.get(self.table_name, jam)
+ jam_obj["teams"].append(team["id"])
+
+ self.db.insert(self.table_name, jam_obj, conflict="replace")
+
+ return jsonify({"team": team})
+
+ if action == "generate_teams":
+ jam = request.form.get("jam", type=int)
+
+ if not jam:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Jam number required"
+ )
+
+ try:
+ query = self.db.query(self.table_name).get(jam).merge(
+ lambda jam_obj: {
+ "participants":
+ self.db.query(self.responses_table)
+ .filter({"jam": jam_obj["number"], "approved": True})
+ .eq_join("snowflake", self.db.query(self.users_table))
+ .without({"left": ["snowflake", "answers"]})
+ .zip()
+ .order_by("username")
+ .coerce_to("array"),
+ "teams":
+ self.db.query(self.teams_table)
+ .outer_join(self.db.query(self.table_name),
+ lambda team_row, jams_row: jams_row["teams"].contains(team_row["id"]))
+ .pluck({"left": ["id", "name", "members"]})
+ .zip()
+ .coerce_to("array")
+ }
+ )
+
+ jam_data = self.db.run(query)
+ except ReqlNonExistenceError:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Unknown jam number"
+ )
+
+ if jam_data["teams"]:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Jam already has teams"
+ )
+
+ num_participants = len(jam_data["participants"])
+ num_teams = num_participants // 3
+
+ if num_participants % 3:
+ num_teams += 1
+
+ word_pairs = get_word_pairs(num_teams)
+ teams = []
+
+ for adjective, noun in word_pairs:
+ team = {
+ "name": f"{adjective} {noun}".title(),
+ "members": []
+ }
+
+ result = self.db.insert(self.teams_table, team, durability="soft")
+ team["id"] = result["generated_keys"][0]
+ teams.append(team)
+
+ self.db.sync(self.teams_table)
+
+ jam_obj = self.db.get(self.table_name, jam)
+ jam_obj["teams"] = [team["id"] for team in teams]
+
+ self.db.insert(self.table_name, jam_obj, conflict="replace")
+
+ return jsonify({"teams": teams})
+
+ if action == "set_team_member":
+ jam = request.form.get("jam", type=int)
+ member = request.form.get("member")
+ team = request.form.get("team")
+
+ if not jam:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Jam number required"
+ )
+
+ if not member:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Member ID required"
+ )
+
+ if not team:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Team ID required"
+ )
+
+ try:
+ query = self.db.query(self.table_name).get(jam).merge(
+ lambda jam_obj: {
+ "participants":
+ self.db.query(self.responses_table)
+ .filter({"jam": jam_obj["number"], "approved": True})
+ .eq_join("snowflake", self.db.query(self.users_table))
+ .without({"left": ["snowflake", "answers"]})
+ .zip()
+ .order_by("username")
+ .coerce_to("array"),
+ "teams":
+ self.db.query(self.teams_table)
+ .outer_join(self.db.query(self.table_name),
+ lambda team_row, jams_row: jams_row["teams"].contains(team_row["id"]))
+ .pluck({"left": ["id", "name", "members"]})
+ .zip()
+ .coerce_to("array")
+ }
+ )
+
+ jam_data = self.db.run(query)
+ except ReqlNonExistenceError:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Unknown jam number"
+ )
+
+ if not jam_data["teams"]:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Jam has no teams"
+ )
+
+ team_obj = self.db.get(self.teams_table, team)
+
+ if not team_obj:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Unknown team ID"
+ )
+
+ for jam_team_obj in jam_data["teams"]:
+ if jam_team_obj["id"] == team:
+ if member not in jam_team_obj["members"]:
+ jam_team_obj["members"].append(member)
+
+ self.db.insert(self.teams_table, jam_team_obj, conflict="replace")
+ else:
+ if member in jam_team_obj["members"]:
+ jam_team_obj["members"].remove(member)
+
+ self.db.insert(self.teams_table, jam_team_obj, conflict="replace")
+
+ return jsonify({"result": True})
+
+ if action == "reroll_team":
+ team = request.form.get("team")
+
+ if not team:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Team ID required"
+ )
+
+ team_obj = self.db.get(self.teams_table, team)
+
+ if not team_obj:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Unknown team ID"
+ )
+
+ word_pairs = get_word_pairs()
+ adjective, noun = list(word_pairs)[0]
+
+ team_obj["name"] = f"{adjective} {noun}".title()
+
+ self.db.insert(self.teams_table, team_obj, conflict="replace")
+
+ return jsonify({"name": team_obj["name"]})
+
if action == "approve_application":
app = request.form.get("id")
@@ -324,3 +527,15 @@ class ActionView(APIView, DBMixin, RMQMixin):
self.db.delete(self.infractions_table, infraction)
return jsonify({"id": infraction_obj["id"]})
+
+ if action == "team":
+ team = request.form.get("team")
+
+ if not team:
+ return self.error(
+ ErrorCodes.incorrect_parameters, "Team ID required"
+ )
+
+ self.db.delete(self.teams_table, team)
+
+ return jsonify({"result": True})
diff --git a/pysite/views/staff/jams/teams/__init__.py b/pysite/views/staff/jams/teams/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/pysite/views/staff/jams/teams/__init__.py
diff --git a/pysite/views/staff/jams/teams/view.py b/pysite/views/staff/jams/teams/view.py
new file mode 100644
index 00000000..c68da63e
--- /dev/null
+++ b/pysite/views/staff/jams/teams/view.py
@@ -0,0 +1,106 @@
+from rethinkdb import ReqlNonExistenceError
+from werkzeug.exceptions import NotFound
+
+from pysite.base_route import RouteView
+from pysite.constants import ALL_STAFF_ROLES
+from pysite.decorators import require_roles
+from pysite.mixins import DBMixin
+
+REQUIRED_KEYS = ("title", "date_start", "date_end")
+
+
+class StaffView(RouteView, DBMixin):
+ path = "/jams/teams/<int:jam>"
+ name = "jams.teams"
+
+ table_name = "code_jam_teams"
+
+ forms_table = "code_jam_forms"
+ jams_table = "code_jams"
+ participants_table = "code_jam_participants"
+ questions_table = "code_jam_questions"
+ responses_table = "code_jam_responses"
+ users_table = "users"
+
+ @require_roles(*ALL_STAFF_ROLES)
+ def get(self, jam: int):
+ try:
+ query = self.db.query(self.jams_table).get(jam).merge(
+ # Merge the jam document with a custom document defined below
+ lambda jam_obj: { # The lambda lets us manipulate the jam document server-side
+ "participants":
+ # Query the responses table
+ self.db.query(self.responses_table)
+ # Filter: approved responses for this jam only # noqa: E131
+ .filter({"jam": jam_obj["number"], "approved": True})
+ # Join each response document with documents from the user table that match the user that
+ # created this response - this is the efficient way to do things, inner/outer joins
+ # are slower as they only support explicit predicates
+ .eq_join("snowflake", self.db.query(self.users_table))
+ # Remove the user ID from the left side (the response document)
+ .without({"left": ["snowflake"]})
+ .zip() # Combine the left and right documents together
+ .order_by("username") # Reorder the documents by username
+ .coerce_to("array"), # Coerce the document stream into an array
+ "profiles":
+ # Query the responses table (again)
+ # We do this because RethinkDB just returns empty lists if you join on another join
+ self.db.query(self.responses_table)
+ # Filter: approved responses for this jam only # noqa: E131
+ .filter({"jam": jam_obj["number"], "approved": True})
+ # Join each response document with documents from the participant profiles table
+ # this time
+ .eq_join("snowflake", self.db.query(self.participants_table))
+ # Remove the user ID and answers from the left side (the response document)
+ .without({"left": ["snowflake", "answers"]})
+ .zip() # Combine the left and right documents together
+ .order_by("username") # Reorder the documents by username
+ .coerce_to("array"), # Coerce the document stream into an array
+ "form": self.db.query(self.forms_table).get(jam), # Just get the correct form object
+ "teams":
+ # Query the teams table
+ self.db.query(self.table_name)
+ # Join the teams table against the jams table, to find all of the teams for this
+ # specific jam - we can't simply filter because of the one-to-many relationship,
+ # so we must use an inner join with a predicate function. This function is still
+ # run on the server, however
+ .inner_join(self.db.query(self.jams_table),
+ lambda team_row, jams_row: jams_row["teams"].contains(team_row["id"]))
+ # Only take the ID, name and members of each team, discard everything else
+ .pluck({"left": ["id", "name", "members"]})
+ .zip() # Combine the left and right documents together
+ .coerce_to("array") # Coerce the document stream into an array
+ }
+ )
+
+ jam_data = self.db.run(query)
+ except ReqlNonExistenceError:
+ raise NotFound()
+
+ questions = {}
+
+ for question in jam_data["form"]["questions"]:
+ questions[question] = self.db.get(self.questions_table, question)
+
+ teams = {}
+ participants = {}
+ assigned = []
+
+ for team in jam_data["teams"]:
+ teams[team["id"]] = team
+
+ for member in team["members"]:
+ assigned.append(member)
+
+ for user in jam_data["participants"]:
+ participants[user["user_id"]] = user
+
+ for profile in jam_data["profiles"]:
+ participants[profile["id"]]["profile"] = profile
+
+ return self.render(
+ "staff/jams/teams/view.html",
+ jam=jam_data, teams=teams,
+ participants=participants, assigned=assigned,
+ questions=questions
+ )
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-19 22:38:45 +0000