def rename_group():
payload = request.get_json(force=True)
if payload is None:
raise CalculatedError(403, "Malformed request")
if 'id' in payload:
entry = SavedGroup.rename_entry(payload['id'], payload['name'])
else:
raise CalculatedError(403, "Malformed request")
return jsonify({"uuid": entry})
def delete_group():
payload = request.get_json(force=True)
if payload is None:
raise CalculatedError(403, "Malformed request")
if 'id' in payload:
entry = SavedGroup.delete_entry(payload['id'])
elif 'ids' in payload:
entry = [SavedGroup.delete_entry(id_) for id_ in payload['ids']]
else:
raise CalculatedError(403, "Malformed request")
return jsonify({"uuid": entry})
def api_find_trainingpack(query_params=None, session=None):
player = get_current_user_id()
if 'player_id' in query_params:
player = query_params['player_id']
elif player is None:
raise CalculatedError(400, "Anonymous requests require 'player_id' parameter.")
return better_jsonify(TrainingPackCreation.list_packs(player, query_params['page'], query_params['limit'], session))
def get_global_stats_by_rank(self, session, query_filter: QueryFilterBuilder, stats_query, stds_query,
player_rank=None, redis=None, ids=None, playlist=13):
"""
Returns the global stats based on the rank of a player.
Does modify the query_filter only setting rank.
:param session: Session
:param query_filter: a query filter.
:param stats_query: A list of global stats
:param stds_query: A list of global stats for standard deviations
:param player_rank: The player that stats are associated with. Uses unranked if rank is not found
:param redis: The local cache
:return:
"""
if ids is None:
# Set the correct rank index
if player_rank is not None:
if isinstance(player_rank, dict) or isinstance(player_rank, list):
rank_index = get_rank_tier(player_rank, playlist=playlist)
else:
rank_index = player_rank
else:
rank_index = 0
stat_list = self.get_player_stat_list()
# Check to see if we have redis available (it usually is)
if redis is not None:
stat_string = redis.get('global_stats_by_rank')
# Check to see if the key exists and if so load it
if stat_string is not None:
stats_dict = json.loads(stat_string)
if playlist is not None:
playlist = str(playlist)
if playlist not in stats_dict:
raise UnsupportedPlaylist(404, 'Playlist does not exist in global stats')
stats_dict = stats_dict[playlist]
global_stats = []
global_stds = []
for stat in stat_list:
if stat.get_field_name() in stats_dict:
global_stats.append(stats_dict[stat.get_field_name()][rank_index]['mean'])
global_stds.append(stats_dict[stat.get_field_name()][rank_index]['std'])
else:
global_stats.append(1)
global_stds.append(1)
return global_stats, global_stds
if is_local_dev():
rank_index = 0
stats = self.get_global_stats(session, with_rank=False)
global_stats = [stats[stat.get_field_name()][rank_index]['mean'] for stat in stat_list]
global_stds = [stats[stat.get_field_name()][rank_index]['std'] for stat in stat_list]
return global_stats, global_stds
raise CalculatedError(500, "Global stats unavailable or have not been calculated yet.")
else:
query_filter.clean().with_replay_ids(ids)
return (query_filter.with_stat_query(stats_query).build_query(session).first(),
query_filter.with_stat_query(stds_query).build_query(session).first())
def cache_items(self):
r = lazy_get_redis()
if r is None:
raise CalculatedError()
items, category_map = self.get_items()
for item in items:
r.set(f"rlgarage_{item}", json.dumps(items[item]))
r.set("rlgarage_category_map", json.dumps(category_map))
r.set("rlgarage_items", json.dumps(items))
def remove_group_from_user(id_: str, group: int, session=None):
if not is_admin(
): # putting this here so that it *can't* be run without being admin from anywhere
raise AuthorizationException()
player = session.query(Player).filter(
Player.platformid == id_).one_or_none()
if player is None:
raise PlayerNotFound()
if player.groups is None:
raise CalculatedError(400, "Player groups is None")
if group not in player.groups:
raise CalculatedError(400, "Group is not assigned to user")
player.groups.remove(group)
# SQLAlchemy needs this flag to be set to actually update the DB for whatever reason
flag_modified(player, "groups")
session.add(player)
session.commit()
return jsonify({"status": "Success", "groups": player.groups})
def import_pack(guid, session):
pack_query = session.query(TrainingPack).filter(TrainingPack.guid == guid)
if pack_query.count() == 0:
pack_query = session.query(TrainingPack).filter(TrainingPack.task_id == guid)
if pack_query.count() == 0:
raise CalculatedError(400, "Invalid pack GUID.")
pack: TrainingPack = duplicate_object(pack_query.first(), ['id'])
user_id = get_current_user_id()
pack.player = user_id
session.add(pack)
session.commit()
return True
def get_stats(uuid, team=False, session=None):
path = session.query(GroupEntry).filter(
GroupEntry.uuid == uuid).first().path
games = session.query(GroupEntry).filter(
GroupEntry.path.descendant_of(path)).filter(
GroupEntry.type == GroupEntryType.game).all()
if len(games) > 150:
return CalculatedError(400, 'Too many replays in group!')
games = [game.game for game in games]
if team:
stats = wrapper.get_group_team_stats(games)
else:
stats = wrapper.get_group_stats(games)
return stats
def api_create_custom_trainingpack():
_json = request.get_json(silent=True)
if _json is None:
raise CalculatedError(400, 'No JSON supplied.')
requester_id = get_current_user_id()
players = _json['players']
replays = _json['replays']
frames = [int(frame) for frame in _json['frames']]
mode = False
name = None
if 'name' in _json:
name = _json['name']
if 'mode' in _json:
mode = _json['mode'].lower() == 'goalie'
task = create_manual_training_pack.delay(requester_id, players, replays, frames, name, mode)
return better_jsonify({'status': 'Success', 'id': task.id})
def create_from_id(cls,
id_: str,
raw=False,
rank=None,
replay_ids=None,
playlist=13,
win=None,
session=None):
game_count = player_wrapper.get_total_games(session, id_)
if game_count == 0:
raise UserHasNoReplays()
if rank is None:
rank = get_rank(id_)
try:
averaged_stats = player_stat_wrapper.get_averaged_stats(
session,
id_,
redis=current_app.config['r'],
raw=raw,
rank=rank,
replay_ids=replay_ids,
playlist=playlist,
win=win)
except NoResultFound:
raise CalculatedError(
404,
f"User has no replays for the selected playlist: {playlist}")
spider_charts_groups = player_stat_wrapper.get_stat_spider_charts()
play_style_chart_datas: List[PlayStyleChartData] = []
for spider_chart_group in spider_charts_groups:
title = spider_chart_group['title']
chart_data_points = [
ChartDataPoint(name=explanations[name].short_name
if name in explanations else name,
value=averaged_stats[name])
for name in spider_chart_group['group']
]
play_style_chart_datas.append(
PlayStyleChartData(title, chart_data_points))
return PlayStyleResponse(
chart_datas=play_style_chart_datas,
show_warning=game_count <= cls.showWarningThreshold)
def create_group():
payload = request.get_json(force=True)
if payload is None:
raise CalculatedError(403, "Malformed request")
name = payload['name'] if 'name' in payload else None
if 'parent' in payload:
parent = payload['parent']
if 'game' in payload:
entry = SavedGroup.add_game(parent, payload['game'], name)
elif 'games' in payload:
entry = [
SavedGroup.add_game(parent, game, name)
for game in payload['games']
]
else:
entry = SavedGroup.add_subgroup(parent, name)
else:
entry = SavedGroup.create(name)
return jsonify({"uuid": entry})
def get_stats(self,
session,
id_,
stats_query,
std_query,
rank=None,
redis=None,
raw=False,
replay_ids=None,
playlist=13,
win: bool = None):
player_stats_filter = self.player_stats_filter.clean().clone()
global_stats, global_stds = self.get_global_stats_by_rank(
session,
player_stats_filter,
stats_query,
std_query,
player_rank=rank,
redis=redis,
ids=replay_ids,
playlist=playlist)
player_stats_filter.clean().with_stat_query(stats_query).with_players(
[id_])
if replay_ids is not None:
player_stats_filter.with_replay_ids(replay_ids)
else:
player_stats_filter.with_playlists([playlist])
query = player_stats_filter.build_query(session).filter(
PlayerGame.time_in_game > 0).filter(
PlayerGame.game != '').group_by(PlayerGame.player)
if win is not None:
query = query.filter(PlayerGame.win == win)
if query.count() < 1:
raise CalculatedError(404, 'User does not have enough replays.')
stats = list(query.first())
stats = [0 if s is None else s for s in stats]
if raw:
return [self.float_maybe(s) for s in stats
], [self.float_maybe(s) for s in global_stats]
else:
return self.compare_to_global(stats, global_stats,
global_stds), len(stats) * [0.0]
def add_group_to_user(id_: str, group: int, session=None):
if not is_admin(
): # putting this here so that it *can't* be run without being admin from anywhere
raise AuthorizationException()
player = session.query(Player).filter(
Player.platformid == id_).one_or_none()
if player is None:
raise PlayerNotFound()
if player.groups is None:
player.groups = []
if group in player.groups:
raise CalculatedError(400, "Group is already assigned to user")
player.groups.append(group)
flag_modified(player, "groups")
session.add(player)
session.commit()
return jsonify({"status": "Success"})
def api_admin_remove_group(user_id: str, group: str):
try:
group: int = int(group)
except ValueError:
raise CalculatedError(400, "Invalid group number format")
return AdminPanelHandler.remove_group_from_user(user_id, group)
def api_handle_error(error: CalculatedError):
MetricsHandler.log_exception_for_metrics(error)
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
