def api_create_trainingpack(query_params=None):
date_start = None
date_end = None
try:
requester_id = get_current_user_id()
pack_player_id = get_current_user_id()
except:
requester_id = None
pack_player_id = None
name = None
replays = None
if 'name' in query_params:
name = query_params['name']
if 'player_id' in query_params:
pack_player_id = query_params['player_id']
if 'replays' in query_params:
replays = query_params['replays']
if 'date_start' in query_params:
date_start = query_params['date_start']
if 'date_end' in query_params:
date_end = query_params['date_end']
task = auto_create_training_pack.delay(requester_id, pack_player_id, name,
10, date_start, date_end, replays)
return better_jsonify({'status': 'Success', 'id': task.id})
def create(name: str,
session=None,
player_id=None,
private_key=None) -> 'Tag':
"""
Creates a new instance of Tag, add one to the db if it does not exist.
:param name: Tag name
:param session: Database session
:param player_id
:param private_key
:return:
"""
# Check if tag exists
try:
dbtag = TagWrapper.get_tag_by_name(
session, get_current_user_id(player_id=player_id), name)
tag = Tag.create_from_dbtag(dbtag)
return tag
except DBTagNotFound:
pass
dbtag = TagWrapper.create_tag(session,
get_current_user_id(player_id=player_id),
name,
private_key=private_key)
tag = Tag.create_from_dbtag(dbtag)
return tag
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 rename(current_name: str, new_name: str, session=None) -> 'Tag':
# Check if name already exists
try:
TagWrapper.get_tag_by_name(session, get_current_user_id(),
new_name)
raise TagError(409, f"Tag with name {new_name} already exists.")
except DBTagNotFound:
pass
try:
dbtag = TagWrapper.rename_tag(session, get_current_user_id(),
current_name, new_name)
except DBTagNotFound:
raise TagNotFound()
tag = Tag.create_from_dbtag(dbtag)
return tag
def create_from_game(game: Game, full=True, groups=False, session=None) -> 'Replay':
group_map = None
if groups and session is not None:
players = session.query(Player).filter(Player.platformid.in_(game.players)).all()
group_map = {player.platformid: player.groups for player in players}
return Replay(
id_=game.hash,
name=game.name,
date=game.match_date.isoformat(),
map=game.map,
game_mode=get_playlist(game.playlist, game.teamsize),
game_score=GameScore.create_from_game(game),
players=[
ReplayPlayer.create_from_player_game(player_game, full=full)
for player_game in sort_player_games_by_team_then_id(
cast(List[PlayerGame], game.playergames))
],
tags=[
JsonTag.create_from_dbtag(tag)
for tag in game.tags if tag.owner == get_current_user_id()
],
visibility=game.visibility,
ranks=game.ranks,
mmrs=game.mmrs,
group_map=group_map
)
def get_player_games(self,
session,
id_,
replay_ids=None,
filter_private=True):
query = session.query(PlayerGame).join(Game)
if replay_ids is not None:
query = query.filter(PlayerGame.game.in_(replay_ids))
if isinstance(id_, list):
query = query.filter(
Game.players.contains(cast(id_,
postgresql.ARRAY(String)))).filter(
PlayerGame.player == id_[0])
else:
query = query.filter(PlayerGame.player == id_).filter(
PlayerGame.game != None)
if filter_private:
if UserManager.get_current_user() is not None:
if not is_admin():
query = query.filter(
or_(Game.visibility != GameVisibilitySetting.PRIVATE,
Game.players.any(get_current_user_id())))
else:
query = query.filter(
Game.visibility != GameVisibilitySetting.PRIVATE)
return query
def add_private_key(name: str,
private_key: str,
session=None,
player_id=None):
try:
TagWrapper.add_private_key_to_tag(
session, get_current_user_id(player_id=player_id), name,
private_key)
except DBTagNotFound:
raise TagNotFound()
def api_create_trainingpack(query_params=None):
date_start = None
date_end = None
if 'date_start' in query_params:
date_start = query_params['date_start']
if 'date_end' in query_params:
date_end = query_params['date_end']
task = create_training_pack.delay(get_current_user_id(), 10, date_start,
date_end)
return better_jsonify({'status': 'Success', 'id': task.id})
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_games(self, session, id_, replay_ids=None, filter_private=True):
query = session.query(Game).filter(Game.players.contains(cast([id_], postgresql.ARRAY(String))))
if replay_ids is not None:
query = query.filter(Game.hash.in_(replay_ids))
if filter_private:
if UserManager.get_current_user() is not None:
if not is_admin():
query = query.filter(or_(Game.visibility != GameVisibilitySetting.PRIVATE,
Game.players.any(get_current_user_id())))
else:
query = query.filter(Game.visibility != GameVisibilitySetting.PRIVATE)
return query
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_game(game: Game) -> 'Replay':
return Replay(id_=game.hash,
name=game.name,
date=game.match_date.isoformat(),
map=game.map,
game_mode=get_playlist(game.playlist, game.teamsize),
game_score=GameScore.create_from_game(game),
players=[
ReplayPlayer.create_from_player_game(player_game)
for player_game in sort_player_games_by_team_then_id(
cast(List[PlayerGame], game.playergames))
],
tags=[
JsonTag.create_from_dbtag(tag) for tag in game.tags
if tag.owner == get_current_user_id()
],
visibility=game.visibility,
ranks=game.ranks,
mmrs=game.mmrs)
def api_update_replay_visibility(id_: str, visibility: str, query_params=None):
try:
visibility_setting = convert_to_enum(GameVisibilitySetting)(visibility)
except Exception as e:
try:
visibility_setting = GameVisibilitySetting(int(visibility))
except Exception as e:
logger.error(e)
return "Visibility setting not provided or incorrect", 400
try:
release_date = query_params['release_date']
except KeyError:
release_date = None
replay_visibiltiy = ReplayVisibility.change_replay_visibility(game_hash=id_,
visibility=visibility_setting,
user_id=get_current_user_id(),
release_date=release_date)
return better_jsonify(replay_visibiltiy)
def api_find_trainingpack(session=None):
player = get_current_user_id()
return better_jsonify(TrainingPackCreation.list_packs(player, session))
def get_tag(name: str, session=None) -> 'Tag':
dbtag = TagWrapper.get_tag_by_name(session, get_current_user_id(),
name)
return Tag.create_from_dbtag(dbtag)
def add_tag_to_game(name: str, replay_id: str, session=None) -> None:
try:
TagWrapper.add_tag_by_name_to_game(session, replay_id,
get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def remove_tag_from_game(name: str, replay_id: str, session=None) -> None:
try:
TagWrapper.remove_tag_from_game(session, replay_id,
get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def build_query(self, session):
"""
Builds a query given the current state, returns the result.
This method does not modify state of this object at all
:return: A filtered query.
"""
has_joined_game = False
if self.initial_query is None:
if self.is_game and self.stats_query is None:
filtered_query = session.query(Game)
else:
filtered_query = session.query(*self.stats_query)
else:
filtered_query = self.initial_query
if (self.start_time is not None or self.end_time is not None
or self.team_size is not None):
if not self.is_game:
filtered_query = filtered_query.join(Game)
has_joined_game = True
if self.is_game or has_joined_game:
# Do visibility check
if not is_admin():
filtered_query = filtered_query.filter(
or_(Game.visibility != GameVisibilitySetting.PRIVATE,
Game.players.any(get_current_user_id())))
if self.start_time is not None:
filtered_query = filtered_query.filter(
Game.match_date >= self.start_time)
if self.end_time is not None:
filtered_query = filtered_query.filter(
Game.match_date <= self.end_time)
if self.rank is not None:
filtered_query = filtered_query.filter(
PlayerGame.rank == self.rank)
if self.team_size is not None:
filtered_query = filtered_query.filter(
Game.teamsize == self.team_size)
if self.playlists is not None:
filtered_query = filtered_query.filter(
Game.playlist.in_(self.playlists))
if self.safe_checking:
filtered_query = filtered_query.filter(
PlayerGame.total_hits > 0).filter(PlayerGame.time_in_game > 0)
if self.players is not None and len(self.players) > 0:
filtered_query = filtered_query.filter(
self.handle_list(PlayerGame.player, self.players))
if self.contains_all_players is not None and len(
self.contains_all_players) > 0:
filtered_query = filtered_query.filter(
self.handle_union(Game.players, self.contains_all_players))
if self.replay_ids is not None and len(self.replay_ids) > 0:
if self.is_game or has_joined_game:
filtered_query = filtered_query.filter(
self.handle_list(Game.hash, self.replay_ids))
else:
filtered_query = filtered_query.filter(
self.handle_list(PlayerGame.game, self.replay_ids))
elif self.replay_ids is not None and len(self.replay_ids) == 1:
if self.is_game or has_joined_game:
filtered_query = filtered_query.filter(
Game.hash == self.replay_ids)
else:
filtered_query = filtered_query.filter(
PlayerGame.game == self.replay_ids)
# Todo: implement tags remember to handle table joins correctly
return filtered_query
def delete(name: str, session=None) -> None:
try:
TagWrapper.delete_tag(session, get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def get_all(session=None) -> List['Tag']:
dbtags = TagWrapper.get_tags(session, get_current_user_id())
tags = [Tag.create_from_dbtag(dbtag) for dbtag in dbtags]
return tags
