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