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 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 g.user is not None:
if not g.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 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 CalculatedError(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 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 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=[
Tag.create_from_dbtag(tag) for tag in game.tags
if tag.owner == get_current_user_id()
],
visibility=game.visibility)
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 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 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 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 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 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
