def get_user_rankings(self, request):
"""Return list of Users in descending order of score"""
users = User.query().order(-User.score).fetch()
return StringMessages(message=[
'{} (score:{})'.format(user.name, user.score) for user in users
])
def getFeaturedSpeaker(self, request):
"""Return Announcement from memcache."""
featured_speakers = memcache.get(MEMCACHE_FEATUREDSPEAKER_KEY)
fs = ['']
if featured_speakers:
fs = featured_speakers.get(str(request.websafeConferenceKey),
{}).values()
return StringMessages(data=fs)
def get_user_rankings(self, request):
"""Return list of Users in descending order of winning rate"""
users = User.query().order(-User.winning_rate).fetch()
return StringMessages(message=[
'{} (Winning rate:{}, '
'win:{}, lose:{}, draw:{})'.format(user.name, user.winning_rate,
user.win, user.lose, user.draw)
for user in users
])
def get_user_matches(self, request):
"""Get all active Matches for a User"""
matches = Match.query(
ndb.AND(
Match.is_active == True,
ndb.OR(Match.player_1_name == request.player_name,
Match.player_2_name == request.player_name))).fetch()
return StringMessages(
message=[match.key.urlsafe() for match in matches])
def get_active_users(self, request):
"""Return list of users with active matches"""
users = User.query().fetch()
active_users = []
for user in users:
if self.get_user_matches(
GET_USER_MATCH_REQUEST.combined_message_class(
player_name=user.name)).message:
active_users.append(user)
return StringMessages(message=[user.name for user in active_users])
def get_user_games(self, request):
""" Get Active user games"""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
q = Game.query(ancestor=ndb.Key(User, user_id))
activeGames = []
for game in q:
if game.game_over == False:
activeGames.append(StringMessage(message=game.key.urlsafe()))
return StringMessages(items=activeGames)
def get_match_history(self, request):
"""Return list of Game plays in Match"""
match = get_by_urlsafe(request.match_key, Match)
if not match:
raise endpoints.ConflictException(
'Cannot find match with key {}'.format(request.match_key))
games = Game.query(ancestor=match.key).order(Game.start_time)
return StringMessages(message=[
'{}:{}, {}:{}. {}'.format(match.player_1_name, game.player_1_move,
match.player_2_name, game.player_2_move,
game.result) for game in games
])
def get_game_history(self, request):
"""Return list of moves play in Game"""
game = get_by_urlsafe(request.game_key, Game)
# check game key
if not game:
raise endpoints.ConflictException(
'Cannot find game (key={})'.format(request.game_key))
moves = PlayerMoves.query(ancestor=game.key).order(PlayerMoves.round)
return StringMessages(message=[
'Round {}, {}:{}, {}:{}.'.format(
move.round, game.player_1_name, move.player_1_move,
game.player_2_name, move.player_2_move) for move in moves
])
def get_user_games(self, request):
"""Get all active Games for a User"""
# check user name
if not User.query(User.name == request.player_name).get():
raise endpoints.ConflictException(
'No user named {} exists!'.format(request.player_name))
else:
games = Game.query(
ndb.AND(
Game.is_active == True,
ndb.OR(
Game.player_1_name == request.player_name,
Game.player_2_name == request.player_name))).fetch()
return StringMessages(
message=[game.key.urlsafe() for game in games])
def get_high_scores(self, request):
"""Return list of high scores of the player """
scores = UserScores.query(UserScores.player ==
request.player_name).\
order(UserScores.score).fetch()
# check user played games
if not scores:
raise endpoints.ConflictException(
'{} have not finished game yet.'.format(request.player_name))
else:
return StringMessages(message=[
'Win {} rounds in game (key={})'.format(
score.score,
score.key.parent().urlsafe()) for score in scores
])
def get_user_rankings(self, request):
"""Returns all users ranked by performance."""
users = User.query().fetch()
results = []
for user in users:
if user.total_games == 0:
results.append(('%s has not played any games.' % user.name,
-1))
else:
winrate = (float(user.points) / (user.total_games * 2)) * 100
results.append(('%s has won %d%% of games played' % (user.name,
winrate),
winrate))
sorted_results = sorted(results, key=lambda result: result[1])
messages = [result[0] for result in sorted_results]
messages.reverse()
return StringMessages(messages=messages)