def _get_object(self, tournament_id, bracket_id, spreadsheet_id):
bracket = (db.query(Bracket).where(
Bracket.tournament_id == tournament_id).where(
Bracket.id == bracket_id).first())
if not bracket or bracket.qualifiers_spreadsheet_id != spreadsheet_id:
raise exceptions.NotFound()
spreadsheet = db.query(QualifiersSpreadsheet).where(
QualifiersSpreadsheet.id == spreadsheet_id).first()
if not spreadsheet:
raise exceptions.NotFound()
return spreadsheet
def get_all(self, tournament_id, include_spreadsheets, request_args):
brackets = db.query(Bracket).where(
Bracket.tournament_id == tournament_id).where(
**request_args).all()
brackets_data = []
for tournament in brackets:
brackets_data.append(
get_bracket_data(tournament, include_spreadsheets))
return {
"brackets": [
bracket.get_api_dict() for bracket in db.query(Bracket).where(
**request.args.to_dict()).all()
]
}
def wrapper_is_authorized(*args, **kwargs):
if request.remote_addr == "127.0.0.1":
if local:
return func(*args, **kwargs)
else:
raise exceptions.Forbidden()
session_token = request.headers.get("Authorization")
if not session_token:
raise exceptions.Unauthorized()
token = db.query(Token).where(
Token.session_token == session_token).first()
if not token:
raise exceptions.Unauthorized()
if int(token.expiry_date) < int(time.time()):
db.delete(token)
current_app.logger.debug(
"Token of the user {0} has expired".format(
token.discord_user_id))
raise exceptions.Unauthorized()
refresh_token_if_needed(token)
g.token = token
if user and token.token_type == "user":
return exec_func_if_user_can_access_resource(
func, *args, **kwargs)
if client and token.token_type == "client":
return func(*args, **kwargs)
raise exceptions.Forbidden()
def get_brackets_data_of_tournament(tournament, include_spreadsheets=False):
brackets_data = []
brackets = db.query(Bracket).where(
Bracket.tournament_id == tournament.id).all()
for bracket in brackets:
brackets_data.append(get_bracket_data(bracket, include_spreadsheets))
return brackets_data
def _get_object(self, tournament_id, bracket_id):
bracket = (db.query(Bracket).where(
Bracket.tournament_id == tournament_id).where(
Bracket.id == bracket_id).first())
if not bracket:
raise exceptions.NotFound()
return bracket
def delete(self, tournament_id, bracket_id):
brackets = db.query(Bracket).where(
Bracket.tournament_id == tournament_id).all()
if len(brackets) <= 1:
raise exceptions.CannotRemoveLastBracket()
bracket = self._get_object(tournament_id, bracket_id)
delete_bracket_and_associated_spreadsheets(bracket)
return {}, 204
def get_all(self, include_brackets, include_spreadsheets, request_args):
tournaments = db.query(Tournament).where(**request_args).all()
tournaments_data = []
for tournament in tournaments:
tournaments_data.append(
get_tournament_data(tournament, include_brackets,
include_spreadsheets))
return {"tournaments": tournaments_data}
def delete(self, tournament_id):
tournament = self._get_object(tournament_id)
brackets = db.query(Bracket).where(
Bracket.tournament_id == tournament_id).all()
for bracket in brackets:
delete_bracket_and_associated_spreadsheets(bracket)
allowed_reschedules = db.query(AllowedReschedule).where(
AllowedReschedule.tournament_id == tournament_id).all()
for allowed_reschedule in allowed_reschedules:
current_app.logger.debug(
"The allowed reschedule {0} for the match id {1} has been deleted successfully."
.format(allowed_reschedule.id, allowed_reschedule.match_id))
db.delete(allowed_reschedule)
db.delete(tournament)
current_app.logger.debug(
"The tournament {0} has been deleted successfully.".format(
tournament_id))
return {}, 204
def exec_func_if_user_can_access_resource(func, *args, **kwargs):
if "guild_id" in kwargs and kwargs["guild_id"]:
guild = db.query(Guild).where(
Guild.id == kwargs["guild_id"]).first()
if not guild:
raise exceptions.NotFound()
assert_user_can_access_resource(guild.guild_id_snowflake,
guild.admin_role_id)
elif "tournament_id" in kwargs and kwargs["tournament_id"]:
tournament = db.query(Tournament).where(
Tournament.id == kwargs["tournament_id"]).first()
if not tournament:
raise exceptions.NotFound()
admin_role_id = None
guild = db.query(Guild).where(
Guild.id == tournament.guild_id_snowflake).first()
if guild:
admin_role_id = guild.admin_role_id
assert_user_can_access_resource(tournament.guild_id_snowflake,
admin_role_id)
else:
request_args = request.args.to_dict()
if "guild_id" not in request_args or not request_args[
"guild_id"]:
body = request.json
if func.__name__ == "post" and body and "guild_id" in body and body[
"guild_id"]:
assert_user_can_access_resource(body["guild_id"])
return func(*args, **kwargs)
raise exceptions.Forbidden()
guild = db.query(Guild).where(
Guild.guild_id == request_args["guild_id"]).first()
if not guild:
tournament = db.query(Tournament).where(
Tournament.guild_id ==
request_args["guild_id"]).first()
if not tournament:
raise exceptions.NotFound()
assert_user_can_access_resource(
tournament.guild_id_snowflake)
return func(*args, **kwargs)
assert_user_can_access_resource(guild.guild_id_snowflake,
guild.admin_role_id)
return func(*args, **kwargs)
def get_spreadsheets_data_of_bracket(bracket):
response_spreadsheets = {}
for spreadsheet_type, spreadsheet_class in Bracket.get_spreadsheet_types(
).items():
spreadsheet = (db.query(spreadsheet_class).where(
id=getattr(bracket, spreadsheet_type + "_spreadsheet_id")).first())
if spreadsheet:
response_spreadsheets[spreadsheet_type +
"_spreadsheet"] = spreadsheet.get_api_dict()
return response_spreadsheets
def get_all(self):
request_args = request.args.to_dict()
guild_id = request_args.pop("guild_id", None)
if guild_id:
request_args["guild_id"] = str(guild_id)
return {
"guilds": [
guild.get_api_dict()
for guild in db.query(Guild).where(**request_args).all()
]
}
def delete_all(self, tournament_id):
try:
allowed_reschedules = (db.query(AllowedReschedule).where(
AllowedReschedule.tournament_id == tournament_id).where(
**request.args.to_dict()).all())
except AttributeError:
raise exceptions.BadRequest()
for allowed_reschedule in allowed_reschedules:
db.delete(allowed_reschedule)
current_app.logger.debug(
"The allowed reschedule {0} for match id {1} has been deleted successfully."
.format(allowed_reschedule.id, allowed_reschedule.match_id))
return {}, 204
def _get_object(self, tournament_id, allowed_reschedule_id):
allowed_reschedule = (db.query(AllowedReschedule).where(
AllowedReschedule.tournament_id == tournament_id).where(
AllowedReschedule.id == allowed_reschedule_id).first())
if not allowed_reschedule:
raise exceptions.NotFound()
now = datetime.datetime.utcnow()
max_allowed_date = datetime.datetime.fromtimestamp(
allowed_reschedule.created_at) + datetime.timedelta(
hours=allowed_reschedule.allowed_hours)
if now >= max_allowed_date:
db.delete(allowed_reschedule)
raise exceptions.NotFound()
return allowed_reschedule
def get_all(self):
request_args = request.args.to_dict()
discord_id = request_args.pop("discord_id", None)
if discord_id:
request_args["discord_id"] = str(discord_id)
if "osu_name_hash" in request_args:
request_args["osu_name_hash"] = request_args[
"osu_name_hash"].casefold()
return {
"users": [
user.get_api_dict()
for user in db.query(User).where(**request_args).all()
]
}
def delete_bracket_and_associated_spreadsheets(bracket):
for spreadsheet_type, spreadsheet_class in Bracket.get_spreadsheet_types(
).items():
spreadsheet_id = getattr(bracket, spreadsheet_type + "_spreadsheet_id")
if spreadsheet_id > 0:
spreadsheet = db.query(spreadsheet_class).where(
id=spreadsheet_id).first()
if spreadsheet:
db.delete(spreadsheet)
current_app.logger.debug(
"The {0} spreadsheet {1} has been deleted successfully.".
format(spreadsheet_type.replace("_", " "), spreadsheet_id))
db.delete(bracket)
current_app.logger.debug(
"The bracket {0} has been deleted successfully.".format(bracket.id))
def post(self, tournament_id, bracket_id):
bracket = (db.query(Bracket).where(
Bracket.tournament_id == tournament_id).where(
Bracket.id == bracket_id).first())
if not bracket:
raise exceptions.NotFound()
body = request.json
if not body or not body["spreadsheet_id"]:
raise exceptions.MissingRequiredInformation()
body["spreadsheet_id"] = spreadsheet_api.extract_spreadsheet_id(
body["spreadsheet_id"])
spreadsheet = QualifiersSpreadsheet(**body)
db.add(spreadsheet)
bracket.qualifiers_spreadsheet_id = spreadsheet.id
db.update(bracket)
current_app.logger.debug(
"The qualifiers spreadsheet {0} for the bracket {1} has been created successfully."
.format(spreadsheet.id, bracket_id))
return spreadsheet.get_api_dict(), 201
def get_all(self, tournament_id):
allowed_reschedules = (db.query(AllowedReschedule).where(
AllowedReschedule.tournament_id == tournament_id).where(
**request.args.to_dict()).all())
real_allowed_reschedules = []
now = datetime.datetime.utcnow()
for allowed_reschedule in allowed_reschedules:
max_allowed_date = datetime.datetime.fromtimestamp(
allowed_reschedule.created_at) + datetime.timedelta(
hours=allowed_reschedule.allowed_hours)
if now >= max_allowed_date:
db.delete(allowed_reschedule)
else:
real_allowed_reschedules.append(allowed_reschedule)
return {
"allowed_reschedules": [
allowed_reschedule.get_api_dict()
for allowed_reschedule in real_allowed_reschedules
]
}
def post(self):
body = request.json
if "tosurnament_code" not in body or "osu_code" not in body:
raise exceptions.BadRequest()
user = db.query(User).where(
User.code == body["tosurnament_code"]).first()
if not user:
raise exceptions.InternalServerError()
if user.verified:
raise exceptions.UserAlreadyVerified()
parameters = {
"client_id": constants.OSU_CLIENT_ID,
"client_secret": constants.OSU_CLIENT_SECRET,
"code": body["osu_code"],
"grant_type": "authorization_code",
"redirect_uri": constants.OSU_REDIRECT_URI,
}
token_request = requests.post(endpoints.OSU_TOKEN, data=parameters)
if not token_request.ok:
raise exceptions.OsuTokenError()
token_results = token_request.json()
me_headers = {
"Authorization": "Bearer " + token_results["access_token"]
}
me_request = requests.get(endpoints.OSU_ME, headers=me_headers)
if not me_request.ok:
raise exceptions.OsuMeError()
me_results = me_request.json()
user.osu_id = str(me_results["id"])
user.osu_name = me_results["username"]
user.osu_name_hash = me_results["username"].casefold()
if me_results["previous_usernames"]:
user.osu_previous_name = me_results["previous_usernames"][-1]
user.verified = True
db.update(user)
current_app.logger.debug(
"The user with the osu id {0} has been authentificated successfully."
.format(user.osu_id))
return {}, 204
def store_token(data):
token = None
session_token = request.headers.get("Authorization")
if session_token:
token = db.query(Token).where(
Token.session_token == session_token).first()
if not token:
token = Token()
token.discord_user_id = get_user_id(data["access_token"])
session_token = str(uuid.uuid4())
token.session_token = session_token
token.expiry_date = str(int(time.time()) + 2592000)
db.add(token)
token.access_token = data["access_token"]
token.token_type = "user"
token.access_token_expiry_date = str(int(time.time()) + data["expires_in"])
token.refresh_token = data["refresh_token"]
token.scope = data["scope"]
db.update(token)
current_app.logger.debug(
"A token has successfully been created/updated for the user {0}".
format(token.discord_user_id))
return session_token
def _get_object(self, tournament_id):
tournament = db.query(Tournament).where(
Tournament.id == tournament_id).first()
if not tournament:
raise exceptions.NotFound()
return tournament
def _get_object(self, user_id):
user = db.query(User).where(User.id == user_id).first()
if not user:
raise exceptions.NotFound()
return user
def _get_object(self, guild_id):
guild = db.query(Guild).where(Guild.id == guild_id).first()
if not guild:
raise exceptions.NotFound()
return guild
