diff options
Diffstat (limited to 'pysite/views')
114 files changed, 0 insertions, 5407 deletions
diff --git a/pysite/views/__init__.py b/pysite/views/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/__init__.py +++ /dev/null diff --git a/pysite/views/api/__init__.py b/pysite/views/api/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/api/__init__.py +++ /dev/null diff --git a/pysite/views/api/bot/__init__.py b/pysite/views/api/bot/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/api/bot/__init__.py +++ /dev/null diff --git a/pysite/views/api/bot/bigbrother.py b/pysite/views/api/bot/bigbrother.py deleted file mode 100644 index 89697811..00000000 --- a/pysite/views/api/bot/bigbrother.py +++ /dev/null @@ -1,118 +0,0 @@ -import json - -from flask import jsonify -from schema import And, Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - - -GET_SCHEMA = Schema({ - # This is passed as a GET parameter, so it has to be a string - Optional('user_id'): And(str, str.isnumeric, error="`user_id` must be a numeric string") -}) - -POST_SCHEMA = Schema({ - 'user_id': And(str, str.isnumeric, error="`user_id` must be a numeric string"), - 'channel_id': And(str, str.isnumeric, error="`channel_id` must be a numeric string") -}) - -DELETE_SCHEMA = Schema({ - 'user_id': And(str, str.isnumeric, error="`user_id` must be a numeric string") -}) - - -NOT_A_NUMBER_JSON = json.dumps({ - 'error_message': "The given `user_id` parameter is not a valid number" -}) -NOT_FOUND_JSON = json.dumps({ - 'error_message': "No entry for the requested user ID could be found." -}) - - -class BigBrotherView(APIView, DBMixin): - path = '/bot/bigbrother' - name = 'bot.bigbrother' - table_name = 'watched_users' - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params): - """ - Without query parameters, returns a list of all monitored users. - A parameter `user_id` can be specified to return a single entry, - or a dictionary with the string field 'error_message' that tells why it failed. - - If the returned status is 200, has got either a list of entries - or a single object (see above). - - If the returned status is 400, the `user_id` parameter was incorrectly specified. - If the returned status is 404, the given `user_id` could not be found. - See the 'error_message' field in the JSON response for more information. - - The user ID must be provided as query parameter. - API key must be provided as header. - """ - - user_id = params.get('user_id') - if user_id is not None: - data = self.db.get(self.table_name, user_id) - if data is None: - return NOT_FOUND_JSON, 404 - return jsonify(data) - - else: - data = self.db.pluck(self.table_name, ('user_id', 'channel_id')) or [] - return jsonify(data) - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - """ - Adds a new entry to the database. - Entries take the following form: - { - "user_id": ..., # The user ID of the user being monitored, as a string. - "channel_id": ... # The channel ID that the user's messages will be relayed to, as a string. - } - - If an entry for the given `user_id` already exists, it will be updated with the new channel ID. - - Returns 204 (ok, empty response) on success. - - Data must be provided as JSON. - API key must be provided as header. - """ - - self.db.insert( - self.table_name, - { - 'user_id': data['user_id'], - 'channel_id': data['channel_id'] - }, - conflict='update' - ) - - return '', 204 - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.params) - def delete(self, params): - """ - Removes an entry for the given `user_id`. - - Returns 204 (ok, empty response) on success. - Returns 400 if the given `user_id` is invalid. - - The user ID must be provided as query parameter. - API key must be provided as header. - """ - - self.db.delete( - self.table_name, - params['user_id'] - ) - - return '', 204 diff --git a/pysite/views/api/bot/clean.py b/pysite/views/api/bot/clean.py deleted file mode 100644 index 82d1e735..00000000 --- a/pysite/views/api/bot/clean.py +++ /dev/null @@ -1,48 +0,0 @@ -from flask import jsonify -from schema import Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - -POST_SCHEMA = Schema({ - 'log_data': [ - { - "author": str, - "user_id": str, - "content": str, - "role_id": str, - "timestamp": str, - "embeds": object, - "attachments": [str], - } - ] -}) - - -class CleanView(APIView, DBMixin): - path = '/bot/clean' - name = 'bot.clean' - table_name = 'clean_logs' - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - """ - Receive some log_data from a bulk deletion, - and store it in the database. - - Returns an ID which can be used to get the data - from the /bot/clean_logs/<id> endpoint. - """ - - # Insert and return the id to use for GET - insert = self.db.insert( - self.table_name, - { - "log_data": data["log_data"] - } - ) - - return jsonify({"log_id": insert['generated_keys'][0]}) diff --git a/pysite/views/api/bot/doc.py b/pysite/views/api/bot/doc.py deleted file mode 100644 index c1d6020c..00000000 --- a/pysite/views/api/bot/doc.py +++ /dev/null @@ -1,98 +0,0 @@ -from flask import jsonify -from schema import Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - - -GET_SCHEMA = Schema([ - { - Optional("package"): str - } -]) - -POST_SCHEMA = Schema([ - { - "package": str, - "base_url": str, - "inventory_url": str - } -]) - -DELETE_SCHEMA = Schema([ - { - "package": str - } -]) - - -class DocView(APIView, DBMixin): - path = "/bot/docs" - name = "bot.docs" - table_name = "pydoc_links" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params=None): - """ - Fetches documentation metadata from the database. - - - If `package` parameters are provided, fetch metadata - for the given packages, or `[]` if none matched. - - - If `package` is not provided, return all - packages known to the database. - - Data must be provided as params. - API key must be provided as header. - """ - - if params: - packages = (param['package'] for param in params if 'package' in param) - data = self.db.get_all(self.table_name, *packages, index='package') or [] - else: - data = self.db.pluck(self.table_name, ("package", "base_url", "inventory_url")) or [] - - return jsonify(data) - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.json) - def post(self, json_data): - """ - Adds one or more new documentation metadata objects. - - If the `package` passed in the data - already exists, it will be updated instead. - - Data must be provided as JSON. - API key must be provided as header. - """ - - packages_to_insert = ( - { - "package": json_object["package"], - "base_url": json_object["base_url"], - "inventory_url": json_object["inventory_url"] - } for json_object in json_data - ) - - self.db.insert(self.table_name, *packages_to_insert, conflict="update") - return jsonify({"success": True}) - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.json) - def delete(self, json_data): - """ - Deletes a documentation metadata object. - Expects the `package` to be deleted to - be specified as a request parameter. - - Data must be provided as params. - API key must be provided as header. - """ - - packages = (json_object["package"]for json_object in json_data) - changes = self.db.delete(self.table_name, *packages, return_changes=True) - return jsonify(changes) diff --git a/pysite/views/api/bot/hiphopify.py b/pysite/views/api/bot/hiphopify.py deleted file mode 100644 index ce4dfa4a..00000000 --- a/pysite/views/api/bot/hiphopify.py +++ /dev/null @@ -1,170 +0,0 @@ -import logging - -from flask import jsonify -from schema import Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin -from pysite.utils.time import is_expired, parse_duration - -log = logging.getLogger(__name__) - -GET_SCHEMA = Schema({ - "user_id": str -}) - -POST_SCHEMA = Schema({ - "user_id": str, - "duration": str, - Optional("forced_nick"): str -}) - -DELETE_SCHEMA = Schema({ - "user_id": str -}) - - -class HiphopifyView(APIView, DBMixin): - path = "/bot/hiphopify" - name = "bot.hiphopify" - prison_table = "hiphopify" - name_table = "hiphopify_namelist" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params=None): - """ - Check if the user is currently in hiphop-prison. - - If user is currently servin' his sentence in the big house, - return the name stored in the forced_nick column of prison_table. - - If user cannot be found in prison, or - if his sentence has expired, return nothing. - - Data must be provided as params. - API key must be provided as header. - """ - - user_id = params.get("user_id") - - log.debug(f"Checking if user ({user_id}) is permitted to change their nickname.") - data = self.db.get(self.prison_table, user_id) or {} - - if data and data.get("end_timestamp"): - log.trace("User exists in the prison_table.") - end_time = data.get("end_timestamp") - if is_expired(end_time): - log.trace("...But their sentence has already expired.") - data = {} # Return nothing if the sentence has expired. - - return jsonify(data) - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.json) - def post(self, json_data): - """ - Imprisons a user in hiphop-prison. - - If a forced_nick was provided by the caller, the method will force - this nick. If not, a random hiphop nick will be selected from the - name_table. - - Data must be provided as JSON. - API key must be provided as header. - """ - - user_id = json_data.get("user_id") - duration = json_data.get("duration") - forced_nick = json_data.get("forced_nick") - - log.debug(f"Attempting to imprison user ({user_id}).") - - # Get random name and picture if no forced_nick was provided. - if not forced_nick: - log.trace("No forced_nick provided. Fetching a random rapper name and image.") - rapper_data = self.db.sample(self.name_table, 1)[0] - forced_nick = rapper_data.get('name') - - # If forced nick was provided, try to look up the forced_nick in the database. - # If a match cannot be found, just default to Lil' Jon for the image. - else: - log.trace(f"Forced nick provided ({forced_nick}). Trying to match it with the database.") - rapper_data = ( - self.db.get(self.name_table, forced_nick) - or self.db.get(self.name_table, "Lil' Joseph") - ) - - image_url = rapper_data.get('image_url') - log.trace(f"Using the nickname {forced_nick} and the image_url {image_url}.") - - # Convert duration to valid timestamp - try: - log.trace("Parsing the duration and converting it to a timestamp") - end_timestamp = parse_duration(duration) - except ValueError: - log.warning(f"The duration could not be parsed, or was invalid. The duration was '{duration}'.") - return jsonify({ - "success": False, - "error_message": "Invalid duration" - }) - - log.debug("Everything seems to be in order, inserting the data into the prison_table.") - self.db.insert( - self.prison_table, - { - "user_id": user_id, - "end_timestamp": end_timestamp, - "forced_nick": forced_nick - }, - conflict="update" # If it exists, update it. - ) - - return jsonify({ - "success": True, - "end_timestamp": end_timestamp, - "forced_nick": forced_nick, - "image_url": image_url - }) - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.json) - def delete(self, json_data): - """ - Releases a user from hiphop-prison. - - Data must be provided as JSON. - API key must be provided as header. - """ - - user_id = json_data.get("user_id") - - log.debug(f"Attempting to release user ({user_id}) from hiphop-prison.") - prisoner_data = self.db.get(self.prison_table, user_id) - sentence_expired = None - - log.trace(f"Checking if the user ({user_id}) is currently in hiphop-prison.") - if prisoner_data and prisoner_data.get("end_timestamp"): - sentence_expired = is_expired(prisoner_data['end_timestamp']) - - if prisoner_data and not sentence_expired: - log.debug("User is currently in hiphop-prison. Deleting the record and releasing the prisoner.") - self.db.delete( - self.prison_table, - user_id - ) - return jsonify({"success": True}) - elif not prisoner_data: - log.warning(f"User ({user_id}) is not currently in hiphop-prison.") - return jsonify({ - "success": False, - "error_message": "User is not currently in hiphop-prison!" - }) - elif sentence_expired: - log.warning(f"User ({user_id}) was in hiphop-prison, but has already been released.") - return jsonify({ - "success": False, - "error_message": "User has already been released from hiphop-prison!" - }) diff --git a/pysite/views/api/bot/infractions.py b/pysite/views/api/bot/infractions.py deleted file mode 100644 index eee40b82..00000000 --- a/pysite/views/api/bot/infractions.py +++ /dev/null @@ -1,572 +0,0 @@ -""" -INFRACTIONS API - -"GET" endpoints in this API may take the following optional parameters, depending on the endpoint: - - active: filters infractions that are active (true), expired (false), or either (not present/any) - - expand: expands the result data with the information about the users (slower) - - dangling: filters infractions that are active, or inactive infractions that have not been closed manually. - - search: filters the "reason" field to match the given RE2 query. - -Infraction Schema: - This schema is used when an infraction's data is returned. - - Root object: - "id" (str): the UUID of the infraction. - "inserted_at" (str): the date and time of the creation of this infraction (RFC1123 format). - "expires_at" (str): the date and time of the expiration of this infraction (RC1123 format), may be null. - The significance of this field being null depends on the type of infraction. Duration-based infractions - have a "null" expiration if they are permanent. Other infraction types do not have expirations. - "active" (bool): whether the infraction is still active. Note that the check for expiration of - duration-based infractions is done by the API, so you should check for expiration using this "active" field. - "user" (object): the user to which the infraction was applied. - "user_id" (str): the Discord ID of the user. - "username" (optional str): the username of the user. This field is only present if the query was expanded. - "discriminator" (optional int): the username discriminator of the user. This field is only present if the - query was expanded. - "avatar" (optional str): the avatar URL of the user. This field is only present if the query was expanded. - "actor" (object): the user which applied the infraction. - This object uses the same schema as the "user" field. - "type" (str): the type of the infraction. - "reason" (str): the reason for the infraction. - - -Endpoints: - - GET /bot/infractions - Gets a list of all infractions, regardless of type or user. - Parameters: "active", "expand", "dangling", "search". - This endpoint returns an array of infraction objects. - - GET /bot/infractions/user/<user_id> - Gets a list of all infractions for a user. - Parameters: "active", "expand", "search". - This endpoint returns an array of infraction objects. - - GET /bot/infractions/type/<type> - Gets a list of all infractions of the given type (ban, mute, etc.) - Parameters: "active", "expand", "search". - This endpoint returns an array of infraction objects. - - GET /bot/infractions/user/<user_id>/<type> - Gets a list of all infractions of the given type for a user. - Parameters: "active", "expand", "search". - This endpoint returns an array of infraction objects. - - GET /bot/infractions/user/<user_id>/<type>/current - Gets the active infraction (if any) of the given type for a user. - Parameters: "expand". - This endpoint returns an object with the "infraction" key, which is either set to null (no infraction) - or the query's corresponding infraction. It will not return an infraction if the type of the infraction - isn't duration-based (e.g. kick, warning, etc.) - - GET /bot/infractions/id/<infraction_id> - Gets the infraction (if any) for the given ID. - Parameters: "expand". - This endpoint returns an object with the "infraction" key, which is either set to null (no infraction) - or the infraction corresponding to the ID. - - POST /bot/infractions - Creates an infraction for a user. - Parameters (JSON payload): - "type" (str): the type of the infraction (must be a valid infraction type). - "reason" (str): the reason of the infraction. - "user_id" (str): the Discord ID of the user who is being given the infraction. - "actor_id" (str): the Discord ID of the user who submitted the infraction. - "duration" (optional str): the duration of the infraction. This is ignored for infractions - which are not duration-based. For other infraction types, omitting this field may imply permanence. - "expand" (optional bool): whether to expand the infraction user data once the infraction is inserted and returned. - - PATCH /bot/infractions - Updates an infractions. - Parameters (JSON payload): - "id" (str): the ID of the infraction to update. - "reason" (optional str): if provided, the new reason for the infraction. - "duration" (optional str): if provided, updates the expiration of the infraction to the time of UPDATING - plus the duration. If set to null, the expiration is also set to null (may imply permanence). - "active" (optional bool): if provided, activates or deactivates the infraction. This does not do anything - if the infraction isn't duration-based, or if the infraction has already expired. This marks the infraction - as closed. - "expand" (optional bool): whether to expand the infraction user data once the infraction is updated and returned. -""" - -import datetime -from typing import NamedTuple - -import rethinkdb -from flask import jsonify -from schema import Optional, Or, Schema - -from pysite.base_route import APIView -from pysite.constants import ErrorCodes, ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin -from pysite.utils.time import parse_duration - - -class InfractionType(NamedTuple): - timed_infraction: bool # whether the infraction is active until it expires. - - -RFC1123_FORMAT = "%a, %d %b %Y %H:%M:%S GMT" -EXCLUDED_FIELDS = "user_id", "actor_id", "closed", "_timed" -INFRACTION_ORDER = rethinkdb.desc("active"), rethinkdb.desc("inserted_at") - -INFRACTION_TYPES = { - "warning": InfractionType(timed_infraction=False), - "mute": InfractionType(timed_infraction=True), - "ban": InfractionType(timed_infraction=True), - "kick": InfractionType(timed_infraction=False), - "superstar": InfractionType(timed_infraction=True) # hiphopify -} - -GET_SCHEMA = Schema({ - Optional("active"): str, - Optional("expand"): str, - Optional("dangling"): str, - Optional("search"): str -}) - -GET_ACTIVE_SCHEMA = Schema({ - Optional("expand"): str -}) - -CREATE_INFRACTION_SCHEMA = Schema({ - "type": lambda tp: tp in INFRACTION_TYPES, - "reason": Or(str, None), - "user_id": str, # Discord user ID - "actor_id": str, # Discord user ID - Optional("duration"): str, # If not provided, may imply permanence depending on the infraction - Optional("expand"): bool -}) - -UPDATE_INFRACTION_SCHEMA = Schema({ - "id": str, - Optional("reason"): Or(str, None), - Optional("duration"): Or(str, None), - Optional("active"): bool -}) - -IMPORT_INFRACTIONS_SCHEMA = Schema([ - { - "id": str, - "active": bool, - "actor": { - "id": str - }, - "created_at": str, - "expires_at": Or(str, None), - "reason": Or(str, None), - "type": { - "name": str - }, - "user": { - "id": str - } - } -], ignore_extra_keys=True) - - -class InfractionsView(APIView, DBMixin): - path = "/bot/infractions" - name = "bot.infractions" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params: dict = None): - if "dangling" in params: - return _infraction_list_filtered(self, params, {"_timed": True, "closed": False}) - else: - return _infraction_list_filtered(self, params, {}) - - @api_key - @api_params(schema=CREATE_INFRACTION_SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - deactivate_infraction_query = None - - infraction_type = data["type"] - user_id = data["user_id"] - actor_id = data["actor_id"] - reason = data["reason"] - duration_str = data.get("duration") - expand = data.get("expand") - expires_at = None - inserted_at = datetime.datetime.now(tz=datetime.timezone.utc) - - if infraction_type not in INFRACTION_TYPES: - return self.error(ErrorCodes.incorrect_parameters, "Invalid infraction type.") - - # check if the user already has an active infraction of this type - # if so, we need to disable that infraction and create a new infraction - if INFRACTION_TYPES[infraction_type].timed_infraction: - active_infraction_query = \ - self.db.query(self.table_name).merge(_merge_active_check()) \ - .filter({"user_id": user_id, "type": infraction_type, "active": True}) \ - .limit(1).nth(0).default(None) - - active_infraction = self.db.run(active_infraction_query) - if active_infraction: - deactivate_infraction_query = \ - self.db.query(self.table_name) \ - .get(active_infraction["id"]) \ - .update({"active": False, "closed": True}) - - if duration_str: - try: - expires_at = parse_duration(duration_str) - except ValueError: - return self.error( - ErrorCodes.incorrect_parameters, - "Invalid duration format." - ) - - infraction_insert_doc = { - "actor_id": actor_id, - "user_id": user_id, - "type": infraction_type, - "reason": reason, - "inserted_at": inserted_at, - "expires_at": expires_at - } - - infraction_id = self.db.insert(self.table_name, infraction_insert_doc)["generated_keys"][0] - - if deactivate_infraction_query: - self.db.run(deactivate_infraction_query) - - query = self.db.query(self.table_name).get(infraction_id) \ - .merge(_merge_expand_users(self, expand)) \ - .merge(_merge_active_check()) \ - .without(*EXCLUDED_FIELDS).default(None) - return jsonify({ - "infraction": self.db.run(query) - }) - - @api_key - @api_params(schema=UPDATE_INFRACTION_SCHEMA, validation_type=ValidationTypes.json) - def patch(self, data): - expand = data.get("expand") - update_collection = { - "id": data["id"] - } - - if "reason" in data: - update_collection["reason"] = data["reason"] - - if "active" in data: - update_collection["active"] = data["active"] - update_collection["closed"] = not data["active"] - - if "duration" in data: - duration_str = data["duration"] - if duration_str is None: - update_collection["expires_at"] = None - else: - try: - update_collection["expires_at"] = parse_duration(duration_str) - except ValueError: - return self.error( - ErrorCodes.incorrect_parameters, - "Invalid duration format." - ) - - query_update = self.db.query(self.table_name).update(update_collection) - result_update = self.db.run(query_update) - - if not result_update["replaced"]: - return jsonify({ - "success": False, - "error_message": "Unknown infraction / nothing was changed." - }) - - # return the updated infraction - query = self.db.query(self.table_name).get(data["id"]) \ - .merge(_merge_expand_users(self, expand)) \ - .merge(_merge_active_check()) \ - .without(*EXCLUDED_FIELDS).default(None) - infraction = self.db.run(query) - - return jsonify({ - "infraction": infraction, - "success": True - }) - - -class InfractionById(APIView, DBMixin): - path = "/bot/infractions/id/<string:infraction_id>" - name = "bot.infractions.id" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_ACTIVE_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params, infraction_id): - params = params or {} - expand = parse_bool(params.get("expand"), default=False) - - query = self.db.query(self.table_name).get(infraction_id) \ - .merge(_merge_expand_users(self, expand)) \ - .merge(_merge_active_check()) \ - .without(*EXCLUDED_FIELDS).default(None) - return jsonify({ - "infraction": self.db.run(query) - }) - - -class ListInfractionsByUserView(APIView, DBMixin): - path = "/bot/infractions/user/<string:user_id>" - name = "bot.infractions.user" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params, user_id): - return _infraction_list_filtered(self, params, { - "user_id": user_id - }) - - -class ListInfractionsByTypeView(APIView, DBMixin): - path = "/bot/infractions/type/<string:type>" - name = "bot.infractions.type" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params, type): - return _infraction_list_filtered(self, params, { - "type": type - }) - - -class ListInfractionsByTypeAndUserView(APIView, DBMixin): - path = "/bot/infractions/user/<string:user_id>/<string:type>" - name = "bot.infractions.user.type" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params, user_id, type): - return _infraction_list_filtered(self, params, { - "user_id": user_id, - "type": type - }) - - -class CurrentInfractionByTypeAndUserView(APIView, DBMixin): - path = "/bot/infractions/user/<string:user_id>/<string:infraction_type>/current" - name = "bot.infractions.user.type.current" - table_name = "bot_infractions" - - @api_key - @api_params(schema=GET_ACTIVE_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params, user_id, infraction_type): - params = params or {} - expand = parse_bool(params.get("expand"), default=False) - - query_filter = { - "user_id": user_id, - "type": infraction_type - } - query = _merged_query(self, expand, query_filter).filter({ - "active": True - }).order_by(rethinkdb.desc("data")).limit(1).nth(0).default(None) - return jsonify({ - "infraction": self.db.run(query) - }) - - -class ImportRowboatInfractionsView(APIView, DBMixin): - path = "/bot/infractions/import" - name = "bot.infractions.import" - table_name = "bot_infractions" - - @api_key - @api_params(schema=IMPORT_INFRACTIONS_SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - # keep track of the un-bans, to apply after the import is complete. - unbans = [] - infractions = [] - - # previously imported infractions - imported_infractions = self.db.run( - self.db.query(self.table_name).filter( - lambda row: row.has_fields("legacy_rowboat_id") - ).fold([], lambda acc, row: acc.append(row["legacy_rowboat_id"])).coerce_to("array") - ) - - for rowboat_infraction_data in data: - legacy_rowboat_id = rowboat_infraction_data["id"] - if legacy_rowboat_id in imported_infractions: - continue - infraction_type = rowboat_infraction_data["type"]["name"] - if infraction_type == "unban": - unbans.append(rowboat_infraction_data) - continue - # adjust infraction types - if infraction_type == "tempmute": - infraction_type = "mute" - if infraction_type == "tempban": - infraction_type = "ban" - if infraction_type not in INFRACTION_TYPES: - # unknown infraction type - continue - active = rowboat_infraction_data["active"] - reason = rowboat_infraction_data["reason"] or "<No reason>" - user_id = rowboat_infraction_data["user"]["id"] - actor_id = rowboat_infraction_data["actor"]["id"] - inserted_at_str = rowboat_infraction_data["created_at"] - try: - inserted_at = parse_rfc1123(inserted_at_str) - except ValueError: - continue - expires_at_str = rowboat_infraction_data["expires_at"] - if expires_at_str is not None: - try: - expires_at = parse_rfc1123(expires_at_str) - except ValueError: - continue - else: - expires_at = None - infractions.append({ - "legacy_rowboat_id": legacy_rowboat_id, - "active": active, - "reason": reason, - "user_id": user_id, - "actor_id": actor_id, - "inserted_at": inserted_at, - "expires_at": expires_at, - "type": infraction_type - }) - - insertion_query = self.db.query(self.table_name).insert(infractions) - inserted_count = self.db.run(insertion_query)["inserted"] - - # apply unbans - for unban_data in unbans: - inserted_at_str = unban_data["created_at"] - user_id = unban_data["user"]["id"] - try: - inserted_at = parse_rfc1123(inserted_at_str) - except ValueError: - continue - self.db.run( - self.db.query(self.table_name).filter( - lambda row: (row["user_id"].eq(user_id)) & - (row["type"].eq("ban")) & - (row["inserted_at"] < inserted_at) - ).pluck("id").merge(lambda row: { - "active": False - }).coerce_to("array").for_each(lambda doc: self.db.query(self.table_name).get(doc["id"]).update(doc)) - ) - - return jsonify({ - "success": True, - "inserted_count": inserted_count - }) - - -def _infraction_list_filtered(view, params=None, query_filter=None): - params = params or {} - query_filter = query_filter or {} - active = parse_bool(params.get("active")) - expand = parse_bool(params.get("expand"), default=False) - search = params.get("search") - - if active is not None: - query_filter["active"] = active - - query = _merged_query(view, expand, query_filter) - - if search is not None: - query = query.filter( - lambda row: rethinkdb.branch( - row["reason"].eq(None), - False, - row["reason"].match(search) - ) - ) - - query = query.order_by(*INFRACTION_ORDER) - - return jsonify(view.db.run(query.coerce_to("array"))) - - -def _merged_query(view, expand, query_filter): - return view.db.query(view.table_name).merge(_merge_active_check()).filter(query_filter) \ - .merge(_merge_expand_users(view, expand)).without(*EXCLUDED_FIELDS) - - -def _merge_active_check(): - # Checks if the "closed" field has been set to true (manual infraction removal). - # If not, the "active" field is set to whether the infraction has expired. - def _merge(row): - return { - "active": - rethinkdb.branch( - _is_timed_infraction(row["type"]), - rethinkdb.branch( - (row["closed"].default(False).eq(True)) | (row["active"].default(True).eq(False)), - False, - rethinkdb.branch( - row["expires_at"].eq(None), - True, - row["expires_at"] > rethinkdb.now() - ) - ), - False - ), - "closed": row["closed"].default(False), - "_timed": _is_timed_infraction(row["type"]) - } - - return _merge - - -def _merge_expand_users(view, expand): - def _do_expand(user_id): - if not user_id: - return None - # Expands the user information, if it is in the database. - - if expand: - return view.db.query("users").get(user_id).default({ - "user_id": user_id - }) - - return { - "user_id": user_id - } - - def _merge(row): - return { - "user": _do_expand(row["user_id"].default(None)), - "actor": _do_expand(row["actor_id"].default(None)) - } - - return _merge - - -def _is_timed_infraction(type_var): - # this method generates an ReQL expression to check if the given type - # is a "timed infraction" (i.e it can expire or be permanent) - - timed_infractions = filter(lambda key: INFRACTION_TYPES[key].timed_infraction, INFRACTION_TYPES.keys()) - expr = rethinkdb.expr(False) - for infra_type in timed_infractions: - expr = expr | type_var.eq(infra_type) - return expr - - -def parse_rfc1123(time_str): - return datetime.datetime.strptime(time_str, RFC1123_FORMAT).replace(tzinfo=datetime.timezone.utc) - - -def parse_bool(a_string, default=None): - # Not present, null or any: returns default (defaults to None) - # false, no, or 0: returns False - # anything else: True - if a_string is None or a_string == "null" or a_string == "any": - return default - if a_string.lower() == "false" or a_string.lower() == "no" or a_string == "0": - return False - return True diff --git a/pysite/views/api/bot/off_topic_names.py b/pysite/views/api/bot/off_topic_names.py deleted file mode 100644 index 1c75428e..00000000 --- a/pysite/views/api/bot/off_topic_names.py +++ /dev/null @@ -1,108 +0,0 @@ -import random - -from flask import jsonify, request -from schema import And, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - - -OFF_TOPIC_NAME = And( - str, - len, - lambda name: all(c.isalnum() or c == '-' for c in name), - str.islower, - lambda name: len(name) <= 96, - error=( - "The channel name must be a non-blank string consisting only of" - " lowercase regular characters and '-' with a maximum length of 96" - ) -) - -DELETE_SCHEMA = Schema({ - 'name': OFF_TOPIC_NAME -}) - -POST_SCHEMA = Schema({ - 'name': OFF_TOPIC_NAME -}) - - -class OffTopicNamesView(APIView, DBMixin): - path = "/bot/off-topic-names" - name = "bot.off_topic_names" - table_name = "off_topic_names" - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.params) - def delete(self, params): - """ - Removes a single off-topic name from the database. - Returns the result of the deletion call. - - API key must be provided as header. - Name to delete must be provided as the `name` query argument. - """ - - result = self.db.delete( - self.table_name, - params['name'], - return_changes=True - ) - - return jsonify(result) - - @api_key - def get(self): - """ - Fetch all known off-topic channel names from the database. - Returns a list of strings, the strings being the off-topic names. - - If the query argument `random_items` is provided (a non-negative integer), - then this view will return `random_items` random names from the database - instead of returning all items at once. - - API key must be provided as header. - """ - - names = [ - entry['name'] for entry in self.db.get_all(self.table_name) - ] - - if 'random_items' in request.args: - random_count = request.args['random_items'] - if not random_count.isdigit(): - response = {'message': "`random_items` must be a valid integer"} - return jsonify(response), 400 - - samples = random.sample(names, int(random_count)) - return jsonify(samples) - - return jsonify(names) - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.params) - def post(self, data): - """ - Add a new off-topic channel name to the database. - Expects the new channel's name as the `name` argument. - The name must consist only of alphanumeric characters or minus signs, - and must not be empty or exceed 96 characters. - - Data must be provided as params. - API key must be provided as header. - """ - - if self.db.get(self.table_name, data['name']) is not None: - response = { - 'message': "An entry with the given name already exists" - } - return jsonify(response), 400 - - self.db.insert( - self.table_name, - {'name': data['name']} - ) - return jsonify({'message': 'ok'}) diff --git a/pysite/views/api/bot/settings.py b/pysite/views/api/bot/settings.py deleted file mode 100644 index a633a68a..00000000 --- a/pysite/views/api/bot/settings.py +++ /dev/null @@ -1,56 +0,0 @@ -from flask import jsonify -from schema import Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - -# todo: type safety -SETTINGS_KEYS_DEFAULTS = { - "defcon_enabled": False, - "defcon_days": 1 -} - -GET_SCHEMA = Schema({ - Optional("keys"): str -}) - - -def settings_schema(): - schema_dict = {Optional(key): type(SETTINGS_KEYS_DEFAULTS[key]) for key in SETTINGS_KEYS_DEFAULTS.keys()} - return Schema(schema_dict) - - -class ServerSettingsView(APIView, DBMixin): - path = "/bot/settings" - name = "bot.settings" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params=None): - keys_raw = None - if params: - keys_raw = params.get("keys") - - keys = filter(lambda key: key in SETTINGS_KEYS_DEFAULTS, - keys_raw.split(",")) if keys_raw else SETTINGS_KEYS_DEFAULTS.keys() - - result = {key: (self.db.get("bot_settings", key) or {}).get("value") or SETTINGS_KEYS_DEFAULTS[key] for key in - keys} - return jsonify(result) - - @api_key - @api_params(schema=settings_schema(), validation_type=ValidationTypes.json) - def put(self, json_data): - # update in database - - for key, value in json_data.items(): - self.db.insert("bot_settings", { - "key": key, - "value": value - }, conflict="update") - - return jsonify({ - "success": True - }) diff --git a/pysite/views/api/bot/snake_cog/__init__.py b/pysite/views/api/bot/snake_cog/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/api/bot/snake_cog/__init__.py +++ /dev/null diff --git a/pysite/views/api/bot/snake_cog/snake_facts.py b/pysite/views/api/bot/snake_cog/snake_facts.py deleted file mode 100644 index 4e8c8a5d..00000000 --- a/pysite/views/api/bot/snake_cog/snake_facts.py +++ /dev/null @@ -1,28 +0,0 @@ -import logging - -from flask import jsonify - -from pysite.base_route import APIView -from pysite.decorators import api_key -from pysite.mixins import DBMixin - -log = logging.getLogger(__name__) - - -class SnakeFactsView(APIView, DBMixin): - path = "/bot/snake_facts" - name = "bot.snake_facts" - table = "snake_facts" - - @api_key - def get(self): - """ - Returns a random fact from the snake_facts table. - - API key must be provided as header. - """ - - log.trace("Fetching a random fact from the snake_facts database") - question = self.db.sample(self.table, 1)[0]["fact"] - - return jsonify(question) diff --git a/pysite/views/api/bot/snake_cog/snake_idioms.py b/pysite/views/api/bot/snake_cog/snake_idioms.py deleted file mode 100644 index 9d879871..00000000 --- a/pysite/views/api/bot/snake_cog/snake_idioms.py +++ /dev/null @@ -1,28 +0,0 @@ -import logging - -from flask import jsonify - -from pysite.base_route import APIView -from pysite.decorators import api_key -from pysite.mixins import DBMixin - -log = logging.getLogger(__name__) - - -class SnakeIdiomView(APIView, DBMixin): - path = "/bot/snake_idioms" - name = "bot.snake_idioms" - table = "snake_idioms" - - @api_key - def get(self): - """ - Returns a random idiom from the snake_idioms table. - - API key must be provided as header. - """ - - log.trace("Fetching a random idiom from the snake_idioms database") - question = self.db.sample(self.table, 1)[0]["idiom"] - - return jsonify(question) diff --git a/pysite/views/api/bot/snake_cog/snake_names.py b/pysite/views/api/bot/snake_cog/snake_names.py deleted file mode 100644 index d9e0c6b8..00000000 --- a/pysite/views/api/bot/snake_cog/snake_names.py +++ /dev/null @@ -1,48 +0,0 @@ -import logging - -from flask import jsonify -from schema import Optional, Schema - - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - -log = logging.getLogger(__name__) - -GET_SCHEMA = Schema([ - { - Optional("get_all"): str - } -]) - - -class SnakeNamesView(APIView, DBMixin): - path = "/bot/snake_names" - name = "bot.snake_names" - table = "snake_names" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params=None): - """ - Returns all snake names random name from the snake_names table. - - API key must be provided as header. - """ - - get_all = None - - if params: - get_all = params[0].get("get_all") - - if get_all: - log.trace("Returning all snake names from the snake_names table") - snake_names = self.db.get_all(self.table) - - else: - log.trace("Fetching a single random snake name from the snake_names table") - snake_names = self.db.sample(self.table, 1)[0] - - return jsonify(snake_names) diff --git a/pysite/views/api/bot/snake_cog/snake_quiz.py b/pysite/views/api/bot/snake_cog/snake_quiz.py deleted file mode 100644 index 359077d7..00000000 --- a/pysite/views/api/bot/snake_cog/snake_quiz.py +++ /dev/null @@ -1,28 +0,0 @@ -import logging - -from flask import jsonify - -from pysite.base_route import APIView -from pysite.decorators import api_key -from pysite.mixins import DBMixin - -log = logging.getLogger(__name__) - - -class SnakeQuizView(APIView, DBMixin): - path = "/bot/snake_quiz" - name = "bot.snake_quiz" - table = "snake_quiz" - - @api_key - def get(self): - """ - Returns a random question from the snake_quiz table. - - API key must be provided as header. - """ - - log.trace("Fetching a random question from the snake_quiz database") - question = self.db.sample(self.table, 1)[0] - - return jsonify(question) diff --git a/pysite/views/api/bot/snake_cog/special_snakes.py b/pysite/views/api/bot/snake_cog/special_snakes.py deleted file mode 100644 index 294c16c9..00000000 --- a/pysite/views/api/bot/snake_cog/special_snakes.py +++ /dev/null @@ -1,28 +0,0 @@ -import logging - -from flask import jsonify - -from pysite.base_route import APIView -from pysite.decorators import api_key -from pysite.mixins import DBMixin - -log = logging.getLogger(__name__) - - -class SpecialSnakesView(APIView, DBMixin): - path = "/bot/special_snakes" - name = "bot.special_snakes" - table = "special_snakes" - - @api_key - def get(self): - """ - Returns all special snake objects from the database - - API key must be provided as header. - """ - - log.trace("Returning all special snakes in the database") - snake_names = self.db.get_all(self.table) - - return jsonify(snake_names) diff --git a/pysite/views/api/bot/tags.py b/pysite/views/api/bot/tags.py deleted file mode 100644 index 4394c224..00000000 --- a/pysite/views/api/bot/tags.py +++ /dev/null @@ -1,107 +0,0 @@ -from flask import jsonify -from schema import Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - -GET_SCHEMA = Schema({ - Optional("tag_name"): str -}) - -POST_SCHEMA = Schema({ - "tag_name": str, - "tag_content": str -}) - -DELETE_SCHEMA = Schema({ - "tag_name": str -}) - - -class TagsView(APIView, DBMixin): - path = "/bot/tags" - name = "bot.tags" - table_name = "tags" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, params=None): - """ - Fetches tags from the database. - - - If tag_name is provided, it fetches - that specific tag. - - - If tag_category is provided, it fetches - all tags in that category. - - - If nothing is provided, it will - fetch a list of all tag_names. - - Data must be provided as params. - API key must be provided as header. - """ - - tag_name = None - - if params: - tag_name = params.get("tag_name") - - if tag_name: - data = self.db.get(self.table_name, tag_name) or {} - else: - data = self.db.pluck(self.table_name, "tag_name") or [] - - return jsonify(data) - - @api_key - @api_params(schema=POST_SCHEMA, validation_type=ValidationTypes.json) - def post(self, json_data): - """ - If the tag_name doesn't exist, this - saves a new tag in the database. - - If the tag_name already exists, - this will edit the existing tag. - - Data must be provided as JSON. - API key must be provided as header. - """ - - tag_name = json_data.get("tag_name") - tag_content = json_data.get("tag_content") - - self.db.insert( - self.table_name, - { - "tag_name": tag_name, - "tag_content": tag_content - }, - conflict="update" # If it exists, update it. - ) - - return jsonify({"success": True}) - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.json) - def delete(self, data): - """ - Deletes a tag from the database. - - Data must be provided as JSON. - API key must be provided as header. - """ - - tag_name = data.get("tag_name") - tag_exists = self.db.get(self.table_name, tag_name) - - if tag_exists: - self.db.delete( - self.table_name, - tag_name - ) - return jsonify({"success": True}) - - return jsonify({"success": False}) diff --git a/pysite/views/api/bot/user.py b/pysite/views/api/bot/user.py deleted file mode 100644 index a3a0c7a8..00000000 --- a/pysite/views/api/bot/user.py +++ /dev/null @@ -1,166 +0,0 @@ -import logging - -import rethinkdb -from flask import jsonify, request -from schema import Optional, Schema - -from pysite.base_route import APIView -from pysite.constants import ErrorCodes, ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - -SCHEMA = Schema([ - { - "avatar": str, - "discriminator": str, - "roles": [str], - "user_id": str, - "username": str - } -]) - -GET_SCHEMA = Schema([ - { - "user_id": str - } -]) - -DELETE_SCHEMA = Schema([ - { - "user_id": str, - - Optional("avatar"): str, - Optional("discriminator"): str, - Optional("roles"): [str], - Optional("username"): str - } -]) - -BANNABLE_STATES = ("preparing", "running") - - -class UserView(APIView, DBMixin): - path = "/bot/users" - name = "bot.users" - - chunks_table = "member_chunks" - infractions_table = "code_jam_infractions" - jams_table = "code_jams" - oauth_table_name = "oauth_data" - participants_table = "code_jam_participants" - responses_table = "code_jam_responses" - table_name = "users" - teams_table = "code_jam_teams" - - @api_key - @api_params(schema=GET_SCHEMA, validation_type=ValidationTypes.params) - def get(self, data): - logging.getLogger(__name__).debug(f"Size of request: {len(request.data)} bytes") - - if not data: - return self.error(ErrorCodes.bad_data_format, "No user IDs supplied") - - data = [x["user_id"] for x in data] - - result = self.db.run( - self.db.query(self.table_name) - .filter(lambda document: rethinkdb.expr(data).contains(document["user_id"])), - coerce=list - ) - - return jsonify({"data": result}) # pragma: no cover - - @api_key - @api_params(schema=SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - logging.getLogger(__name__).debug(f"Size of request: {len(request.data)} bytes") - - if not data: - return self.error(ErrorCodes.bad_data_format, "No users supplied") - - self.db.insert(self.chunks_table, {"chunk": data}) - - return jsonify({"success": True}) # pragma: no cover - - @api_key - @api_params(schema=SCHEMA, validation_type=ValidationTypes.json) - def put(self, data): - changes = self.db.insert( - self.table_name, *data, - conflict="update" - ) - - return jsonify(changes) # pragma: no cover - - @api_key - @api_params(schema=DELETE_SCHEMA, validation_type=ValidationTypes.json) - def delete(self, data): - user_ids = [user["user_id"] for user in data] - - changes = {} - - # changes = self.db.run( - # self.db.query(self.table_name) - # .get_all(*user_ids) - # .delete() - # ) - - oauth_deletions = self.db.run( - self.db.query(self.oauth_table_name) - .get_all(*user_ids, index="snowflake") - .delete() - ).get("deleted", 0) - - profile_deletions = self.db.run( - self.db.query(self.participants_table) - .get_all(*user_ids) - .delete() - ).get("deleted", 0) - - bans = 0 - response_deletions = 0 - - for user_id in user_ids: - banned = False - responses = self.db.run(self.db.query(self.responses_table).filter({"snowflake": user_id}), coerce=list) - - for response in responses: - jam = response["jam"] - jam_obj = self.db.get(self.jams_table, jam) - - if jam_obj: - if jam_obj["state"] in BANNABLE_STATES: - banned = True - - 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, { - "participant": user_id, - "reason": "Automatic ban: Removed jammer profile in the middle of a code jam", - "number": -1, - "decremented_for": [] - } - ) - bans += 1 - - changes["deleted_oauth"] = oauth_deletions - changes["deleted_jam_profiles"] = profile_deletions - changes["deleted_responses"] = response_deletions - changes["jam_bans"] = bans - - return jsonify(changes) # pragma: no cover diff --git a/pysite/views/api/bot/user_complete.py b/pysite/views/api/bot/user_complete.py deleted file mode 100644 index 877eee34..00000000 --- a/pysite/views/api/bot/user_complete.py +++ /dev/null @@ -1,143 +0,0 @@ -import logging - -from flask import jsonify, request - -from pysite.base_route import APIView -from pysite.constants import ErrorCodes, ValidationTypes -from pysite.decorators import api_key, api_params -from pysite.mixins import DBMixin - - -BANNABLE_STATES = ("preparing", "running") - -log = logging.getLogger(__name__) - - -class UserView(APIView, DBMixin): - path = "/bot/users/complete" - name = "bot.users.complete" - - chunks_table = "member_chunks" - infractions_table = "code_jam_infractions" - jams_table = "code_jams" - oauth_table_name = "oauth_data" - participants_table = "code_jam_participants" - responses_table = "code_jam_responses" - table_name = "users" - teams_table = "code_jam_teams" - - @api_key - @api_params(validation_type=ValidationTypes.none) - def post(self, _): - log.debug(f"Size of request: {len(request.data)} bytes") - - documents = self.db.get_all(self.chunks_table) - chunks = [] - - for doc in documents: - log.info(f"Got member chunk with {len(doc['chunk'])} users") - chunks.append(doc["chunk"]) - - self.db.delete(self.chunks_table, doc["id"], durability="soft") - self.db.sync(self.chunks_table) - - log.info(f"Got {len(chunks)} member chunks") - - data = [] - - for chunk in chunks: - data += chunk - - log.info(f"Got {len(data)} members") - - if not data: - return self.error(ErrorCodes.bad_data_format, "No users supplied") - - deletions = 0 - oauth_deletions = 0 - profile_deletions = 0 - response_deletions = 0 - bans = 0 - - user_ids = [user["user_id"] for user in data] - - all_users = self.db.run(self.db.query(self.table_name), coerce=list) - - for user in all_users: - if user["user_id"] not in user_ids: - self.db.delete(self.table_name, user["user_id"], durability="soft") - deletions += 1 - - all_oauth_data = self.db.run(self.db.query(self.oauth_table_name), coerce=list) - - for item in all_oauth_data: - if item["snowflake"] not in user_ids: - user_id = item["snowflake"] - - oauth_deletions += self.db.delete( - self.oauth_table_name, item["id"], durability="soft", return_changes=True - ).get("deleted", 0) - profile_deletions += self.db.delete( - self.participants_table, user_id, durability="soft", return_changes=True - ).get("deleted", 0) - - banned = False - responses = self.db.run( - self.db.query(self.responses_table).filter({"snowflake": user_id}), - coerce=list - ) - - for response in responses: - jam = response["jam"] - jam_obj = self.db.get(self.jams_table, jam) - - if jam_obj: - if jam_obj["state"] in BANNABLE_STATES: - banned = True - - 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, { - "participant": user_id, - "reason": "Automatic ban: Removed jammer profile in the middle of a code jam", - "number": -1, - "decremented_for": [] - }, durability="soft" - ) - bans += 1 - - del user_ids - - changes = self.db.insert( - self.table_name, *data, - conflict="update", - durability="soft" - ) - - self.db.sync(self.infractions_table) - self.db.sync(self.oauth_table_name) - 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 - changes["deleted_jam_profiles"] = profile_deletions - changes["deleted_responses"] = response_deletions - changes["jam_bans"] = bans - - return jsonify(changes) # pragma: no cover diff --git a/pysite/views/api/error_view.py b/pysite/views/api/error_view.py deleted file mode 100644 index 89b4d6ad..00000000 --- a/pysite/views/api/error_view.py +++ /dev/null @@ -1,40 +0,0 @@ -from flask import jsonify -from werkzeug.exceptions import HTTPException - -from pysite.base_route import ErrorView - - -class APIErrorView(ErrorView): - name = "api.error_all" - error_code = range(400, 600) - register_on_app = False - - def __init__(self): - - # Direct errors for all methods at self.return_error - methods = [ - 'get', 'post', 'put', - 'delete', 'patch', 'connect', - 'options', 'trace' - ] - - for method in methods: - setattr(self, method, self.return_error) - - def return_error(self, error: HTTPException): - """ - Return a basic JSON object representing the HTTP error, - as well as propagating its status code - """ - - message = str(error) - code = 500 - - if isinstance(error, HTTPException): - message = error.description - code = error.code - - return jsonify({ - "error_code": -1, - "error_message": message - }), code diff --git a/pysite/views/api/healthcheck.py b/pysite/views/api/healthcheck.py deleted file mode 100644 index c873d674..00000000 --- a/pysite/views/api/healthcheck.py +++ /dev/null @@ -1,11 +0,0 @@ -from flask import jsonify - -from pysite.base_route import APIView - - -class HealthCheckView(APIView): - path = "/healthcheck" - name = "api.healthcheck" - - def get(self): - return jsonify({"status": "ok"}) diff --git a/pysite/views/api/index.py b/pysite/views/api/index.py deleted file mode 100644 index 5111162c..00000000 --- a/pysite/views/api/index.py +++ /dev/null @@ -1,10 +0,0 @@ -from pysite.base_route import APIView -from pysite.constants import ErrorCodes - - -class IndexView(APIView): - path = "/" - name = "api.index" - - def get(self): - return self.error(ErrorCodes.unknown_route) diff --git a/pysite/views/api/robots_txt.py b/pysite/views/api/robots_txt.py deleted file mode 100644 index d4406d54..00000000 --- a/pysite/views/api/robots_txt.py +++ /dev/null @@ -1,15 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView - - -class RobotsTXT(RouteView): - path = "/robots.txt" - name = "robots_txt" - - def get(self): - return Response( - self.render( - "robots.txt", sitemap_url=url_for("api.sitemap_xml", _external=True), rules={"*": ["/"]} - ), content_type="text/plain" - ) diff --git a/pysite/views/api/sitemap_xml.py b/pysite/views/api/sitemap_xml.py deleted file mode 100644 index 26a786b0..00000000 --- a/pysite/views/api/sitemap_xml.py +++ /dev/null @@ -1,11 +0,0 @@ -from flask import Response - -from pysite.base_route import RouteView - - -class SitemapXML(RouteView): - path = "/sitemap.xml" - name = "sitemap_xml" - - def get(self): - return Response(self.render("sitemap.xml", urls=[]), content_type="application/xml") diff --git a/pysite/views/error_handlers/http_4xx.py b/pysite/views/error_handlers/http_4xx.py deleted file mode 100644 index 731204f9..00000000 --- a/pysite/views/error_handlers/http_4xx.py +++ /dev/null @@ -1,31 +0,0 @@ -from flask import request -from werkzeug.exceptions import HTTPException - -from pysite.base_route import ErrorView -from pysite.constants import ERROR_DESCRIPTIONS - - -class Error400View(ErrorView): - name = "errors.4xx" - error_code = range(400, 430) - - def __init__(self): - # Direct errors for all methods at self.return_error - methods = [ - 'get', 'post', 'put', - 'delete', 'patch', 'connect', - 'options', 'trace' - ] - - for method in methods: - setattr(self, method, self.error) - - def error(self, error: HTTPException): - error_desc = ERROR_DESCRIPTIONS.get(error.code, "We're not really sure what happened there, please try again.") - - return self.render( - "errors/error.html", code=error.code, req=request, error_title=error_desc, - error_message=f"{error_desc} If you believe we have made a mistake, please " - "<a href='https://gitlab.com/python-discord/projects/site/issues'>" - "open an issue on our GitLab</a>." - ), error.code diff --git a/pysite/views/error_handlers/http_5xx.py b/pysite/views/error_handlers/http_5xx.py deleted file mode 100644 index 489eb5e5..00000000 --- a/pysite/views/error_handlers/http_5xx.py +++ /dev/null @@ -1,41 +0,0 @@ -from flask import request -from werkzeug.exceptions import HTTPException, InternalServerError - -from pysite.base_route import ErrorView -from pysite.constants import ERROR_DESCRIPTIONS - - -class Error500View(ErrorView): - name = "errors.5xx" - error_code = range(500, 600) - - def __init__(self): - - # Direct errors for all methods at self.return_error - methods = [ - 'get', 'post', 'put', - 'delete', 'patch', 'connect', - 'options', 'trace' - ] - - for method in methods: - setattr(self, method, self.error) - - def error(self, error: HTTPException): - - # We were sometimes recieving errors from RethinkDB, which were not originating from Werkzeug. - # To fix this, this section checks whether they have a code (which werkzeug adds) and if not - # change the error to a Werkzeug InternalServerError. - - if not hasattr(error, "code"): - error = InternalServerError() - - error_desc = ERROR_DESCRIPTIONS.get(error.code, "We're not really sure what happened there, please try again.") - - return self.render( - "errors/error.html", code=error.code, req=request, error_title=error_desc, - error_message="An error occurred while processing this request, please try " - "again later. If you believe we have made a mistake, please " - "<a href='https://gitlab.com/python-discord/projects/site/issues'>file an issue on our" - " GitLab</a>." - ), error.code diff --git a/pysite/views/main/__init__.py b/pysite/views/main/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/__init__.py +++ /dev/null diff --git a/pysite/views/main/abort.py b/pysite/views/main/abort.py deleted file mode 100644 index ecfe8f91..00000000 --- a/pysite/views/main/abort.py +++ /dev/null @@ -1,11 +0,0 @@ -from werkzeug.exceptions import InternalServerError - -from pysite.base_route import RouteView - - -class EasterEgg500(RouteView): - path = "/500" - name = "500" - - def get(self): - raise InternalServerError diff --git a/pysite/views/main/about/__init__.py b/pysite/views/main/about/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/about/__init__.py +++ /dev/null diff --git a/pysite/views/main/about/channels.py b/pysite/views/main/about/channels.py deleted file mode 100644 index 2e5496f9..00000000 --- a/pysite/views/main/about/channels.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class ChannelsView(TemplateView): - path = "/about/channels" - name = "about.channels" - template = "main/about/channels.html" diff --git a/pysite/views/main/about/index.py b/pysite/views/main/about/index.py deleted file mode 100644 index 6f5ef1c8..00000000 --- a/pysite/views/main/about/index.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class IndexView(TemplateView): - path = "/about/" - name = "about.index" - template = "main/about/index.html" diff --git a/pysite/views/main/about/partners.py b/pysite/views/main/about/partners.py deleted file mode 100644 index 4fe321a5..00000000 --- a/pysite/views/main/about/partners.py +++ /dev/null @@ -1,19 +0,0 @@ -import json -from logging import getLogger - -from pysite.base_route import RouteView - -try: - with open("static/partners.json") as fh: - partners = json.load(fh) -except Exception: - getLogger("Partners").exception("Failed to load partners.json") - categories = None - - -class PartnersView(RouteView): - path = "/about/partners" - name = "about.partners" - - def get(self): - return self.render("main/about/partners.html", partners=partners) diff --git a/pysite/views/main/about/privacy.py b/pysite/views/main/about/privacy.py deleted file mode 100644 index a08aa22b..00000000 --- a/pysite/views/main/about/privacy.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class PrivacyView(TemplateView): - path = "/about/privacy" - name = "about.privacy" - template = "main/about/privacy.html" diff --git a/pysite/views/main/about/rules.py b/pysite/views/main/about/rules.py deleted file mode 100644 index a40110a1..00000000 --- a/pysite/views/main/about/rules.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class RulesView(TemplateView): - path = "/about/rules" - name = "about.rules" - template = "main/about/rules.html" diff --git a/pysite/views/main/auth/__init__.py b/pysite/views/main/auth/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/auth/__init__.py +++ /dev/null diff --git a/pysite/views/main/auth/done.py b/pysite/views/main/auth/done.py deleted file mode 100644 index 6e892906..00000000 --- a/pysite/views/main/auth/done.py +++ /dev/null @@ -1,18 +0,0 @@ -from flask import redirect, session, url_for - -from pysite.base_route import RouteView - - -class AuthDoneView(RouteView): - path = "/auth/done" - name = "auth.done" - - def get(self): - if self.logged_in: - target = session.get("redirect_target") - - if target: - del session["redirect_target"] - return redirect(url_for(target["url"], **target.get("kwargs", {}))) - - return redirect(url_for("main.index")) diff --git a/pysite/views/main/bot/cleanlog.py b/pysite/views/main/bot/cleanlog.py deleted file mode 100644 index 9c719b3e..00000000 --- a/pysite/views/main/bot/cleanlog.py +++ /dev/null @@ -1,35 +0,0 @@ -import logging - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES, DEVELOPERS_ROLE, ROLE_COLORS -from pysite.decorators import require_roles -from pysite.mixins import DBMixin, OAuthMixin - -log = logging.getLogger(__name__) - - -class CleanLogView(RouteView, DBMixin, OAuthMixin): - path = "/bot/clean_logs/<log_id>" - name = "bot.clean_logs" - - table_name = "clean_logs" - template = "main/bot/clean_logs.html" - - @require_roles(ALL_STAFF_ROLES) - def get(self, log_id): - """ - Get the requested clean log and spit it out - in a beautiful template. - """ - - data = self.db.get(self.table_name, log_id) - - if data is None: - return "ID could not be found in the database", 404 - - messages = data["log_data"] - - for message in messages: - message['color'] = ROLE_COLORS.get(message['role_id'], ROLE_COLORS[DEVELOPERS_ROLE]) - - return self.render(self.template, messages=messages) diff --git a/pysite/views/main/error.py b/pysite/views/main/error.py deleted file mode 100644 index 07286eb4..00000000 --- a/pysite/views/main/error.py +++ /dev/null @@ -1,14 +0,0 @@ -from flask import abort - -from pysite.base_route import RouteView - - -class ErrorView(RouteView): - path = "/error/<int:code>" - name = "error" - - def get(self, code): - try: - return abort(code) - except LookupError: - return abort(500) diff --git a/pysite/views/main/index.py b/pysite/views/main/index.py deleted file mode 100644 index 874961bb..00000000 --- a/pysite/views/main/index.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class IndexView(TemplateView): - path = "/" - name = "index" - template = "main/index.html" diff --git a/pysite/views/main/info/__init__.py b/pysite/views/main/info/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/info/__init__.py +++ /dev/null diff --git a/pysite/views/main/info/faq.py b/pysite/views/main/info/faq.py deleted file mode 100644 index 8878e180..00000000 --- a/pysite/views/main/info/faq.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class IndexView(TemplateView): - path = "/info/faq" - name = "info.faq" - template = "main/info/faq.html" diff --git a/pysite/views/main/info/help.py b/pysite/views/main/info/help.py deleted file mode 100644 index 6a82a9ed..00000000 --- a/pysite/views/main/info/help.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class HelpView(TemplateView): - path = "/info/help" - name = "info.help" - template = "main/info/help.html" diff --git a/pysite/views/main/info/index.py b/pysite/views/main/info/index.py deleted file mode 100644 index 97678ee4..00000000 --- a/pysite/views/main/info/index.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class IndexView(TemplateView): - path = "/info/" - name = "info.index" - template = "main/info/index.html" diff --git a/pysite/views/main/info/jams.py b/pysite/views/main/info/jams.py deleted file mode 100644 index b654ec1d..00000000 --- a/pysite/views/main/info/jams.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import RedirectView - - -class JamsView(RedirectView): - path = "/info/jams" - name = "info.jams" - page = "main.jams.index" diff --git a/pysite/views/main/info/resources.py b/pysite/views/main/info/resources.py deleted file mode 100644 index 541b9ba1..00000000 --- a/pysite/views/main/info/resources.py +++ /dev/null @@ -1,58 +0,0 @@ -import json -from logging import getLogger - -from pysite.base_route import RouteView - -ICON_STYLES = { - "branding": "fab", - "regular": "far", - "solid": "fas", - "light": "fal" -} - -logger = getLogger("Resources") - -try: - with open("static/resources.json") as fh: - categories = json.load(fh) - - for category, items in categories.items(): - to_remove = [] - - for name, resource in items["resources"].items(): - for url_obj in resource["urls"]: - icon = url_obj["icon"].lower() - - if "/" not in icon: - to_remove.append(name) - logger.error( - f"Resource {name} in category {category} has an invalid icon. Icons should be of the" - f"form `style/name`." - ) - continue - - style, icon_name = icon.split("/") - - if style not in ICON_STYLES: - to_remove.append(name) - logger.error( - f"Resource {name} in category {category} has an invalid icon style. Icon style must " - f"be one of {', '.join(ICON_STYLES.keys())}." - ) - continue - - url_obj["classes"] = f"{ICON_STYLES[style]} fa-{icon_name}" - - for name in to_remove: - del items["resources"][name] -except Exception: - getLogger("Resources").exception("Failed to load resources.json") - categories = None - - -class ResourcesView(RouteView): - path = "/info/resources" - name = "info.resources" - - def get(self): - return self.render("main/info/resources.html", categories=categories) diff --git a/pysite/views/main/jams/__init__.py b/pysite/views/main/jams/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/jams/__init__.py +++ /dev/null diff --git a/pysite/views/main/jams/index.py b/pysite/views/main/jams/index.py deleted file mode 100644 index 0cd9a287..00000000 --- a/pysite/views/main/jams/index.py +++ /dev/null @@ -1,52 +0,0 @@ -import rethinkdb - -from pysite.base_route import RouteView -from pysite.mixins import DBMixin - - -class JamsIndexView(RouteView, DBMixin): - path = "/jams" - name = "jams.index" - table_name = "code_jams" - - teams_table = "code_jam_teams" - - def get(self): - query = ( - self.db.query(self.table_name) - .filter(rethinkdb.row["state"] != "planning") - .merge( - lambda jam_obj: { - "teams": - self.db.query(self.teams_table) - .filter(lambda team_row: jam_obj["teams"].contains(team_row["id"])) - .pluck(["id"]) - .coerce_to("array") - } - ) - .order_by(rethinkdb.desc("number")) - .limit(5) - ) - - jams = self.db.run(query, coerce=list) - for jam in jams: - if "winning_team" in jam and jam["winning_team"]: - jam["winning_team"] = self.db.get(self.teams_table, jam["winning_team"]) - else: - jam["winning_team"] = None - pass - return self.render("main/jams/index.html", jams=jams, has_applied_to_jam=self.has_applied_to_jam) - - def get_jam_response(self, jam, user_id): - query = self.db.query("code_jam_responses").filter({"jam": jam, "snowflake": user_id}) - result = self.db.run(query, coerce=list) - - if result: - return result[0] - return None - - def has_applied_to_jam(self, jam): - # whether the user has applied to this jam - if not self.logged_in: - return False - return self.get_jam_response(jam, self.user_data["user_id"]) diff --git a/pysite/views/main/jams/info.py b/pysite/views/main/jams/info.py deleted file mode 100644 index fd4615e9..00000000 --- a/pysite/views/main/jams/info.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class JamsInfoView(TemplateView): - path = "/jams/info" - name = "jams.info" - template = "main/jams/info.html" diff --git a/pysite/views/main/jams/jam_team_list.py b/pysite/views/main/jams/jam_team_list.py deleted file mode 100644 index 452a073f..00000000 --- a/pysite/views/main/jams/jam_team_list.py +++ /dev/null @@ -1,45 +0,0 @@ -import logging - -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.mixins import DBMixin, OAuthMixin - -log = logging.getLogger(__name__) - - -class JamsTeamListView(RouteView, DBMixin, OAuthMixin): - path = "/jams/teams/<int:jam_id>" - name = "jams.jam_team_list" - - table_name = "code_jam_teams" - jams_table = "code_jams" - - def get(self, jam_id): - jam_obj = self.db.get(self.jams_table, jam_id) - if not jam_obj: - raise NotFound() - - # Get all the participants of this jam - # Note: the group function will return a dict with user_ids as keys, however each element will be an array - participants_query = self.db.query("users").get_all(*jam_obj["participants"], index="user_id").group("user_id") - participants = self.db.run(participants_query) - - # Get all the teams, leaving the team members as only an array of IDs - query = self.db.query(self.table_name).get_all(self.table_name, *jam_obj["teams"]).pluck( - ["id", "name", "members", "repo"]).coerce_to("array") - jam_obj["teams"] = self.db.run(query) - - # Populate each team's members using the previously queried participant list - for team in jam_obj["teams"]: - team["members"] = [participants[user_id][0] for user_id in team["members"]] - - return self.render( - "main/jams/team_list.html", - jam=jam_obj, - teams=jam_obj["teams"], - member_ids=self.member_ids - ) - - def member_ids(self, members): - return [member["user_id"] for member in members] diff --git a/pysite/views/main/jams/join.py b/pysite/views/main/jams/join.py deleted file mode 100644 index 4db59630..00000000 --- a/pysite/views/main/jams/join.py +++ /dev/null @@ -1,247 +0,0 @@ -import datetime -from email.utils import parseaddr - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import BotEventTypes, CHANNEL_JAM_LOGS -from pysite.decorators import csrf -from pysite.mixins import DBMixin, OAuthMixin, RMQMixin - - -class JamsJoinView(RouteView, DBMixin, OAuthMixin, RMQMixin): - path = "/jams/join/<int:jam>" - name = "jams.join" - - table_name = "code_jams" - forms_table = "code_jam_forms" - questions_table = "code_jam_questions" - responses_table = "code_jam_responses" - participants_table = "code_jam_participants" - infractions_table = "code_jam_infractions" - - def get(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not self.user_data: - return self.redirect_login(jam=jam) - - infractions = self.get_infractions(self.user_data["user_id"]) - - for infraction in infractions: - if infraction["number"] == -1: # Indefinite ban - return self.render("main/jams/banned.html", infraction=infraction, jam=jam_obj) - - if infraction["number"]: # Got some jams left - if jam not in infraction["decremented_for"]: - # Make sure they haven't already tried to apply for this jam - infraction["number"] -= 1 - infraction["decremented_for"].append(jam) - - self.db.insert(self.infractions_table, infraction, conflict="replace") - - return self.render("main/jams/banned.html", infraction=infraction, jam=jam_obj) - - if jam in infraction["decremented_for"]: - # They already tried to apply for this jam - return self.render("main/jams/banned.html", infraction=infraction, jam=jam_obj) - - participant = self.db.get(self.participants_table, self.user_data["user_id"]) - - if not participant: - return redirect(url_for("main.jams.profile", form=jam)) - - if self.get_response(jam, self.user_data["user_id"]): - return self.render("main/jams/already.html", jam=jam_obj) - - form_obj = self.db.get(self.forms_table, jam) - questions = [] - - if form_obj: - for question in form_obj["questions"]: - questions.append(self.db.get(self.questions_table, question)) - - return self.render( - "main/jams/join.html", jam=jam_obj, form=form_obj, - questions=questions, question_ids=[q["id"] for q in questions] - ) - - @csrf - def post(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not self.user_data: - return self.redirect_login(jam=jam) - - infractions = self.get_infractions(self.user_data["user_id"]) - - for infraction in infractions: - if infraction["number"] == -1: # Indefinite ban - self.log_banned(infraction["number"], infraction["reason"]) - return self.render("main/jams/banned.html", infraction=infraction) - - if infraction["number"]: # Got some jams left - if jam not in infraction["decremented_for"]: - # Make sure they haven't already tried to apply for this jam - infraction["number"] -= 1 - infraction["decremented_for"].append(jam) - - self.db.insert(self.infractions_table, infraction, conflict="replace") - - self.log_banned(infraction["number"], infraction["reason"]) - return self.render("main/jams/banned.html", infraction=infraction, jam=jam_obj) - - if jam in infraction["decremented_for"]: - # They already tried to apply for this jam - self.log_banned(infraction["number"], infraction["reason"]) - return self.render("main/jams/banned.html", infraction=infraction, jam=jam_obj) - - participant = self.db.get(self.participants_table, self.user_data["user_id"]) - - if not participant: - return redirect(url_for("main.jams.profile")) - - if self.get_response(jam, self.user_data["user_id"]): - return self.render("main/jams/already.html", jam=jam_obj) - - form_obj = self.db.get(self.forms_table, jam) - - if not form_obj: - return NotFound() - - questions = [] - - for question in form_obj["questions"]: - questions.append(self.db.get(self.questions_table, question)) - - answers = [] - - for question in questions: - value = request.form.get(question["id"]) - answer = {"question": question["id"]} - - if not question["optional"] and value is None: - return BadRequest() - - if question["type"] == "checkbox": - if value == "on": - answer["value"] = True - elif not question["optional"]: - return BadRequest() - else: - answer["value"] = False - - elif question["type"] == "email": - if value: - address = parseaddr(value) - - if address == ("", ""): - return BadRequest() - - answer["value"] = value - - elif question["type"] in ["number", "range", "slider"]: - if value is not None: - value = int(value) - - if value > int(question["data"]["max"]) or value < int(question["data"]["min"]): - return BadRequest() - - answer["value"] = value - - elif question["type"] == "radio": - if value: - if value not in question["data"]["options"]: - return BadRequest() - - answer["value"] = value - - elif question["type"] in ["text", "textarea"]: - answer["value"] = value - - answers.append(answer) - - user_id = self.user_data["user_id"] - - response = { - "snowflake": user_id, - "jam": jam, - "approved": False, - "answers": answers - } - - self.db.insert(self.responses_table, response) - self.log_success() - - return self.render("main/jams/thanks.html", jam=jam_obj) - - def get_response(self, jam, user_id): - query = self.db.query(self.responses_table).filter({"jam": jam, "snowflake": user_id}) - result = self.db.run(query, coerce=list) - - if result: - return result[0] - return None - - def get_infractions(self, user_id): - query = self.db.query(self.infractions_table).filter({"participant": user_id}) - return self.db.run(query, coerce=list) - - def log_banned(self, number, reason): - user_data = self.user_data - - user_id = user_data["user_id"] - username = user_data["username"] - discriminator = user_data["discriminator"] - - message = f"Failed code jam signup from banned user: {user_id} ({username}#{discriminator})\n\n" - - if number == -1: - message += f"This user has been banned indefinitely. Reason: '{reason}'" - elif number < 1: - message += f"This application has expired the infraction. Reason: '{reason}'" - else: - message += f"This user has {number} more applications left before they're unbanned. Reason: '{reason}'" - - self.rmq_bot_event( - BotEventTypes.mod_log, - { - "level": "warning", "title": "Code Jams: Applications", - "message": message - } - ) - - def log_success(self): - user_data = self.user_data - - user_id = user_data["user_id"] - username = user_data["username"] - discriminator = user_data["discriminator"] - - self.rmq_bot_event( - BotEventTypes.mod_log, - { - "level": "info", "title": "Code Jams: Applications", - "message": f"Successful code jam signup from user: {user_id} " - f"({username}#{discriminator})" - } - ) - - self.rmq_bot_event( - BotEventTypes.send_embed, - { - "target": CHANNEL_JAM_LOGS, - "title": "Code Jams: Applications", - "description": f"Successful code jam signup from user: {user_id} " - f"({username}#{discriminator})", - "colour": 0x2ecc71, # Green from d.py - "timestamp": datetime.datetime.now().isoformat() - } - ) diff --git a/pysite/views/main/jams/profile.py b/pysite/views/main/jams/profile.py deleted file mode 100644 index e918c135..00000000 --- a/pysite/views/main/jams/profile.py +++ /dev/null @@ -1,71 +0,0 @@ -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest - -from pysite.base_route import RouteView -from pysite.decorators import csrf -from pysite.mixins import DBMixin, OAuthMixin - - -class JamsProfileView(RouteView, DBMixin, OAuthMixin): - path = "/jams/profile" - name = "jams.profile" - - table_name = "code_jam_participants" - - def get(self): - if not self.user_data: - return self.redirect_login() - - participant = self.db.get(self.table_name, self.user_data["user_id"]) - existing = True - - if not participant: - participant = {"id": self.user_data["user_id"]} - existing = False - - form = request.args.get("form") - - if form: - try: - form = int(form) - except ValueError: - pass # Someone trying to have some fun I guess - - return self.render( - "main/jams/profile.html", participant=participant, form=form, existing=existing - ) - - @csrf - def post(self): - if not self.user_data: - return self.redirect_login() - - participant = self.db.get(self.table_name, self.user_data["user_id"]) - - if not participant: - participant = {"id": self.user_data["user_id"]} - - gitlab_username = request.form.get("gitlab_username") - timezone = request.form.get("timezone") - - if not gitlab_username or not timezone: - return BadRequest() - - participant["gitlab_username"] = gitlab_username - participant["timezone"] = timezone - - self.db.insert(self.table_name, participant, conflict="replace") - - form = request.args.get("form") - - if form: - try: - form = int(form) - except ValueError: - pass # Someone trying to have some fun I guess - else: - return redirect(url_for("main.jams.join", jam=form)) - - return self.render( - "main/jams/profile.html", participant=participant, done=True, existing=True - ) diff --git a/pysite/views/main/jams/retract.py b/pysite/views/main/jams/retract.py deleted file mode 100644 index 277426b5..00000000 --- a/pysite/views/main/jams/retract.py +++ /dev/null @@ -1,83 +0,0 @@ -from werkzeug.exceptions import BadRequest - -from pysite.base_route import RouteView -from pysite.decorators import csrf -from pysite.mixins import DBMixin, OAuthMixin - -BANNABLE_STATES = ("preparing", "running") - - -class JamsProfileView(RouteView, DBMixin, OAuthMixin): - path = "/jams/retract" - name = "jams.retract" - - table_name = "code_jam_participants" - infractions_table = "code_jam_infractions" - jams_table = "code_jams" - responses_table = "code_jam_responses" - - def get(self): - if not self.user_data: - return self.redirect_login() - - user_id = self.user_data["user_id"] - participant = self.db.get(self.table_name, user_id) - - banned = False - - if participant: - responses = self.db.run(self.db.query(self.responses_table).filter({"snowflake": user_id}), coerce=list) - - for response in responses: - jam = response["jam"] - jam_obj = self.db.get(self.jams_table, jam) - - if jam_obj: - if jam_obj["state"] in BANNABLE_STATES: - banned = True - break - - return self.render( - "main/jams/retract.html", participant=participant, banned=banned - ) - - @csrf - def post(self): - if not self.user_data: - return self.redirect_login() - - user_id = self.user_data["user_id"] - participant = self.db.get(self.table_name, user_id) - - if not participant: - return BadRequest() - - banned = False - - responses = self.db.run(self.db.query(self.responses_table).filter({"snowflake": user_id}), coerce=list) - - for response in responses: - jam = response["jam"] - jam_obj = self.db.get(self.jams_table, jam) - - if jam_obj: - if jam_obj["state"] in BANNABLE_STATES: - banned = True - - self.db.delete(self.responses_table, response["id"]) - - self.db.delete(self.table_name, participant["id"]) - - if banned: - self.db.insert( - self.infractions_table, { - "participant": user_id, - "reason": "Automatic ban: Removed jammer profile in the middle of a code jam", - "number": -1, - "decremented_for": [] - } - ) - - return self.render( - "main/jams/retracted.html", participant=participant, banned=banned - ) diff --git a/pysite/views/main/jams/team_edit_repo.py b/pysite/views/main/jams/team_edit_repo.py deleted file mode 100644 index 03e752bc..00000000 --- a/pysite/views/main/jams/team_edit_repo.py +++ /dev/null @@ -1,151 +0,0 @@ -import logging -import re -from urllib.parse import quote - -import requests -from flask import jsonify, request -from rethinkdb import ReqlNonExistenceError -from urllib3.util import parse_url -from werkzeug.exceptions import NotFound, Unauthorized - -from pysite.base_route import APIView -from pysite.constants import ErrorCodes, GITLAB_ACCESS_TOKEN -from pysite.decorators import csrf -from pysite.mixins import DBMixin, OAuthMixin - -log = logging.getLogger(__name__) - - -class JamsTeamEditRepo(APIView, DBMixin, OAuthMixin): - path = "/jams/teams/<string:team_id>/edit_repo" - name = "jams.team.edit_repo" - - table_name = "code_jam_teams" - jams_table = "code_jams" - - gitlab_projects_api_endpoint = "https://gitlab.com/api/v4/projects/{0}" - - @csrf - def post(self, team_id): - if not self.user_data: - return self.redirect_login() - - try: - query = self.db.query(self.table_name).get(team_id).merge( - lambda team: { - "jam": self.db.query("code_jams").get(team["jam"]) - } - ) - - team = self.db.run(query) - except ReqlNonExistenceError: - log.exception("Failed RethinkDB query") - raise NotFound() - - # Only team members can use this route - if not self.user_data["user_id"] in team["members"]: - raise Unauthorized() - - repo_url = request.form.get("repo_url").strip() - - # Check if repo is a valid GitLab repo URI - url = parse_url(repo_url) - - if url.host != "gitlab.com" or url.path is None: - return self.error( - ErrorCodes.incorrect_parameters, - "Not a GitLab repository." - ) - - project_path = url.path.strip("/") # /user/repository/ --> user/repository - if len(project_path.split("/")) < 2: - return self.error( - ErrorCodes.incorrect_parameters, - "Not a valid repository." - ) - - word_regex = re.compile("^[\-\.\w]+$") # Alphanumerical, underscores, periods, and dashes - for segment in project_path.split("/"): - if not word_regex.fullmatch(segment): - return self.error( - ErrorCodes.incorrect_parameters, - "Not a valid repository." - ) - - project_path_encoded = quote(project_path, safe='') # Replaces / with %2F, etc. - - # If validation returns something else than True, abort - validation = self.validate_project(team, project_path_encoded) - if validation is not True: - return validation - - # Update the team repo - # Note: the team repo is only stored using its path (e.g. user/repository) - team_obj = self.db.get(self.table_name, team_id) - team_obj["repo"] = project_path - self.db.insert(self.table_name, team_obj, conflict="update") - - return jsonify( - { - "project_path": project_path - } - ) - - def validate_project(self, team, project_path): - # Check on GitLab if the project exists - # NB: certain fields (such as "forked_from_project") need an access token - # to be visible. Set the GITLAB_ACCESS_TOKEN env variable to solve this - query_response = self.request_project(project_path) - - if query_response.status_code != 200: - return self.error( - ErrorCodes.incorrect_parameters, - "Not a valid repository." - ) - - # Check if the jam's base repo has been set by staff - # If not, just ignore the fork check and proceed - if "repo" not in team["jam"]: - return True - jam_repo = team["jam"]["repo"] - - # Check if the provided repo is a forked repo - project_data = query_response.json() - if "forked_from_project" not in project_data: - return self.error( - ErrorCodes.incorrect_parameters, - "This repository is not a fork of the jam's repository." - ) - - # Check if the provided repo is forking the base repo - forked_from_project = project_data["forked_from_project"] - - # The jam repo is stored in full (e.g. https://gitlab.com/user/repository) - jam_repo_path = quote(parse_url(jam_repo).path.strip("/"), safe='') - - # Get info about the code jam repo - jam_repo_response = self.request_project(jam_repo_path) - - # Something went wrong, fail silently - if jam_repo_response.status_code != 200: - return True - - # Check if the IDs for the code jam repo and the fork source match - jam_repo_data = jam_repo_response.json() - if jam_repo_data["id"] != forked_from_project["id"]: - return self.error( - ErrorCodes.incorrect_parameters, - "This repository is not a fork of the jam's repository." - ) - - # All good - return True - - def request_project(self, project_path): - # Request the project details using a private access token - return requests.get( - self.gitlab_projects_api_endpoint.format(project_path), - params={ - "private_token": GITLAB_ACCESS_TOKEN - } - ) diff --git a/pysite/views/main/jams/team_view.py b/pysite/views/main/jams/team_view.py deleted file mode 100644 index 6b5d86ce..00000000 --- a/pysite/views/main/jams/team_view.py +++ /dev/null @@ -1,53 +0,0 @@ -import datetime -import logging - -from rethinkdb import ReqlNonExistenceError -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.mixins import DBMixin, OAuthMixin - -log = logging.getLogger(__name__) - - -class JamsTeamView(RouteView, DBMixin, OAuthMixin): - path = "/jams/team/<string:team_id>" - name = "jams.team_view" - - table_name = "code_jam_teams" - - def get(self, team_id: str): - try: - query = self.db.query(self.table_name).get(team_id).merge( - lambda team: { - "members": - self.db.query("users") - .filter(lambda user: team["members"].contains(user["user_id"])) - .merge( - lambda user: { - "gitlab_username": self.db.query("code_jam_participants").filter( - {"id": user["user_id"]} - ).coerce_to("array")[0]["gitlab_username"] - } - ).coerce_to("array"), - "jam": self.db.query("code_jams").get(team["jam"]) - } - ) - - team = self.db.run(query) - except ReqlNonExistenceError: - log.exception("Failed RethinkDB query") - raise NotFound() - - # check if the current user is a member of this team - # (this is for edition privileges) - is_own_team = self.logged_in and self.user_data["user_id"] in [member["user_id"] for member in team["members"]] - - return self.render( - "main/jams/team_view.html", - team=team, is_own_team=is_own_team, day_delta=self.day_delta - ) - - def day_delta(self, date, delta): - # util to add or subtract days from a date - return date + datetime.timedelta(days=delta) diff --git a/pysite/views/main/jams/user_team_list.py b/pysite/views/main/jams/user_team_list.py deleted file mode 100644 index 226cc4b0..00000000 --- a/pysite/views/main/jams/user_team_list.py +++ /dev/null @@ -1,37 +0,0 @@ -import rethinkdb - -from pysite.base_route import RouteView -from pysite.mixins import DBMixin, OAuthMixin - - -class JamsUserTeamListView(RouteView, DBMixin, OAuthMixin): - path = "/jams/my_teams" - name = "jams.user_team_list" - - def get(self): - # list teams a user is (or was) a part of - if not self.user_data: - return self.redirect_login() - - query = self.db.query("code_jam_teams").filter( - lambda team: team["members"].contains(self.user_data["user_id"]) - ).merge( - lambda team: { - "members": - self.db.query("users") - .filter(lambda user: team["members"].contains(user["user_id"])) - .merge(lambda user: { - "gitlab_username": - self.db.query("code_jam_participants").filter({"id": user["user_id"]}) - .coerce_to("array")[0]["gitlab_username"] - }).coerce_to("array"), - "jam": self.db.query("code_jams").get(team["jam"]) - } - ).order_by(rethinkdb.desc("jam.number")) - teams = self.db.run(query) - - return self.render( - "main/jams/team_list.html", - user_teams=True, - teams=teams - ) diff --git a/pysite/views/main/logout.py b/pysite/views/main/logout.py deleted file mode 100644 index 64326371..00000000 --- a/pysite/views/main/logout.py +++ /dev/null @@ -1,16 +0,0 @@ -from flask import redirect, session, url_for - -from pysite.base_route import RouteView - - -class LogoutView(RouteView): - path = "/auth/logout" - name = "logout" - - def get(self): - if self.logged_in: - # remove user's session - del session["session_id"] - self.oauth.logout() - - return redirect(url_for("main.index")) diff --git a/pysite/views/main/redirects/__init__.py b/pysite/views/main/redirects/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/main/redirects/__init__.py +++ /dev/null diff --git a/pysite/views/main/redirects/github.py b/pysite/views/main/redirects/github.py deleted file mode 100644 index 9e9c0cb8..00000000 --- a/pysite/views/main/redirects/github.py +++ /dev/null @@ -1,8 +0,0 @@ -from pysite.base_route import RedirectView - - -class GitHubView(RedirectView): - path = "/github" - name = "github" - page = "https://gitlab.com/python-discord/" - code = 302 diff --git a/pysite/views/main/redirects/gitlab.py b/pysite/views/main/redirects/gitlab.py deleted file mode 100644 index 4b2b60b4..00000000 --- a/pysite/views/main/redirects/gitlab.py +++ /dev/null @@ -1,8 +0,0 @@ -from pysite.base_route import RedirectView - - -class GitLabView(RedirectView): - path = "/gitlab" - name = "gitlab" - page = "https://gitlab.com/python-discord/" - code = 302 diff --git a/pysite/views/main/redirects/invite.py b/pysite/views/main/redirects/invite.py deleted file mode 100644 index 72e0d144..00000000 --- a/pysite/views/main/redirects/invite.py +++ /dev/null @@ -1,8 +0,0 @@ -from pysite.base_route import RedirectView - - -class InviteView(RedirectView): - path = "/invite" - name = "invite" - page = "https://discord.gg/8NWhsvT" - code = 302 diff --git a/pysite/views/main/redirects/stats.py b/pysite/views/main/redirects/stats.py deleted file mode 100644 index 57a56b3d..00000000 --- a/pysite/views/main/redirects/stats.py +++ /dev/null @@ -1,8 +0,0 @@ -from pysite.base_route import RedirectView - - -class StatsView(RedirectView): - path = "/stats" - name = "stats" - page = "https://p.datadoghq.com/sb/ac8680a8c-c01b556f01b96622fd4f57545b81d568" - code = 302 diff --git a/pysite/views/main/robots_txt.py b/pysite/views/main/robots_txt.py deleted file mode 100644 index 308fe2a2..00000000 --- a/pysite/views/main/robots_txt.py +++ /dev/null @@ -1,15 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView - - -class RobotsTXT(RouteView): - path = "/robots.txt" - name = "robots_txt" - - def get(self): - return Response( - self.render( - "robots.txt", sitemap_url=url_for("api.sitemap_xml", _external=True) - ), content_type="text/plain" - ) diff --git a/pysite/views/main/sitemap_xml.py b/pysite/views/main/sitemap_xml.py deleted file mode 100644 index 98893c21..00000000 --- a/pysite/views/main/sitemap_xml.py +++ /dev/null @@ -1,69 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView - - -class SitemapXML(RouteView): - path = "/sitemap.xml" - name = "sitemap_xml" - - def get(self): - urls = [ - { - "type": "url", - "url": url_for("main.index", _external=True), - "priority": 1.0, # Max priority - - "images": [ - { - "caption": "Python Discord Logo", - "url": url_for("static", filename="logos/logo_discord.png", _external=True) - }, - { - "caption": "Python Discord Banner", - "url": url_for("static", filename="logos/logo_banner.png", _external=True) - } - ] - }, - - { - "type": "url", - "url": url_for("main.jams.index", _external=True), - "priority": 0.9 # Above normal priority - }, - - { - "type": "url", - "url": url_for("main.about.privacy", _external=True), - "priority": 0.8 # Above normal priority - }, - { - "type": "url", - "url": url_for("main.about.rules", _external=True), - "priority": 0.8 # Above normal priority - }, - - { - "type": "url", - "url": url_for("main.info.help", _external=True), - "priority": 0.7 # Above normal priority - }, - { - "type": "url", - "url": url_for("main.info.faq", _external=True), - "priority": 0.7 # Above normal priority - }, - { - "type": "url", - "url": url_for("main.info.resources", _external=True), - "priority": 0.7 # Above normal priority - }, - - { - "type": "url", - "url": url_for("main.about.partners", _external=True), - "priority": 0.6 # Normal priority - }, - ] - - return Response(self.render("sitemap.xml", urls=urls), content_type="application/xml") diff --git a/pysite/views/main/ws_test.py b/pysite/views/main/ws_test.py deleted file mode 100644 index a0b6215f..00000000 --- a/pysite/views/main/ws_test.py +++ /dev/null @@ -1,14 +0,0 @@ -import os - -from pysite.base_route import RouteView - - -class WSTest(RouteView): - path = "/ws_test" - name = "ws_test" - - def get(self): - return self.render( - "main/ws_test.html", - server_name=os.environ.get("SERVER_NAME", "localhost") - ) diff --git a/pysite/views/main/ws_test_rst.py b/pysite/views/main/ws_test_rst.py deleted file mode 100644 index e80acc55..00000000 --- a/pysite/views/main/ws_test_rst.py +++ /dev/null @@ -1,14 +0,0 @@ -import os - -from pysite.base_route import RouteView - - -class WSTest(RouteView): - path = "/ws_test_rst" - name = "ws_test_rst" - - def get(self): - return self.render( - "main/ws_test_rst.html", - server_name=os.environ.get("SERVER_NAME", "localhost") - ) diff --git a/pysite/views/staff/__init__.py b/pysite/views/staff/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/__init__.py +++ /dev/null diff --git a/pysite/views/staff/index.py b/pysite/views/staff/index.py deleted file mode 100644 index a090ebdd..00000000 --- a/pysite/views/staff/index.py +++ /dev/null @@ -1,31 +0,0 @@ -from pprint import pformat - -from flask import current_app - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES, DEBUG_MODE, TABLE_MANAGER_ROLES -from pysite.decorators import require_roles - - -class StaffView(RouteView): - path = "/" - name = "index" - - @require_roles(*ALL_STAFF_ROLES) - def get(self): - return self.render( - "staff/index.html", manager=self.is_table_editor(), - app_config=pformat(current_app.config, indent=4, width=120) - ) - - def is_table_editor(self): - if DEBUG_MODE: - return True - - data = self.user_data - - for role in TABLE_MANAGER_ROLES: - if role in data.get("roles", []): - return True - - return False diff --git a/pysite/views/staff/jams/__init__.py b/pysite/views/staff/jams/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/jams/__init__.py +++ /dev/null diff --git a/pysite/views/staff/jams/actions.py b/pysite/views/staff/jams/actions.py deleted file mode 100644 index dfcbf2de..00000000 --- a/pysite/views/staff/jams/actions.py +++ /dev/null @@ -1,597 +0,0 @@ -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 = ( - "associate_question", "disassociate_question", "infraction", "questions", "state", "approve_application", - "unapprove_application", "create_team", "generate_teams", "set_team_member", - "reroll_team", "set_winning_team", "unset_winning_team" -) -DELETE_ACTIONS = ("infraction", "question", "team") - -KEYS = ("action",) -QUESTION_KEYS = ("optional", "title", "type") - - -class ActionView(APIView, DBMixin, RMQMixin): - path = "/jams/action" - name = "jams.action" - - table_name = "code_jams" - forms_table = "code_jam_forms" - 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) - def get(self): - action = request.args.get("action") - - if action not in GET_ACTIONS: - return self.error(ErrorCodes.incorrect_parameters) - - if action == "questions": - questions = self.db.get_all(self.questions_table) - - return jsonify({"questions": questions}) - - @csrf - @require_roles(*ALL_STAFF_ROLES) - def post(self): - if request.is_json: - data = request.get_json(force=True) - action = data["action"] if "action" in data else None - else: - action = request.form.get("action") - - if action not in POST_ACTIONS: - return self.error(ErrorCodes.incorrect_parameters) - - if action == "associate_question": - form = int(request.form.get("form")) - question = request.form.get("question") - - form_obj = self.db.get(self.forms_table, form) - - if not form_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown form: {form}") - - question_obj = self.db.get(self.questions_table, question) - - if not question_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown question: {question}") - - if question_obj["id"] not in form_obj["questions"]: - form_obj["questions"].append(question_obj["id"]) - self.db.insert(self.forms_table, form_obj, conflict="replace") - - return jsonify({"question": question_obj}) - else: - return self.error( - ErrorCodes.incorrect_parameters, - f"Question {question} already associated with form {form}" - ) - - if action == "disassociate_question": - form = int(request.form.get("form")) - question = request.form.get("question") - - form_obj = self.db.get(self.forms_table, form) - - if not form_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown form: {form}") - - question_obj = self.db.get(self.questions_table, question) - - if not question_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown question: {question}") - - if question_obj["id"] in form_obj["questions"]: - form_obj["questions"].remove(question_obj["id"]) - self.db.insert(self.forms_table, form_obj, conflict="replace") - - return jsonify({"question": question_obj}) - else: - return self.error( - ErrorCodes.incorrect_parameters, - f"Question {question} not already associated with form {form}" - ) - - if action == "state": - jam = int(request.form.get("jam")) - state = request.form.get("state") - - if not all((jam, state)): - return self.error(ErrorCodes.incorrect_parameters) - - jam_obj = self.db.get(self.table_name, jam) - jam_obj["state"] = state - self.db.insert(self.table_name, jam_obj, conflict="update") - - return jsonify({}) - - if action == "questions": - data = request.get_json(force=True) - - for key in QUESTION_KEYS: - if key not in data: - return self.error(ErrorCodes.incorrect_parameters, f"Missing key: {key}") - - title = data["title"] - optional = data["optional"] - question_type = data["type"] - question_data = data.get("data", {}) - - if question_type in ["number", "range", "slider"]: - if "max" not in question_data or "min" not in question_data: - return self.error( - ErrorCodes.incorrect_parameters, f"{question_type} questions must have both max and min values" - ) - - result = self.db.insert( - self.questions_table, - { - "title": title, - "optional": optional, - "type": question_type, - "data": { - "max": question_data["max"], - "min": question_data["min"] - } - }, - conflict="error" - ) - elif question_type == "radio": - if "options" not in question_data: - return self.error( - ErrorCodes.incorrect_parameters, f"{question_type} questions must have both options" - ) - - result = self.db.insert( - self.questions_table, - { - "title": title, - "optional": optional, - "type": question_type, - "data": { - "options": question_data["options"] - } - }, - conflict="error" - ) - else: - result = self.db.insert( - self.questions_table, - { # No extra data for other types of question - "title": title, - "optional": optional, - "type": question_type - }, - conflict="error" - ) - - return jsonify({"id": result["generated_keys"][0]}) - - if action == "infraction": - participant = request.form.get("participant") - reason = request.form.get("reason") - - if not participant or not reason or "number" not in request.form: - return self.error( - ErrorCodes.incorrect_parameters, "Infractions must have a participant, reason and number" - ) - - number = int(request.form.get("number")) - - result = self.db.insert(self.infractions_table, { - "participant": participant, - "reason": reason, - "number": number, - "decremented_for": [] - }) - - 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": [], - "jam": jam - } - - 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) - .filter(lambda team_row: jam_obj["teams"].contains(team_row["id"])) - .pluck(["id", "name", "members", "jam"]) - .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 == "set_winning_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" - ) - - jam_number = team_obj["jam"] - jam_obj = self.db.get(self.table_name, jam_number) - jam_obj["winning_team"] = team - self.db.insert(self.table_name, jam_obj, conflict="replace") - - return jsonify({"result": "success"}) - - if action == "unset_winning_team": - jam = request.form.get("jam", type=int) - - if not jam: - return self.error( - ErrorCodes.incorrect_parameters, "Jam number required" - ) - - jam_obj = self.db.get(self.table_name, jam) - if not jam_obj: - return self.error( - ErrorCodes.incorrect_parameters, "Unknown jam number" - ) - - jam_obj["winning_team"] = None - self.db.insert(self.table_name, jam_obj, conflict="replace") - - return jsonify({"result": "success"}) - - if action == "approve_application": - app = request.form.get("id") - - if not app: - return self.error( - ErrorCodes.incorrect_parameters, "Application ID required" - ) - - app_obj = self.db.get(self.responses_table, app) - - if not app_obj: - return self.error( - ErrorCodes.incorrect_parameters, "Unknown application ID" - ) - - app_obj["approved"] = True - - self.db.insert(self.responses_table, app_obj, conflict="replace") - - jam_obj = self.db.get(self.table_name, app_obj["jam"]) - - snowflake = app_obj["snowflake"] - participants = jam_obj.get("participants", []) - - if snowflake not in participants: - participants.append(snowflake) - jam_obj["participants"] = participants - self.db.insert(self.table_name, jam_obj, conflict="replace") - - self.rmq_bot_event( - BotEventTypes.add_role, - { - "reason": "Code jam application approved", - "role_id": JAMMERS_ROLE, - "target": snowflake, - } - ) - - self.rmq_bot_event( - BotEventTypes.send_message, - { - "message": f"Congratulations <@{snowflake}> - you've been approved, " - f"and we've assigned you the Jammer role!", - "target": CHANNEL_JAM_LOGS, - } - ) - - return jsonify({"result": "success"}) - - if action == "unapprove_application": - app = request.form.get("id") - - if not app: - return self.error( - ErrorCodes.incorrect_parameters, "Application ID required" - ) - - app_obj = self.db.get(self.responses_table, app) - - if not app_obj: - return self.error( - ErrorCodes.incorrect_parameters, "Unknown application ID" - ) - - app_obj["approved"] = False - - self.db.insert(self.responses_table, app_obj, conflict="replace") - - jam_obj = self.db.get(self.table_name, app_obj["jam"]) - - snowflake = app_obj["snowflake"] - participants = jam_obj.get("participants", []) - - if snowflake in participants: - participants.remove(snowflake) - jam_obj["participants"] = participants - - self.db.insert(self.table_name, jam_obj, conflict="replace") - - self.rmq_bot_event( - BotEventTypes.remove_role, - { - "reason": "Code jam application unapproved", - "role_id": JAMMERS_ROLE, - "target": snowflake, - } - ) - - return jsonify({"result": "success"}) - - @csrf - @require_roles(*ALL_STAFF_ROLES) - def delete(self): - action = request.form.get("action") - - if action not in DELETE_ACTIONS: - return self.error(ErrorCodes.incorrect_parameters) - - if action == "question": - question = request.form.get("id") - - if not question: - return self.error(ErrorCodes.incorrect_parameters, f"Missing key: id") - - question_obj = self.db.get(self.questions_table, question) - - if not question_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown question: {question}") - - self.db.delete(self.questions_table, question) - - for form_obj in self.db.get_all(self.forms_table): - if question in form_obj["questions"]: - form_obj["questions"].remove(question) - self.db.insert(self.forms_table, form_obj, conflict="replace") - - return jsonify({"id": question}) - - if action == "infraction": - infraction = request.form.get("id") - - if not infraction: - return self.error(ErrorCodes.incorrect_parameters, "Missing key id") - - infraction_obj = self.db.get(self.infractions_table, infraction) - - if not infraction_obj: - return self.error(ErrorCodes.incorrect_parameters, f"Unknown infraction: {infraction}") - - 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" - ) - - team_obj = self.db.get(self.teams_table, team) - - if not team_obj: - return self.error( - ErrorCodes.incorrect_parameters, "Unknown team ID" - ) - - jam_obj = self.db.get(self.table_name, team_obj["jam"]) - if jam_obj: - jam_obj["teams"].remove(team) - self.db.insert(self.table_name, jam_obj, conflict="update") - - self.db.delete(self.teams_table, team) - - return jsonify({"result": True}) diff --git a/pysite/views/staff/jams/create.py b/pysite/views/staff/jams/create.py deleted file mode 100644 index ef61cbef..00000000 --- a/pysite/views/staff/jams/create.py +++ /dev/null @@ -1,61 +0,0 @@ -import datetime - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin - -REQUIRED_KEYS = ["title", "date_start", "date_end"] - - -class StaffView(RouteView, DBMixin): - path = "/jams/create" - name = "jams.create" - table_name = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self): - number = self.get_next_number() - return self.render("staff/jams/create.html", number=number) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self): - data = {} - - for key in REQUIRED_KEYS: - arg = request.form.get(key) - - if not arg: - return BadRequest() - - data[key] = arg - - data["state"] = "planning" - data["number"] = self.get_next_number() - - # Convert given datetime strings into actual objects, adding timezones to keep rethinkdb happy - date_start = datetime.datetime.strptime(data["date_start"], "%Y-%m-%d %H:%M") - date_start = date_start.replace(tzinfo=datetime.timezone.utc) - - date_end = datetime.datetime.strptime(data["date_end"], "%Y-%m-%d %H:%M") - date_end = date_end.replace(tzinfo=datetime.timezone.utc) - - data["date_start"] = date_start - data["date_end"] = date_end - - self.db.insert(self.table_name, data) - - return redirect(url_for("staff.jams.index")) - - def get_next_number(self) -> int: - count = self.db.run(self.table.count(), coerce=int) - - if count: - max_num = self.db.run(self.table.max("number"))["number"] - - return max_num + 1 - return 1 diff --git a/pysite/views/staff/jams/edit_basics.py b/pysite/views/staff/jams/edit_basics.py deleted file mode 100644 index 462cba14..00000000 --- a/pysite/views/staff/jams/edit_basics.py +++ /dev/null @@ -1,55 +0,0 @@ -import datetime - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin - -REQUIRED_KEYS = ["title", "date_start", "date_end"] - - -class StaffView(RouteView, DBMixin): - path = "/jams/<int:jam>/edit/basics" - name = "jams.edit.basics" - table_name = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - return self.render("staff/jams/edit_basics.html", jam=jam_obj) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - for key in REQUIRED_KEYS: - arg = request.form.get(key) - - if not arg: - return BadRequest() - - jam_obj[key] = arg - - # Convert given datetime strings into actual objects, adding timezones to keep rethinkdb happy - date_start = datetime.datetime.strptime(jam_obj["date_start"], "%Y-%m-%d %H:%M") - date_start = date_start.replace(tzinfo=datetime.timezone.utc) - - date_end = datetime.datetime.strptime(jam_obj["date_end"], "%Y-%m-%d %H:%M") - date_end = date_end.replace(tzinfo=datetime.timezone.utc) - - jam_obj["date_start"] = date_start - jam_obj["date_end"] = date_end - - self.db.insert(self.table_name, jam_obj, conflict="replace") - - return redirect(url_for("staff.jams.index")) diff --git a/pysite/views/staff/jams/edit_ending.py b/pysite/views/staff/jams/edit_ending.py deleted file mode 100644 index 43a36ebc..00000000 --- a/pysite/views/staff/jams/edit_ending.py +++ /dev/null @@ -1,54 +0,0 @@ -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin -from pysite.rst import render - -REQUIRED_KEYS = ["end_rst"] -ALLOWED_STATES = ["judging", "finished"] - - -class StaffView(RouteView, DBMixin): - path = "/jams/<int:jam>/edit/ending" - name = "jams.edit.ending" - table_name = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not jam_obj["state"] in ALLOWED_STATES: - return BadRequest() - - return self.render("staff/jams/edit_ending.html", jam=jam_obj) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not jam_obj["state"] in ALLOWED_STATES: - return BadRequest() - - for key in REQUIRED_KEYS: - arg = request.form.get(key) - - if not arg: - return BadRequest() - - jam_obj[key] = arg - - jam_obj["end_html"] = render(jam_obj["end_rst"], link_headers=False)["html"] - - self.db.insert(self.table_name, jam_obj, conflict="replace") - - return redirect(url_for("staff.jams.index")) diff --git a/pysite/views/staff/jams/edit_info.py b/pysite/views/staff/jams/edit_info.py deleted file mode 100644 index 4944ae67..00000000 --- a/pysite/views/staff/jams/edit_info.py +++ /dev/null @@ -1,55 +0,0 @@ -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin -from pysite.rst import render - -REQUIRED_KEYS = ["info_rst", "repo", "task_rst", "theme"] -ALLOWED_STATES = ["planning", "announced", "preparing", "finished"] - - -class StaffView(RouteView, DBMixin): - path = "/jams/<int:jam>/edit/info" - name = "jams.edit.info" - table_name = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not jam_obj["state"] in ALLOWED_STATES: - return BadRequest() - - return self.render("staff/jams/edit_info.html", jam=jam_obj) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - if not jam_obj["state"] in ALLOWED_STATES: - return BadRequest() - - for key in REQUIRED_KEYS: - arg = request.form.get(key) - - if not arg: - return BadRequest() - - jam_obj[key] = arg - - jam_obj["task_html"] = render(jam_obj["task_rst"], link_headers=False)["html"] - jam_obj["info_html"] = render(jam_obj["info_rst"], link_headers=False)["html"] - - self.db.insert(self.table_name, jam_obj, conflict="replace") - - return redirect(url_for("staff.jams.index")) diff --git a/pysite/views/staff/jams/forms/__init__.py b/pysite/views/staff/jams/forms/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/jams/forms/__init__.py +++ /dev/null diff --git a/pysite/views/staff/jams/forms/preamble_edit.py b/pysite/views/staff/jams/forms/preamble_edit.py deleted file mode 100644 index 59b4678b..00000000 --- a/pysite/views/staff/jams/forms/preamble_edit.py +++ /dev/null @@ -1,45 +0,0 @@ -from flask import redirect, request, url_for -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin -from pysite.rst import render - - -class StaffView(RouteView, DBMixin): - path = "/jams/form/<int:jam>/preamble" - name = "jams.forms.preamble.edit" - - table_name = "code_jam_forms" - jams_table = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam): - jam_obj = self.db.get(self.jams_table, jam) - - if not jam_obj: - return NotFound() - - form_obj = self.db.get(self.table_name, jam) - return self.render("staff/jams/forms/preamble_edit.html", jam=jam_obj, form=form_obj) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - form_obj = self.db.get(self.table_name, jam) - - preamble_rst = request.form.get("preamble_rst") - - form_obj["preamble_rst"] = preamble_rst - form_obj["preamble_html"] = render(preamble_rst, link_headers=False)["html"] - - self.db.insert(self.table_name, form_obj, conflict="replace") - - return redirect(url_for("staff.jams.forms.view", jam=jam)) diff --git a/pysite/views/staff/jams/forms/questions_edit.py b/pysite/views/staff/jams/forms/questions_edit.py deleted file mode 100644 index d46c4ef3..00000000 --- a/pysite/views/staff/jams/forms/questions_edit.py +++ /dev/null @@ -1,75 +0,0 @@ -import json - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin - -REQUIRED_KEYS = ["title", "date_start", "date_end"] - - -class StaffView(RouteView, DBMixin): - path = "/jams/forms/questions/<question>" - name = "jams.forms.questions.edit" - - questions_table = "code_jam_questions" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, question): - question_obj = self.db.get(self.questions_table, question) - - if not question_obj: - return NotFound() - - question_obj["data"] = question_obj.get("data", {}) - - return self.render( - "staff/jams/forms/questions_edit.html", question=question_obj - ) - - @require_roles(*ALL_STAFF_ROLES) - @csrf - def post(self, question): - question_obj = self.db.get(self.questions_table, question) - - if not question_obj: - return NotFound() - - title = request.form.get("title") - optional = request.form.get("optional") - question_type = request.form.get("type") - - if not title or not optional or not question_type: - return BadRequest() - - question_obj["title"] = title - question_obj["optional"] = optional == "optional" - question_obj["type"] = question_type - - if question_type == "radio": - options = request.form.get("options") - - if not options: - return BadRequest() - - options = json.loads(options)["options"] # No choice this time - question_obj["data"] = {"options": options} - - elif question_type in ("number", "range", "slider"): - question_min = request.form.get("min") - question_max = request.form.get("max") - - if question_min is None or question_max is None: - return BadRequest() - - question_obj["data"] = { - "min": question_min, - "max": question_max - } - - self.db.insert(self.questions_table, question_obj, conflict="replace") - - return redirect(url_for("staff.jams.forms.questions")) diff --git a/pysite/views/staff/jams/forms/questions_view.py b/pysite/views/staff/jams/forms/questions_view.py deleted file mode 100644 index 50ad009e..00000000 --- a/pysite/views/staff/jams/forms/questions_view.py +++ /dev/null @@ -1,22 +0,0 @@ -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/forms/questions" - name = "jams.forms.questions" - - questions_table = "code_jam_questions" - - @require_roles(*ALL_STAFF_ROLES) - def get(self): - questions = self.db.get_all(self.questions_table) - - return self.render( - "staff/jams/forms/questions_view.html", questions=questions, - question_ids=[q["id"] for q in questions] - ) diff --git a/pysite/views/staff/jams/forms/view.py b/pysite/views/staff/jams/forms/view.py deleted file mode 100644 index 8d4e16ad..00000000 --- a/pysite/views/staff/jams/forms/view.py +++ /dev/null @@ -1,46 +0,0 @@ -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/forms/<int:jam>" - name = "jams.forms.view" - - table_name = "code_jams" - forms_table = "code_jam_forms" - questions_table = "code_jam_questions" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam): - jam_obj = self.db.get(self.table_name, jam) - - if not jam_obj: - return NotFound() - - form_obj = self.db.get(self.forms_table, jam) - - if not form_obj: - form_obj = { - "number": jam, - "questions": [], - "preamble_rst": "", - "preamble_html": "" - } - - self.db.insert(self.forms_table, form_obj) - - if form_obj["questions"]: - questions = self.db.get_all(self.questions_table, *[q for q in form_obj["questions"]]) - else: - questions = [] - - return self.render( - "staff/jams/forms/view.html", jam=jam_obj, form=form_obj, - questions=questions, question_ids=[q["id"] for q in questions] - ) diff --git a/pysite/views/staff/jams/index.py b/pysite/views/staff/jams/index.py deleted file mode 100644 index 40a8387c..00000000 --- a/pysite/views/staff/jams/index.py +++ /dev/null @@ -1,15 +0,0 @@ -from pysite.base_route import RouteView -from pysite.constants import ALL_STAFF_ROLES, JAM_STATES -from pysite.decorators import require_roles -from pysite.mixins import DBMixin - - -class StaffView(RouteView, DBMixin): - path = "/jams" - name = "jams.index" - table_name = "code_jams" - - @require_roles(*ALL_STAFF_ROLES) - def get(self): - jams = self.db.get_all(self.table_name) - return self.render("staff/jams/index.html", jams=jams, states=JAM_STATES) diff --git a/pysite/views/staff/jams/infractions/__init__.py b/pysite/views/staff/jams/infractions/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/jams/infractions/__init__.py +++ /dev/null diff --git a/pysite/views/staff/jams/infractions/view.py b/pysite/views/staff/jams/infractions/view.py deleted file mode 100644 index 235f99ac..00000000 --- a/pysite/views/staff/jams/infractions/view.py +++ /dev/null @@ -1,29 +0,0 @@ -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/infractions" - name = "jams.infractions" - - table_name = "code_jam_infractions" - users_table = "users" - - @require_roles(*ALL_STAFF_ROLES) - def get(self): - infractions = self.db.get_all(self.table_name) - - for document in infractions: - user_obj = self.db.get(self.users_table, document["participant"]) - - if user_obj: - document["participant"] = user_obj - - return self.render( - "staff/jams/infractions/view.html", infractions=infractions, - infraction_ids=[i["id"] for i in infractions] - ) diff --git a/pysite/views/staff/jams/participants.py b/pysite/views/staff/jams/participants.py deleted file mode 100644 index 52f9bdec..00000000 --- a/pysite/views/staff/jams/participants.py +++ /dev/null @@ -1,56 +0,0 @@ -import logging - -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"] -log = logging.getLogger(__name__) - - -class StaffView(RouteView, DBMixin): - path = "/jams/participants/<int:jam>" - name = "jams.participants" - - forms_table = "code_jam_forms" - participants_table = "code_jam_participants" - questions_table = "code_jam_questions" - responses_table = "code_jam_responses" - table_name = "code_jams" - users_table = "users" - - @require_roles(*ALL_STAFF_ROLES) - def get(self, jam: int): - 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"]}) - .eq_join("snowflake", self.db.query(self.users_table)) - .without({"left": "snowflake"}) - .zip() - .coerce_to("array") - } - ) - - jam_data = self.db.run(query) - except ReqlNonExistenceError: - log.exception("Failed RethinkDB query") - raise NotFound() - - form_obj = self.db.get(self.forms_table, jam) - questions = {} - - if form_obj: - for question in form_obj["questions"]: - questions[question] = self.db.get(self.questions_table, question) - - return self.render( - "staff/jams/participants.html", - jam=jam_data, form=form_obj, questions=questions - ) diff --git a/pysite/views/staff/jams/teams/__init__.py b/pysite/views/staff/jams/teams/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/jams/teams/__init__.py +++ /dev/null diff --git a/pysite/views/staff/jams/teams/view.py b/pysite/views/staff/jams/teams/view.py deleted file mode 100644 index 662cc084..00000000 --- a/pysite/views/staff/jams/teams/view.py +++ /dev/null @@ -1,102 +0,0 @@ -import logging - -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") -log = logging.getLogger(__name__) - - -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": - self.db.query(self.table_name) - .filter(lambda team_row: jam_obj["teams"].contains(team_row["id"])) - .pluck(["id", "name", "members"]) - .coerce_to("array") - } - ) - - jam_data = self.db.run(query) - except ReqlNonExistenceError: - log.exception("Failed RethinkDB query") - 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 - ) diff --git a/pysite/views/staff/render.py b/pysite/views/staff/render.py deleted file mode 100644 index 0152e568..00000000 --- a/pysite/views/staff/render.py +++ /dev/null @@ -1,62 +0,0 @@ -import re - -from docutils.utils import SystemMessage -from flask import jsonify -from schema import Schema - -from pysite.base_route import APIView -from pysite.constants import EDITOR_ROLES, ValidationTypes -from pysite.decorators import api_params, csrf, require_roles -from pysite.rst import render - -SCHEMA = Schema([{ - "data": str -}]) - -MESSAGE_REGEX = re.compile(r"<string>:(\d+): \([A-Z]+/\d\) (.*)") - - -class RenderView(APIView): - path = "/render" # "path" means that it accepts slashes - name = "render" - - @csrf - @require_roles(*EDITOR_ROLES) - @api_params(schema=SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - if not len(data): - return jsonify({"error": "No data!"}) - - data = data[0]["data"] - try: - html = render(data, link_headers=False)["html"] - - return jsonify({"data": html}) - except SystemMessage as e: - lines = str(e) - data = { - "error": lines, - "error_lines": [] - } - - if "\n" in lines: - lines = lines.split("\n") - else: - lines = [lines] - - for message in lines: - match = MESSAGE_REGEX.match(message) - - if match: - data["error_lines"].append( - { - "row": int(match.group(1)) - 3, - "column": 0, - "type": "error", - "text": match.group(2) - } - ) - - return jsonify(data) - except Exception as e: - return jsonify({"error": str(e)}) diff --git a/pysite/views/staff/robots_txt.py b/pysite/views/staff/robots_txt.py deleted file mode 100644 index 308fe2a2..00000000 --- a/pysite/views/staff/robots_txt.py +++ /dev/null @@ -1,15 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView - - -class RobotsTXT(RouteView): - path = "/robots.txt" - name = "robots_txt" - - def get(self): - return Response( - self.render( - "robots.txt", sitemap_url=url_for("api.sitemap_xml", _external=True) - ), content_type="text/plain" - ) diff --git a/pysite/views/staff/sitemap_xml.py b/pysite/views/staff/sitemap_xml.py deleted file mode 100644 index 26a786b0..00000000 --- a/pysite/views/staff/sitemap_xml.py +++ /dev/null @@ -1,11 +0,0 @@ -from flask import Response - -from pysite.base_route import RouteView - - -class SitemapXML(RouteView): - path = "/sitemap.xml" - name = "sitemap_xml" - - def get(self): - return Response(self.render("sitemap.xml", urls=[]), content_type="application/xml") diff --git a/pysite/views/staff/tables/__init__.py b/pysite/views/staff/tables/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/staff/tables/__init__.py +++ /dev/null diff --git a/pysite/views/staff/tables/edit.py b/pysite/views/staff/tables/edit.py deleted file mode 100644 index 7de63ad2..00000000 --- a/pysite/views/staff/tables/edit.py +++ /dev/null @@ -1,110 +0,0 @@ -import json - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import TABLE_MANAGER_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin -from pysite.tables import TABLES - - -class TableEditView(RouteView, DBMixin): - path = "/tables/<table>/edit" - name = "tables.edit" - - @require_roles(*TABLE_MANAGER_ROLES) - def get(self, table): - obj = TABLES.get(table) - - if not obj: - # Unknown table - raise NotFound() - - if obj.locked: - return redirect(url_for("staff.tables.table", table=table, page=1), code=303) - - key = request.args.get("key") - - old_primary = None - - if key: - db_obj = self.db.get(table, key) - old_primary = key # Provide the current document's primary key, in case it's modified - - document = json.dumps( # Editor uses JSON - db_obj, - indent=4 - ) - else: - document = json.dumps( # Generate default document from key schema - {k: "" for k in obj.keys}, - indent=4 - ) - - return self.render( - "staff/tables/edit.html", table=table, primary_key=obj.primary_key, - document=document, old_primary=old_primary - ) - - @require_roles(*TABLE_MANAGER_ROLES) - @csrf - def post(self, table): - obj = TABLES.get(table) - - if not obj: - # Unknown table - raise NotFound() - - if obj.locked: - raise BadRequest() - - data = request.form.get("json") - old_primary = request.form.get("old_primary") - - if not data: - # No data given (for some reason) - document = json.dumps( - {k: "" for k in obj.keys}, - indent=4 - ) - - return self.render( - "staff/tables/edit.html", table=table, primary_key=obj.primary_key, document=document, - message="Please provide some data to save", old_primary=old_primary - ) - - try: - data = json.loads(data) - except json.JSONDecodeError as e: - # Invalid JSON - return self.render( - "staff/tables/edit.html", table=table, primary_key=obj.primary_key, document=data, - message=f"Invalid JSON, please try again: {e}", old_primary=old_primary - ) - - if not data[obj.primary_key]: - # No primary key value provided - return self.render( - "staff/tables/edit.html", table=table, primary_key=obj.primary_key, document=data, - message=f"Please provide a value for the primary key: {obj.primary_key}", old_primary=old_primary - ) - - if old_primary is None: - self.db.insert( # This is a new object, so just insert it - table, data - ) - elif old_primary == data[obj.primary_key]: - self.db.insert( # This is an update without a primary key change, replace the whole document - table, data, conflict="replace" - ) - else: - self.db.delete( # This is a primary key change, so we need to remove the old object - table, old_primary - ) - self.db.insert( - table, data, - ) - - return redirect(url_for("staff.tables.table", table=table, page=1), code=303) diff --git a/pysite/views/staff/tables/index.py b/pysite/views/staff/tables/index.py deleted file mode 100644 index 0d84aeb4..00000000 --- a/pysite/views/staff/tables/index.py +++ /dev/null @@ -1,13 +0,0 @@ -from pysite.base_route import RouteView -from pysite.constants import TABLE_MANAGER_ROLES -from pysite.decorators import require_roles -from pysite.tables import TABLES - - -class TablesView(RouteView): - path = "/tables" - name = "tables.index" - - @require_roles(*TABLE_MANAGER_ROLES) - def get(self): - return self.render("staff/tables/index.html", tables=TABLES) diff --git a/pysite/views/staff/tables/table.py b/pysite/views/staff/tables/table.py deleted file mode 100644 index f47d7793..00000000 --- a/pysite/views/staff/tables/table.py +++ /dev/null @@ -1,63 +0,0 @@ -from math import ceil - -from flask import request -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import TABLE_MANAGER_ROLES -from pysite.decorators import require_roles -from pysite.mixins import DBMixin -from pysite.tables import TABLES - - -class TableView(RouteView, DBMixin): - path = "/tables/<table>/<page>" - name = "tables.table" - - @require_roles(*TABLE_MANAGER_ROLES) - def get(self, table, page): - search = request.args.get("search") - search_key = request.args.get("search-key") - - pages = page - obj = TABLES.get(table) - - if not obj: - return NotFound() - - if search: - new_search = f"(?i){search}" # Case-insensitive search - search_key = search_key or obj.primary_key - - query = self.db.query(table).filter(lambda d: d[search_key].match(new_search)) - else: - query = self.db.query(table) - - if page != "all": - try: - page = int(page) - except ValueError: - # Not an integer - return BadRequest() - - count = self.db.run(query.count(), coerce=int) - pages = max(ceil(count / 10), 1) # Pages if we have 10 documents per page, always at least one - - if page < 1 or page > pages: - # If the page is too small or too big, well, that's an error - return BadRequest() - - documents = self.db.run( # Get only the documents for this page - query.skip((page - 1) * 10).limit(10), - coerce=list - ) - else: - documents = self.db.run(query, coerce=list) - - documents = [dict(sorted(d.items())) for d in documents] - - return self.render( - "staff/tables/table.html", - table=table, documents=documents, table_obj=obj, - page=page, pages=pages, search=search, search_key=search_key - ) diff --git a/pysite/views/staff/tables/table_bare.py b/pysite/views/staff/tables/table_bare.py deleted file mode 100644 index abd6cb19..00000000 --- a/pysite/views/staff/tables/table_bare.py +++ /dev/null @@ -1,30 +0,0 @@ -from flask import redirect, request, url_for -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import TABLE_MANAGER_ROLES -from pysite.decorators import require_roles -from pysite.mixins import DBMixin -from pysite.tables import TABLES - - -class TableView(RouteView, DBMixin): - path = "/tables/<table>" - name = "tables.table_bare" - - @require_roles(*TABLE_MANAGER_ROLES) - def get(self, table): - if table not in TABLES: - raise NotFound() - - search = request.args.get("search") - - args = { - "table": table, - "page": 1 - } - - if search is not None: - args["search"] = search - - return redirect(url_for("staff.tables.table", **args)) diff --git a/pysite/views/tests/__init__.py b/pysite/views/tests/__init__.py deleted file mode 100644 index adfc1286..00000000 --- a/pysite/views/tests/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# .gitkeep diff --git a/pysite/views/tests/index.py b/pysite/views/tests/index.py deleted file mode 100644 index f99e3f3c..00000000 --- a/pysite/views/tests/index.py +++ /dev/null @@ -1,23 +0,0 @@ -from flask import jsonify -from schema import Schema - -from pysite.base_route import APIView -from pysite.constants import ValidationTypes -from pysite.decorators import api_params - -LIST_SCHEMA = Schema([{"test": str}]) -DICT_SCHEMA = Schema({"segfault": str}) - - -class TestParamsView(APIView): - path = "/testparams" - name = "testparams" - - @api_params(schema=DICT_SCHEMA, validation_type=ValidationTypes.params) - def get(self, data): - return jsonify(data) - - @api_params(schema=LIST_SCHEMA, validation_type=ValidationTypes.params) - def post(self, data): - jsonified = jsonify(data) - return jsonified diff --git a/pysite/views/wiki/__init__.py b/pysite/views/wiki/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/wiki/__init__.py +++ /dev/null diff --git a/pysite/views/wiki/delete.py b/pysite/views/wiki/delete.py deleted file mode 100644 index 728570a9..00000000 --- a/pysite/views/wiki/delete.py +++ /dev/null @@ -1,64 +0,0 @@ -import datetime - -from flask import redirect, url_for -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import BotEventTypes, CHANNEL_MOD_LOG, EDITOR_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin, RMQMixin - - -class DeleteView(RouteView, DBMixin, RMQMixin): - path = "/delete/<path:page>" # "path" means that it accepts slashes - name = "delete" - table_name = "wiki" - revision_table_name = "wiki_revisions" - - @require_roles(*EDITOR_ROLES) - def get(self, page): - obj = self.db.get(self.table_name, page) - - if obj: - title = obj.get("title", "") - - if obj.get("lock_expiry") and obj.get("lock_user") != self.user_data.get("user_id"): - lock_time = datetime.datetime.fromtimestamp(obj["lock_expiry"]) - if datetime.datetime.utcnow() < lock_time: - return self.render("wiki/page_in_use.html", page=page) - - return self.render("wiki/page_delete.html", page=page, title=title, can_edit=True) - else: - raise NotFound() - - @require_roles(*EDITOR_ROLES) - @csrf - def post(self, page): - obj = self.db.get(self.table_name, page) - - if not obj: - raise NotFound() - - self.db.delete(self.table_name, page) - self.db.delete(self.revision_table_name, page) - - revisions = self.db.filter(self.revision_table_name, lambda revision: revision["slug"] == page) - - for revision in revisions: - self.db.delete(self.revision_table_name, revision["id"]) - - self.audit_log(obj) - - return redirect(url_for("wiki.page", page="home"), code=303) # Redirect, ensuring a GET - - def audit_log(self, obj): - self.rmq_bot_event( - BotEventTypes.send_embed, - { - "target": CHANNEL_MOD_LOG, - "title": f"Page Deletion", - "description": f"**{obj['title']}** was deleted by **{self.user_data.get('username')}**", - "colour": 0x3F8DD7, # Light blue - "timestamp": datetime.datetime.now().isoformat() - } - ) diff --git a/pysite/views/wiki/edit.py b/pysite/views/wiki/edit.py deleted file mode 100644 index 949c9942..00000000 --- a/pysite/views/wiki/edit.py +++ /dev/null @@ -1,149 +0,0 @@ -import datetime -import html -import re - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest - -from pysite.base_route import RouteView -from pysite.constants import BotEventTypes, CHANNEL_MOD_LOG, DEBUG_MODE, EDITOR_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin, RMQMixin -from pysite.rst import render - -STRIP_REGEX = re.compile(r"<[^<]+?>") - - -class EditView(RouteView, DBMixin, RMQMixin): - path = "/edit/<path:page>" # "path" means that it accepts slashes - name = "edit" - table_name = "wiki" - revision_table_name = "wiki_revisions" - - @require_roles(*EDITOR_ROLES) - def get(self, page): - rst = "" - title = "" - preview = "<p>Preview will appear here.</p>" - - obj = self.db.get(self.table_name, page) - - if obj: - rst = obj.get("rst", "") - title = obj.get("title", "") - preview = obj.get("html", preview) - - if obj.get("lock_expiry") and obj.get("lock_user") != self.user_data.get("user_id"): - lock_time = datetime.datetime.fromtimestamp(obj["lock_expiry"]) - if datetime.datetime.utcnow() < lock_time: - return self.render("wiki/page_in_use.html", page=page, can_edit=True) - - lock_expiry = datetime.datetime.utcnow() + datetime.timedelta(minutes=5) - - # There are a couple of cases where we will not need to lock a page. One of these is if the application is - # current set to debug mode. The other of these cases is if the page is empty, because if the page is empty - # we will only have a partially filled out page if the user quits before saving. - if obj: - if not DEBUG_MODE and obj.get("rst"): - self.db.insert( - self.table_name, - { - "slug": page, - "lock_expiry": lock_expiry.timestamp(), - "lock_user": self.user_data.get("user_id") - }, - conflict="update" - ) - - return self.render("wiki/page_edit.html", page=page, rst=rst, title=title, preview=preview, can_edit=True) - - @require_roles(*EDITOR_ROLES) - @csrf - def post(self, page): - rst = request.form.get("rst") - title = request.form["title"] - - if not rst or not rst.strip(): - raise BadRequest() - - if not title or not title.strip(): - raise BadRequest() - - rendered = render(rst) - - obj = { - "slug": page, - "title": request.form["title"], - "rst": rst, - "html": rendered["html"], - "text": html.unescape(STRIP_REGEX.sub("", rendered["html"]).strip()), - "headers": rendered["headers"] - } - - self.db.insert( - self.table_name, - obj, - conflict="replace" - ) - - if not DEBUG_MODE: - # Add the post to the revisions table - revision_payload = { - "slug": page, - "post": obj, - "date": datetime.datetime.utcnow().timestamp(), - "user": self.user_data.get("user_id") - } - - del revision_payload["post"]["slug"] - - current_revisions = self.db.filter(self.revision_table_name, lambda rev: rev["slug"] == page) - sorted_revisions = sorted(current_revisions, key=lambda rev: rev["date"], reverse=True) - - if len(sorted_revisions) > 0: - old_rev = sorted_revisions[0] - else: - old_rev = None - - new_rev = self.db.insert(self.revision_table_name, revision_payload)["generated_keys"][0] - - self.audit_log(page, new_rev, old_rev, obj) - - return redirect(url_for("wiki.page", page=page), code=303) # Redirect, ensuring a GET - - @require_roles(*EDITOR_ROLES) - @csrf - def patch(self, page): - current = self.db.get(self.table_name, page) - if not current: - return "", 404 - - if current.get("lock_expiry"): # If there is a lock present - - # If user patching is not the user with the lock end here - if current["lock_user"] != self.user_data.get("user_id"): - return "", 400 - new_lock = datetime.datetime.utcnow() + datetime.timedelta(minutes=5) # New lock time, 5 minutes in future - self.db.insert(self.table_name, { - "slug": page, - "lock_expiry": new_lock.timestamp() - }, conflict="update") # Update with new lock time - return "", 204 - - def audit_log(self, page, new_id, old_data, new_data): - if not old_data: - link = f"https://wiki.pythondiscord.com/source/{page}" - else: - link = f"https://wiki.pythondiscord.com/history/compare/{old_data['id']}/{new_id}" - - self.rmq_bot_event( - BotEventTypes.send_embed, - { - "target": CHANNEL_MOD_LOG, - "title": "Page Edit", - "description": f"**{new_data['title']}** edited by **{self.user_data.get('username')}**. " - f"[View the diff here]({link})", - "colour": 0x3F8DD7, # Light blue - "timestamp": datetime.datetime.now().isoformat() - } - ) diff --git a/pysite/views/wiki/history/compare.py b/pysite/views/wiki/history/compare.py deleted file mode 100644 index 6411ab30..00000000 --- a/pysite/views/wiki/history/compare.py +++ /dev/null @@ -1,70 +0,0 @@ -import difflib - -from pygments import highlight -from pygments.formatters import HtmlFormatter -from pygments.lexers import DiffLexer -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import DEBUG_MODE, EDITOR_ROLES -from pysite.mixins import DBMixin - - -class CompareView(RouteView, DBMixin): - path = "/history/compare/<string:first_rev>/<string:second_rev>" - name = "history.compare" - - table_name = "wiki_revisions" - table_primary_key = "id" - - def get(self, first_rev, second_rev): - before = self.db.get(self.table_name, first_rev) - after = self.db.get(self.table_name, second_rev) - - if not (before and after): - raise NotFound() - - if before["date"] > after["date"]: # Check whether the before was created after the after - raise BadRequest() - - if before["id"] == after["id"]: # The same revision has been requested - raise BadRequest() - - before_text = before["post"]["rst"] - after_text = after["post"]["rst"] - - if not before_text.endswith("\n"): - before_text += "\n" - - if not after_text.endswith("\n"): - after_text += "\n" - - before_text = before_text.splitlines(keepends=True) - after_text = after_text.splitlines(keepends=True) - - if not before["slug"] == after["slug"]: - raise BadRequest() # The revisions are not from the same post - - diff = difflib.unified_diff(before_text, after_text, fromfile=f"{first_rev}.rst", tofile=f"{second_rev}.rst") - diff = "".join(diff) - diff = highlight(diff, DiffLexer(), HtmlFormatter()) - return self.render("wiki/compare_revision.html", - title=after["post"]["title"], - page=before["slug"], - diff=diff, - slug=before["slug"], - can_edit=self.is_staff()) - - def is_staff(self): - if DEBUG_MODE: - return True - if not self.logged_in: - return False - - roles = self.user_data.get("roles", []) - - for role in roles: - if role in EDITOR_ROLES: - return True - - return False diff --git a/pysite/views/wiki/history/show.py b/pysite/views/wiki/history/show.py deleted file mode 100644 index 00a1dc27..00000000 --- a/pysite/views/wiki/history/show.py +++ /dev/null @@ -1,41 +0,0 @@ -import datetime - -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import DEBUG_MODE, EDITOR_ROLES -from pysite.mixins import DBMixin - - -class RevisionsListView(RouteView, DBMixin): - path = "/history/show/<path:page>" - name = "history.show" - - table_name = "wiki_revisions" - table_primary_key = "id" - - def get(self, page): - results = self.db.filter(self.table_name, lambda revision: revision["slug"] == page) - if len(results) == 0: - raise NotFound() - - for result in results: - ts = datetime.datetime.fromtimestamp(result["date"]) - result["pretty_time"] = ts.strftime("%d %b %Y") - - results = sorted(results, key=lambda revision: revision["date"], reverse=True) - return self.render("wiki/revision_list.html", page=page, revisions=results, can_edit=self.is_staff()), 200 - - def is_staff(self): - if DEBUG_MODE: - return True - if not self.logged_in: - return False - - roles = self.user_data.get("roles", []) - - for role in roles: - if role in EDITOR_ROLES: - return True - - return False diff --git a/pysite/views/wiki/index.py b/pysite/views/wiki/index.py deleted file mode 100644 index 53a4d269..00000000 --- a/pysite/views/wiki/index.py +++ /dev/null @@ -1,8 +0,0 @@ -from pysite.base_route import RedirectView - - -class WikiView(RedirectView): - path = "/" - name = "index" - page = "wiki.page" - kwargs = {"page": "home"} diff --git a/pysite/views/wiki/move.py b/pysite/views/wiki/move.py deleted file mode 100644 index 095a1fdb..00000000 --- a/pysite/views/wiki/move.py +++ /dev/null @@ -1,84 +0,0 @@ -import datetime - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest, NotFound - -from pysite.base_route import RouteView -from pysite.constants import BotEventTypes, CHANNEL_MOD_LOG, EDITOR_ROLES -from pysite.decorators import csrf, require_roles -from pysite.mixins import DBMixin, RMQMixin - - -class MoveView(RouteView, DBMixin, RMQMixin): - path = "/move/<path:page>" # "path" means that it accepts slashes - name = "move" - table_name = "wiki" - revision_table_name = "wiki_revisions" - - @require_roles(*EDITOR_ROLES) - def get(self, page): - obj = self.db.get(self.table_name, page) - - if obj: - title = obj.get("title", "") - - if obj.get("lock_expiry") and obj.get("lock_user") != self.user_data.get("user_id"): - lock_time = datetime.datetime.fromtimestamp(obj["lock_expiry"]) - if datetime.datetime.utcnow() < lock_time: - return self.render("wiki/page_in_use.html", page=page, can_edit=True) - - return self.render("wiki/page_move.html", page=page, title=title, can_edit=True) - else: - raise NotFound() - - @require_roles(*EDITOR_ROLES) - @csrf - def post(self, page): - location = request.form.get("location") - - if not location or not location.strip(): - raise BadRequest() - - obj = self.db.get(self.table_name, page) - - if not obj: - raise NotFound() - - title = obj.get("title", "") - other_obj = self.db.get(self.table_name, location) - - if other_obj: - return self.render( - "wiki/page_move.html", page=page, title=title, - message=f"There's already a page at {location} - please pick a different location" - ) - - self.db.delete(self.table_name, page) - - # Move all revisions for the old slug to the new slug. - revisions = self.db.filter(self.revision_table_name, lambda revision: revision["slug"] == obj["slug"]) - - for revision in revisions: - revision["slug"] = location - self.db.insert(self.revision_table_name, revision, conflict="update") - - obj["slug"] = location - - self.db.insert(self.table_name, obj, conflict="update") - - self.audit_log(obj) - - return redirect(url_for("wiki.page", page=location), code=303) # Redirect, ensuring a GET - - def audit_log(self, obj): - self.rmq_bot_event( - BotEventTypes.send_embed, - { - "target": CHANNEL_MOD_LOG, - "title": "Wiki Page Move", - "description": f"**{obj['title']}** was moved by **{self.user_data.get('username')}** to " - f"**{obj['slug']}**", - "colour": 0x3F8DD7, # Light blue - "timestamp": datetime.datetime.now().isoformat() - } - ) diff --git a/pysite/views/wiki/page.py b/pysite/views/wiki/page.py deleted file mode 100644 index 26edfcc4..00000000 --- a/pysite/views/wiki/page.py +++ /dev/null @@ -1,36 +0,0 @@ -from flask import redirect, url_for -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import DEBUG_MODE, EDITOR_ROLES -from pysite.mixins import DBMixin - - -class PageView(RouteView, DBMixin): - path = "/wiki/<path:page>" # "path" means that it accepts slashes - name = "page" - table_name = "wiki" - - def get(self, page): - obj = self.db.get(self.table_name, page) - - if obj is None: - if self.is_staff(): - return redirect(url_for("wiki.edit", page=page)) - - raise NotFound() - return self.render("wiki/page_view.html", page=page, data=obj, can_edit=self.is_staff()) - - def is_staff(self): - if DEBUG_MODE: - return True - if not self.logged_in: - return False - - roles = self.user_data.get("roles", []) - - for role in roles: - if role in EDITOR_ROLES: - return True - - return False diff --git a/pysite/views/wiki/render.py b/pysite/views/wiki/render.py deleted file mode 100644 index 39bdd133..00000000 --- a/pysite/views/wiki/render.py +++ /dev/null @@ -1,62 +0,0 @@ -import re - -from docutils.utils import SystemMessage -from flask import jsonify -from schema import Schema - -from pysite.base_route import APIView -from pysite.constants import EDITOR_ROLES, ValidationTypes -from pysite.decorators import api_params, csrf, require_roles -from pysite.rst import render - -SCHEMA = Schema([{ - "data": str -}]) - -MESSAGE_REGEX = re.compile(r"<string>:(\d+): \([A-Z]+/\d\) (.*)", flags=re.S) - - -class RenderView(APIView): - path = "/render" # "path" means that it accepts slashes - name = "render" - - @csrf - @require_roles(*EDITOR_ROLES) - @api_params(schema=SCHEMA, validation_type=ValidationTypes.json) - def post(self, data): - if not len(data): - return jsonify({"error": "No data!"}) - - data = data[0]["data"] - try: - html = render(data)["html"] - - return jsonify({"data": html}) - except SystemMessage as e: - lines = str(e) - data = { - "error": lines, - "error_lines": [] - } - - if "\n" in lines: - lines = lines.split("\n") - else: - lines = [lines] - - for message in lines: - match = MESSAGE_REGEX.match(message) - - if match: - data["error_lines"].append( - { - "row": int(match.group(1)) - 3, - "column": 0, - "type": "error", - "text": match.group(2) - } - ) - - return jsonify(data) - except Exception as e: - return jsonify({"error": str(e)}) diff --git a/pysite/views/wiki/robots_txt.py b/pysite/views/wiki/robots_txt.py deleted file mode 100644 index 308fe2a2..00000000 --- a/pysite/views/wiki/robots_txt.py +++ /dev/null @@ -1,15 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView - - -class RobotsTXT(RouteView): - path = "/robots.txt" - name = "robots_txt" - - def get(self): - return Response( - self.render( - "robots.txt", sitemap_url=url_for("api.sitemap_xml", _external=True) - ), content_type="text/plain" - ) diff --git a/pysite/views/wiki/search.py b/pysite/views/wiki/search.py deleted file mode 100644 index 369da943..00000000 --- a/pysite/views/wiki/search.py +++ /dev/null @@ -1,66 +0,0 @@ -import html -import re - -from flask import redirect, request, url_for -from werkzeug.exceptions import BadRequest - -from pysite.base_route import RouteView -from pysite.decorators import csrf -from pysite.mixins import DBMixin - -STRIP_REGEX = re.compile(r"<[^<]+?>") - - -class SearchView(RouteView, DBMixin): - path = "/search" # "path" means that it accepts slashes - name = "search" - table_name = "wiki" - revision_table_name = "wiki_revisions" - - def get(self): - return self.render("wiki/search.html") - - @csrf - def post(self): - given_query = request.form.get("query") - - if not given_query or not given_query.strip(): - raise BadRequest() - - query = f"({re.escape(given_query)})" - - pages = self.db.filter( - self.table_name, - lambda doc: doc["text"].match(f"(?i){query}") - ) - - if len(pages) == 1: - slug = pages[0]["slug"] - return redirect(url_for("wiki.page", page=slug), code=303) - - for obj in pages: - text = obj["text"] - - matches = re.finditer(query, text, flags=re.IGNORECASE) - snippets = [] - - for match in matches: - start = match.start() - 50 - - if start < 0: - start = 0 - - end = match.end() + 50 - - if end > len(text): - end = len(text) - - match_text = text[start:end] - match_text = re.sub(query, r"<strong>\1</strong>", html.escape(match_text), flags=re.IGNORECASE) - - snippets.append(match_text.replace("\n", "<br />")) - - obj["matches"] = snippets - - pages = sorted(pages, key=lambda d: d["title"]) - return self.render("wiki/search_results.html", pages=pages, query=given_query) diff --git a/pysite/views/wiki/sitemap_xml.py b/pysite/views/wiki/sitemap_xml.py deleted file mode 100644 index 9b7f0980..00000000 --- a/pysite/views/wiki/sitemap_xml.py +++ /dev/null @@ -1,22 +0,0 @@ -from flask import Response, url_for - -from pysite.base_route import RouteView -from pysite.mixins import DBMixin - - -class SitemapXML(RouteView, DBMixin): - path = "/sitemap.xml" - name = "sitemap_xml" - table_name = "wiki" - - def get(self): - urls = [] - - for page in self.db.get_all(self.table_name): - urls.append({ - "change_frequency": "weekly", - "type": "url", - "url": url_for("wiki.page", page=page["slug"], _external=True) - }) - - return Response(self.render("sitemap.xml", urls=urls), content_type="application/xml") diff --git a/pysite/views/wiki/source.py b/pysite/views/wiki/source.py deleted file mode 100644 index 83674447..00000000 --- a/pysite/views/wiki/source.py +++ /dev/null @@ -1,42 +0,0 @@ -from flask import redirect, url_for -from pygments import highlight -from pygments.formatters.html import HtmlFormatter -from pygments.lexers import get_lexer_by_name -from werkzeug.exceptions import NotFound - -from pysite.base_route import RouteView -from pysite.constants import DEBUG_MODE, EDITOR_ROLES -from pysite.mixins import DBMixin - - -class PageView(RouteView, DBMixin): - path = "/source/<path:page>" # "path" means that it accepts slashes - name = "source" - table_name = "wiki" - - def get(self, page): - obj = self.db.get(self.table_name, page) - - if obj is None: - if self.is_staff(): - return redirect(url_for("wiki.edit", page=page, can_edit=False)) - - raise NotFound() - - rst = obj["rst"] - rst = highlight(rst, get_lexer_by_name("rst"), HtmlFormatter(preclass="code", linenos="inline")) - return self.render("wiki/page_source.html", page=page, data=obj, rst=rst, can_edit=self.is_staff()) - - def is_staff(self): - if DEBUG_MODE: - return True - if not self.logged_in: - return False - - roles = self.user_data.get("roles", []) - - for role in roles: - if role in EDITOR_ROLES: - return True - - return False diff --git a/pysite/views/wiki/special/__init__.py b/pysite/views/wiki/special/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/wiki/special/__init__.py +++ /dev/null diff --git a/pysite/views/wiki/special/all_pages.py b/pysite/views/wiki/special/all_pages.py deleted file mode 100644 index d2e02a72..00000000 --- a/pysite/views/wiki/special/all_pages.py +++ /dev/null @@ -1,27 +0,0 @@ -from pysite.base_route import RouteView -from pysite.mixins import DBMixin - - -class PageView(RouteView, DBMixin): - path = "/special/all_pages" - name = "special.all_pages" - table_name = "wiki" - - def get(self): - pages = self.db.pluck(self.table_name, "title", "slug") - pages = sorted(pages, key=lambda d: d.get("title", "No Title")) - - letters = {} - - for page in pages: - if "title" not in page: - page["title"] = "No Title" - - letter = page["title"][0].upper() - - if letter not in letters: - letters[letter] = [] - - letters[letter].append(page) - - return self.render("wiki/special_all.html", letters=letters) diff --git a/pysite/views/wiki/special/index.py b/pysite/views/wiki/special/index.py deleted file mode 100644 index ccfc7a5a..00000000 --- a/pysite/views/wiki/special/index.py +++ /dev/null @@ -1,7 +0,0 @@ -from pysite.base_route import TemplateView - - -class PageView(TemplateView): - path = "/special" - name = "special" - template = "wiki/special.html" diff --git a/pysite/views/ws/__init__.py b/pysite/views/ws/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/pysite/views/ws/__init__.py +++ /dev/null diff --git a/pysite/views/ws/bot.py b/pysite/views/ws/bot.py deleted file mode 100644 index 816e7579..00000000 --- a/pysite/views/ws/bot.py +++ /dev/null @@ -1,56 +0,0 @@ -import json -import logging - -from geventwebsocket.websocket import WebSocket - -from pysite.constants import BOT_API_KEY -from pysite.mixins import DBMixin -from pysite.websockets import WS - - -class BotWebsocket(WS, DBMixin): - path = "/bot" - name = "ws.bot" - table_name = "bot_events" - - do_changefeed = True - - def __init__(self, socket: WebSocket): - super().__init__(socket) - self.log = logging.getLogger() - - def on_open(self): - self.log.debug("Bot | WS opened.") - - def on_message(self, message): - self.log.debug(f"Bot | Message: {message}") - - try: - message = json.loads(message) - except json.JSONDecodeError: - self.send_json({"error": "Message was not valid JSON"}) - return self.socket.close() - - action = message["action"] - - if action == "login": - if message["key"] != BOT_API_KEY: - return self.socket.close() - - self.do_changefeed = True - - for document in self.db.changes(self.table_name, include_initial=True, include_types=True): - if not self.do_changefeed: - break - - if document["type"] not in ["add", "initial"]: - continue - - self.send_json({"action": "event", "event": document["new_val"]}) - self.db.delete(self.table_name, document["id"]) - - self.send_json({"error": f"Unknown action: {action}"}) - - def on_close(self): - self.log.debug("Bot | WS closed.") - self.do_changefeed = False diff --git a/pysite/views/ws/echo.py b/pysite/views/ws/echo.py deleted file mode 100644 index b6f11168..00000000 --- a/pysite/views/ws/echo.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging - -from geventwebsocket.websocket import WebSocket - -from pysite.websockets import WS - - -class EchoWebsocket(WS): - path = "/echo" - name = "ws.echo" - - def __init__(self, socket: WebSocket): - super().__init__(socket) - self.log = logging.getLogger() - - def on_open(self): - self.log.debug("Echo | WS opened.") - self.send("Hey, welcome!") - - def on_message(self, message): - self.log.debug(f"Echo | Message: {message}") - self.send(message) - - def on_close(self): - self.log.debug("Echo | WS closed.") diff --git a/pysite/views/ws/rst.py b/pysite/views/ws/rst.py deleted file mode 100644 index f2b2db24..00000000 --- a/pysite/views/ws/rst.py +++ /dev/null @@ -1,33 +0,0 @@ -import logging - -from geventwebsocket.websocket import WebSocket - -from pysite.rst import render -from pysite.websockets import WS - - -class RSTWebsocket(WS): - path = "/rst" - name = "ws.rst" - - def __init__(self, socket: WebSocket): - super().__init__(socket) - self.log = logging.getLogger() - - def on_open(self): - self.log.debug("RST | WS opened.") - self.send("Hey, welcome!") - - def on_message(self, message): - self.log.debug(f"RST | Message: {message}") - - try: - data = render(message)["html"] - except Exception as e: - self.log.exception("Parsing error") - data = str(e) - - self.send(data) - - def on_close(self): - self.log.debug("RST | WS closed.") |