def view_player(id_):
print(id_, request.remote_addr)
if len(id_) != 17 or re.match(regex, id_) is None:
r = get_vanity_to_steam_id_or_random_response(id_, current_app)
if r is None:
return redirect(url_for('home'))
id_ = r['response']['steamid']
return redirect(url_for('players.view_player', id_=id_))
session = current_app.config['db']()
rank = get_rank(id_)
total_games = player_wrapper.get_total_games(session, id_)
games, stats, favorite_car, favorite_car_pctg, names = player_stat_wrapper.get_averaged_stats(session, id_, total_games, rank, redis=current_app.config['r'])
steam_profile = get_steam_profile_or_random_response(id_, current_app)
user = session.query(Player).filter(Player.platformid == id_).first()
if user is not None:
groups = [current_app.config['groups'][i] for i in user.groups]
else:
groups = []
if steam_profile is None:
return render_template('error.html', error="Unable to find the requested profile")
return render_with_session('player.html', session, games=games, rank=rank, profile=steam_profile, car=favorite_car,
favorite_car_pctg=favorite_car_pctg, stats=stats,
total_games=total_games, game_per_page=player_wrapper.limit,
id=id_, get_stat_spider_charts=PlayerStatWrapper.get_stat_spider_charts,
groups=groups, names=names)
def create_from_id(id_: str, session=None) -> 'Player':
# names_and_counts: List[Tuple[str, int]] = session.query(PlayerGame.name,
# func.count(PlayerGame.name).label('c')) \
# .filter(PlayerGame.player == id_) \
# .group_by(PlayerGame.name).order_by(desc('c'))[:5]
names_and_counts = [] # TODO: fix with Elasticsearch or something similar
query = session.query(DBPlayer.groups).filter(DBPlayer.platformid == id_)
if query.count() > 0:
groups = query.first()[0]
else:
groups = []
try:
steam_profile = get_steam_profile_or_random_response(id_)['response']['players'][0]
except TypeError:
names_and_counts: List[Tuple[str, int]] = session.query(PlayerGame.name,
func.count(PlayerGame.name).label('c')) \
.filter(PlayerGame.player == id_) \
.group_by(PlayerGame.name).order_by(desc('c'))[:5]
if len(names_and_counts) > 0:
return Player(id_=id_, name=names_and_counts[0][0], past_names=names_and_counts, profile_link="",
avatar_link="/psynet.jpg" if not id_.startswith(
'b') else "/ai.jpg", groups=[])
raise PlayerNotFound
return Player(id_=id_, name=steam_profile['personaname'], past_names=names_and_counts,
profile_link=steam_profile['profileurl'],
avatar_link=steam_profile['avatarfull'], groups=groups)
def create() -> 'LoggedInUser':
if is_local_dev():
mock_steam_profile = get_steam_profile_or_random_response(
"TESTLOCALUSER")['response']['players'][0]
name = mock_steam_profile['personaname']
id_ = mock_steam_profile['steamid']
avatar_link = mock_steam_profile['avatarfull']
return LoggedInUser(name, id_, avatar_link, True, True, True)
if g.user is None:
raise CalculatedError(404, "User is not logged in.")
return LoggedInUser(g.user.platformname, g.user.platformid,
g.user.avatar, g.admin, g.alpha, g.beta)
def create_from_id(id_: str) -> 'Player':
session = current_app.config['db']()
names_and_counts: List[Tuple[str, int]] = session.query(PlayerGame.name, func.count(PlayerGame.name).label('c')) \
.filter(PlayerGame.player == id_) \
.group_by(PlayerGame.name).order_by(desc('c'))[:5]
try:
steam_profile = get_steam_profile_or_random_response(id_)['response']['players'][0]
except TypeError:
raise PlayerNotFound
session.close()
return Player(id_=id_, name=steam_profile['personaname'], past_names=names_and_counts,
profile_link=steam_profile['profileurl'],
avatar_link=steam_profile['avatarfull'])
def steam_process():
if validate_openid(request.args):
user_id = request.args['openid.claimed_id'].split('/')[-1]
profile = get_steam_profile_or_random_response(user_id)['response']['players'][0]
s = current_app.config['db']()
match = s.query(Player).filter(Player.platformid == user_id).first()
if match:
match.platformname = profile['personaname']
match.avatar = profile['avatarfull']
else:
u = Player(platformid=user_id, platformname=profile['personaname'], avatar=profile['avatarfull'], groups=[])
s.add(u)
s.commit()
s.close()
session['openid'] = user_id
return redirect(url_for('home'))
return jsonify({'error': 'invalid openid credentials'})
def create_from_id(id_: str, session=None) -> 'Player':
names_and_counts: List[Tuple[str, int]] = session.query(PlayerGame.name, func.count(PlayerGame.name).label('c')) \
.filter(PlayerGame.player == id_) \
.group_by(PlayerGame.name).order_by(desc('c'))[:5]
try:
steam_profile = get_steam_profile_or_random_response(
id_)['response']['players'][0]
except TypeError:
if len(names_and_counts) > 0:
return Player(id_=id_,
name=names_and_counts[0][0],
past_names=names_and_counts,
profile_link="",
avatar_link="/psynet.jpg"
if not id_.startswith('b') else "/ai.jpg")
raise PlayerNotFound
return Player(id_=id_,
name=steam_profile['personaname'],
past_names=names_and_counts,
profile_link=steam_profile['profileurl'],
avatar_link=steam_profile['avatarfull'])
def steam_process(session=None):
if validate_openid(request.args):
user_id = request.args['openid.claimed_id'].split('/')[-1]
profile = get_steam_profile_or_random_response(
user_id)['response']['players'][0]
add_or_update_steam_player(profile)
match = session.query(Player).filter(
Player.platformid == user_id).first()
if match:
match.platformname = profile['personaname']
match.avatar = profile['avatarfull']
else:
u = Player(platformid=user_id,
platformname=profile['personaname'],
avatar=profile['avatarfull'],
groups=[])
session.add(u)
session.commit()
flask_session['openid'] = user_id
flask_session.permanent = True
return redirect(url_for('home'))
return jsonify({'error': 'invalid openid credentials'})
def compare_player(ids):
session = current_app.config['db']()
ids = ids.split(',')
common_games = player_wrapper.get_player_games(session, ids)
users = []
for player_id in ids:
total_games = player_wrapper.get_total_games(session, player_id)
games, stats, favorite_car, favorite_car_pctg, names = player_stat_wrapper.get_averaged_stats(session, player_id,
total_games)
steam_profile = get_steam_profile_or_random_response(player_id, current_app)
if steam_profile is None:
return render_template('error.html', error="Unable to find the requested profile: " + player_id)
user = {
'id': player_id,
'games': games,
'stats': stats,
'favorite_car': favorite_car,
'favorite_car_pctg': favorite_car_pctg,
'steam_profile': steam_profile
}
users.append(user)
return render_with_session('compare.html', session, games=common_games, users=users, max_pages=1,
get_stat_spider_charts=PlayerStatWrapper.get_stat_spider_charts)
def create(session=None) -> List[PlaylistLeaderboard]:
durations = [Duration('week', 7), Duration('month', 30)]
q = session.query(PlayerGame.player, func.count(PlayerGame.player).label('count')) \
.join(Game, Game.hash == PlayerGame.game).group_by(PlayerGame.player).order_by(desc('count'))
playlist_leaderboards = []
for playlist in Playlist:
filtered_playlist = q.filter(Game.playlist == playlist.value)
duration_leaders: Dict[Duration, List[Leader]] = {}
for duration in durations:
start = datetime.datetime.now() - datetime.timedelta(
days=duration.days)
leaders_query_result = filtered_playlist.filter(
Game.match_date > start)[:10]
leaders = []
for leader in leaders_query_result:
player = session.query(Player).filter(
Player.platformid == leader[0]).first()
if player.avatar == "":
# this will update the DB for future calls, we just want it temporarily
profile = get_steam_profile_or_random_response(
player.platformid)
try:
player.avatar = profile['response']['players'][0][
'avatarfull']
except:
player.avatar = "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/" \
"avatars/fe/fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb_full.jpg"
leaders.append(
Leader(name=player.platformname
if player.platformname != "" else leader[0],
id_=leader[0],
count=leader[1],
avatar=player.avatar))
duration_leaders[duration] = leaders
playlist_leaderboards.append(
PlaylistLeaderboard(playlist, duration_leaders))
return playlist_leaderboards
