def get_most_recent_ratings(user_id):
from sqlalchemy.orm.exc import NoResultFound
session = SessionFactory()
try:
participation_matches = session.query( Match.id.label("match_id"),
Match.date_recorded.label("date") ).\
filter( Participation.user_id == user_id ).\
filter( Participation.match_id == Match.id ).subquery()
most_recent_match_date = session.query( participation_matches.c.match_id.label("match_id"),
func.max(participation_matches.c.date).label("date") ).\
subquery()
most_recent_match = session.query( participation_matches.c.match_id.label("match_id") ).\
filter( participation_matches.c.date == most_recent_match_date.c.date ).\
subquery()
most_recent_ratings = session.query( TrueSkillCache.sigma.label("sigma"),
TrueSkillCache.mu.label("mu"),
TrueSkillCache.exposure.label("exposure")).\
filter( TrueSkillCache.user_id == user_id ).\
filter( most_recent_match.c.match_id == TrueSkillCache.match_id ).one()
return resultdict(most_recent_ratings)
except NoResultFound:
return {'mu': trueskill.MU, 'sigma': trueskill.SIGMA, 'exposure': 0}
finally:
session.close()
def get(self, user_id):
username = self.get_current_user()
if username is None:
self.validate_user()
return
user = User.get_user(username)
if user.permission_level < constants.PERMISSION_LEVEL_USER:
self.render("denied.html", user=user)
return
if user_id is not None and user_id != "":
# single item
user_id = int(user_id)
session = SessionFactory()
try:
result = get_leaderboard_query(session).filter(User.id == user_id).one()
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
else:
# query items
raw_range = self.request.headers.get('Range', '')
m = range_expression.match(raw_range)
if m is not None:
start = int(m.group('lower'))
stop = int(m.group('upper')) + 1
else:
start = 0
stop = -1
raw_query = self.request.query
m = sorting_expression.match(raw_query)
if m is not None:
direction = m.group('direction')
column = m.group('column')
else:
direction = '-'
column = "rating"
if column not in ["id", "displayname", "games", "wins", "win_percentage", "rating", "form", "streak",
'rank_change', 'order']:
column = "rating"
if direction == '-':
direction = 'desc'
else:
direction = 'asc'
session = SessionFactory()
try:
query = get_leaderboard_query(session)
total = query.count()
# query = query.order_by(direction(column))
query = query.slice(start, stop)
result = query.all()
result = resultdict(result)
trophy_holder = session.query(FloatingTrophyCache).order_by(FloatingTrophyCache.id.desc()).first()
today = datetime.now().date()
today = datetime(today.year, today.month, today.day)
today = int(today.strftime('%s'))
previous_board = get_leaderboard_query(session, at_date = today).order_by(desc('rating')).all()
previous_ranking = {}
for pos, item in enumerate(previous_board,1):
previous_ranking[item.id] = (pos, item.rating)
result = sorted(result, key= lambda k:k['rating'])[::-1]
for i,res in enumerate(result,1):
res['order']= i
s1 = aliased(Score)
game_history = session.query(Score.score.label('player_score'), Score.game_id, s1.score.label('opponent_score') ).\
join(s1, sqlalchemy.and_(s1.game_id==Score.game_id, s1.user_id!=Score.user_id)).filter(Score.user_id==res['id']).\
order_by(Score.game_id.desc())
res['form'] = ''
game_history = ['W' if game.player_score>game.opponent_score else 'L' for game in game_history]
last_game = game_history[0]
opposite = 'W' if last_game == 'L' else 'L'
res['form'] = ''.join(reversed(game_history[0:5]))
res['streak'] = '%s%s' % (last_game, game_history.index(opposite) if opposite in game_history else len(game_history))
res['rank_change'] = (previous_ranking[res['id']][0]- i) if previous_ranking.has_key(res['id']) else 0
res['rating_change'] = (res['rating']-previous_ranking[res['id']][1]) if previous_ranking.has_key(res['id']) else 0
res['hot_streak'] = False
res['trophy_holder'] = trophy_holder is not None and trophy_holder.user_id==res['id']
result = sorted(result, key= sort_dict.get(column,lambda k:k[column]))
if direction == 'desc':
result = result[::-1]
best_streak = None
for res in sorted(result, key= sort_dict.get('streak'))[::-1]:
if (best_streak is None and int(res['streak'][1:])>3) or res['streak'] == best_streak:
res['hot_streak'] = True
best_streak = res['streak']
else:
break
data = "{}&& "+json.dumps(result)
self.set_header('Content-range', 'items {}-{}/{}'.format(start, stop, total))
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
def get(self, target_user_id):
username = self.get_current_user()
if username is None:
self.validate_user()
return
user = User.get_user(username)
if user.permission_level < constants.PERMISSION_LEVEL_USER:
self.render("denied.html", user=user)
return
if not target_user_id:
raise ValueError("User required")
# query items
raw_range = self.request.headers.get('Range', '')
m = range_expression.match(raw_range)
if m is not None:
start = int(m.group('lower'))
stop = int(m.group('upper')) + 1
else:
start = 0
stop = -1
raw_query = self.request.query
m = sorting_expression.match(raw_query)
if m is not None:
direction = m.group('direction')
column = m.group('column')
else:
direction = '-'
column = "date"
if column not in ["id", "date", "winner_id", "winner_score", "winner_displayname", "opponent_id", "opponent_score", "opponent_displayname"]:
column = "date"
if direction == '-':
direction = desc
else:
direction = asc
session = SessionFactory()
try:
query = get_match_history_query(session, target_user_id)
total = query.count()
query = query.order_by(direction(column))
query = query.slice(start, stop)
result = query.all()
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-range', 'items {}-{}/{}'.format(start, stop, total))
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
def get(self, user1, user2, summary=False):
username = self.get_current_user()
if username is None:
self.validate_user()
return
user = User.get_user(username)
if user.permission_level < constants.PERMISSION_LEVEL_USER:
self.render("denied.html", user=user)
return
if not (user1 and user2):
raise ValueError("Two users are required")
user1 = User.by_id(user1)
user2 = User.by_id(user2)
# query items
raw_range = self.request.headers.get('Range', '')
m = range_expression.match(raw_range)
if m is not None:
start = int(m.group('lower'))
stop = int(m.group('upper')) + 1
else:
start = 0
stop = -1
raw_query = self.request.query
m = sorting_expression.match(raw_query)
if m is not None:
direction = m.group('direction')
column = m.group('column')
else:
direction = '-'
column = "date"
if column not in ["id", "date", "winner_id", "winner_score", "winner_displayname", "opponent_id", "opponent_score", "opponent_displayname"]:
column = "date"
if direction == '-':
direction = desc
else:
direction = asc
session = SessionFactory()
try:
query = get_match_history_query(session, [user1.id, user2.id])
total = query.count()
query = query.order_by(direction(column))
if not summary:
query = query.slice(start, stop)
result = query.all()
if summary:
score_dict = {'won': 0, 'lost': 0, 'points_scored': 0, 'difference': 0, 'form': ''}
sum_dict = { user1.id: score_dict.copy(), user2.id: score_dict.copy() }
for res in result:
sum_dict[res.winner_id]['won'] += 1
sum_dict[res.winner_id]['points_scored'] += res.winner_score
sum_dict[res.winner_id]['difference'] += res.winner_score-res.opponent_score
sum_dict[res.winner_id]['form'] = 'W' + sum_dict[res.winner_id]['form']
sum_dict[res.opponent_id]['lost'] += 1
sum_dict[res.opponent_id]['points_scored'] += res.opponent_score
sum_dict[res.opponent_id]['difference'] += res.opponent_score-res.winner_score
sum_dict[res.opponent_id]['form'] = 'L' + sum_dict[res.opponent_id]['form']
result = []
for player in sum_dict:
user = user1 if player==user1.id else user2
player_dict = sum_dict[player]
player_dict['form'] = player_dict['form'][-5:]
player_dict.update({'id': player, 'displayname': user.displayname})
result.append(player_dict)
start = 0
stop = 1
total = 2
else:
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-range', 'items {}-{}/{}'.format(start, stop, total))
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
def get(self, user_id, timestamp):
user_id = int(user_id)
username = self.get_current_user()
if username is None:
self.validate_user()
return
user = User.get_user(username)
if user.permission_level < constants.PERMISSION_LEVEL_USER:
self.render("denied.html", user=user)
return
if timestamp is not None and timestamp != "":
# single item
timestamp = int(timestamp)
session = SessionFactory()
try:
result = get_rankstore_query(session, user_id).filter_by(timestamp=timestamp).one()
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
else:
# query items
raw_range = self.request.headers.get('Range', '')
m = range_expression.match(raw_range)
if m is not None:
start = int(m.group('lower'))
stop = int(m.group('upper')) + 1
else:
start = 0
stop = -1
raw_query = self.request.query
m = sorting_expression.match(raw_query)
if m is not None:
direction = m.group('direction')
column = m.group('column')
else:
direction = '-'
column = "timestamp"
if column not in ["timestamp", "rank"]:
column = "timestamp"
if direction == '-':
direction = desc
else:
direction = asc
session = SessionFactory()
try:
query = get_rankstore_query(session, user_id)
total = query.count()
query = query.order_by(direction(column))
query = query.slice(start, stop)
result = query.all()
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-range', 'items {}-{}/{}'.format(start, stop, total))
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
def get(self, user_id):
username = self.get_current_user()
if username is None:
self.validate_user()
return
user = User.get_user(username)
if user.permission_level < constants.PERMISSION_LEVEL_USER:
self.render("denied.html", user=user)
return
if user_id is not None and user_id != "":
# single item
user_id = int(user_id)
session = SessionFactory()
try:
result = get_leaderboard_query(session).filter(User.id == user_id).one()
result = resultdict(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
else:
# query items
raw_range = self.request.headers.get('Range', '')
m = range_expression.match(raw_range)
if m is not None:
start = int(m.group('lower'))
stop = int(m.group('upper')) + 1
else:
start = 0
stop = -1
raw_query = self.request.query
m = sorting_expression.match(raw_query)
if m is not None:
direction = m.group('direction')
column = m.group('column')
else:
direction = '-'
column = "displayname"
if column not in ["id", "displayname"]:
column = "displayname"
if direction == '-':
direction = desc
else:
direction = asc
session = SessionFactory()
try:
query = get_leaderboard_query(session)
filterable_columns = {'displayname': User.displayname}
for col, val in self.request.arguments.iteritems():
if col in filterable_columns.keys():
val = val[0].replace('*', '%')
query = query.filter(filterable_columns[col].like(val))
query = query.order_by(direction(column))
query = query.slice(start, stop)
result = query.all()
result = resultdict(result)
total = len(result)
data = "{}&& "+json.dumps(result)
self.set_header('Content-range', 'items {}-{}/{}'.format(start, stop, total))
self.set_header('Content-length', len(data))
self.set_header('Content-type', 'application/json')
self.write(data)
finally:
session.close()
