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