def get_json(self):
tourney_id = self.tourney.id
players = self.tourney.tourney_players
participant_count = self.tourney.participant_count
rankings = self.tourney.rankings
ret = {}
data = []
ret[DATA] = data
if len(rankings) == 0:
#tourney has not been initialized
i = 1
while i <= participant_count:
player = TourneyPlayer(tourney_id=tourney_id,
player_name="Player %d" % (i))
self.pm.db_connector.get_session().add(player)
ranking = TourneyRanking(tourney_id=tourney_id,
player=player,
score=0,
mov=0,
sos=0,
rank=i,
elim_rank=None,
dropped=False)
self.pm.db_connector.get_session().add(ranking)
#create an empty tourney list for the player
tourney_list = TourneyList(tourney_id=tourney_id,
player=player)
self.pm.db_connector.get_session().add(tourney_list)
self.tourney.tourney_players.append(player)
self.tourney.rankings.append(ranking)
self.tourney.tourney_lists.append(tourney_list)
i = i + 1
self.pm.db_connector.get_session().commit()
for ranking in rankings:
row = {}
row['player_id'] = ranking.player_id
row['player_name'] = ranking.player.get_player_name()
row['score'] = ranking.score
row['swiss_rank'] = ranking.rank
row['dropped'] = ranking.dropped
row['championship_rank'] = ranking.elim_rank
row['mov'] = ranking.mov
if ranking.sos is None:
sos = None
else:
sos = "%.2f" % round(float(ranking.sos), 2)
row['sos'] = sos
row['list'] = ranking.pretty_print(url_root=self.url_root)
data.append(row)
return json.dumps(ret)
def get_json(self):
tourney_id = self.tourney.id
players = self.tourney.tourney_players
participant_count = self.tourney.participant_count
rankings = self.tourney.rankings
ret = {}
data = []
ret[DATA] = data
if len(rankings) == 0:
#tourney has not been initialized
i = 1
while i <= participant_count:
player = TourneyPlayer( tourney_id=tourney_id, player_name="Player %d" % (i ) )
self.pm.db_connector.get_session().add(player)
ranking = TourneyRanking( tourney_id=tourney_id, player=player,
score=0, mov=0, sos=0, rank=i, elim_rank=None, dropped=False )
self.pm.db_connector.get_session().add(ranking)
#create an empty tourney list for the player
tourney_list = TourneyList( tourney_id=tourney_id, player=player )
self.pm.db_connector.get_session().add(tourney_list)
self.tourney.tourney_players.append(player)
self.tourney.rankings.append(ranking)
self.tourney.tourney_lists.append(tourney_list)
i = i+1
self.pm.db_connector.get_session().commit()
for ranking in rankings:
row = {}
row['player_id'] = ranking.player_id
row['player_name'] = ranking.player.get_player_name()
row['score'] = ranking.score
row['swiss_rank'] = ranking.rank
row['dropped'] = ranking.dropped
row['championship_rank'] = ranking.elim_rank
row['mov'] = ranking.mov
if ranking.sos is None:
sos = None
else:
sos = "%.2f" % round(float(ranking.sos),2)
row['sos'] = sos
row['list'] = ranking.pretty_print(url_root=self.url_root)
data.append(row)
return json.dumps(ret)
def extract_players(self, t, tourney):
pm = PersistenceManager(myapp.db_connector)
tlists_by_id = {}
tlists_by_name = {}
if t.has_key(PLAYERS):
players = t[PLAYERS]
i = 1
for p in players:
player = None
ranking = None
# first see if the tourney already has a player and player list matching this player's name
#if so, update it rather than creating a new one
if p.has_key(PLAYER_ID):
player = tourney.get_player_by_id(p[PLAYER_ID])
if player is None:
return self.bail(
"couldn't find player with id %d, giving up" % ( p[PLAYER_ID], 403)), None, None
else:
if not p.has_key(PLAYER_NAME):
return self.bail("neither an id or a name was provided, giving up ", 403), None, None
player = tourney.get_player_by_name(p[PLAYER_NAME])
if player is None:
player = TourneyPlayer(player_name="Player %d" % ( i ))
ranking = TourneyRanking(player=player)
player.result = ranking
tourney_list = TourneyList(tourney=tourney, player=player)
tlists_by_id[player.id] = tourney_list # stash it away for later use
if p.has_key(PLAYER_NAME):
tlists_by_name[p[PLAYER_NAME]] = tourney_list
tourney.tourney_players.append(player)
tourney.tourney_lists.append(tourney_list)
tourney.rankings.append(ranking)
player.tourney_lists.append(tourney_list)
i = i + 1
else:
ranking = player.result
tlists_by_id[player.id] = player.get_first_tourney_list()
if p.has_key(PLAYER_NAME):
tlists_by_name[p[PLAYER_NAME]] = tlists_by_id[player.id]
# add list via XWS
if XWS in p:
try:
XWSToJuggler(p[XWS]).convert(pm, tourney_list)
except Exception as e:
print "Could not convert XWS: {} (XWS was {!r})".format(e, p[XWS])
self.extract_player(p, player, ranking)
return None, tlists_by_id, tlists_by_name
def testCryodexImport(self):
file = "static/tourneys/treport.html"
tourney_name = "test"
with open(file, "r") as myfile:
data = myfile.read()
c = Cryodex(data)
t = Tourney(tourney_name=tourney_name,
tourney_date="12/01/14",
tourney_type="whatev")
self.pm.db_connector.get_session().add(t)
#add the players
players = {}
lists = {}
for player in c.players.keys():
tp = TourneyPlayer(tourney=t, player_name=player)
tlist = TourneyList(tourney=t, player=tp)
self.pm.db_connector.get_session().add(tlist)
players[player] = tp
lists[player] = tlist
self.pm.db_connector.get_session().commit()
for round_type in c.rounds.keys():
rounds = c.rounds[round_type]
for round in rounds:
tr = TourneyRound(round_num=int(round.number),
round_type=round.get_round_type(),
tourney=t)
self.pm.db_connector.get_session().add(tr)
for round_result in round.results:
p1_tourney_list = lists[round_result.player1]
self.assertTrue(p1_tourney_list is not None)
p2_tourney_list = lists[round_result.player2]
self.assertTrue(p2_tourney_list)
winner = None
loser = None
if round_result.player1 == round_result.winner:
winner = p1_tourney_list
loser = p2_tourney_list
else:
winner = p2_tourney_list
loser = p1_tourney_list
rr = RoundResult(
round=tr,
list1=p1_tourney_list,
list2=p2_tourney_list,
winner=winner,
loser=loser,
list1_score=int(round_result.player1_score),
list2_score=int(round_result.player2_score))
self.pm.db_connector.get_session().add(rr)
# self.pm.db_connector.get_session().commit()
#finally load the rankings
for rank in c.ranking.rankings:
r = TourneyRanking(tourney=t,
player=players[rank.player_name],
rank=rank.rank,
elim_rank=None,
mov=rank.mov,
sos=rank.sos,
score=rank.score)
self.pm.db_connector.get_session().add(r)
self.pm.db_connector.get_session().commit()
#pull them out and verify they loaded ok
tourney = self.pm.get_tourney(tourney_name)
self.assertTrue(tourney is not None)
self.assertTrue(tourney.rounds is not None)
self.assertEqual(len(tourney.rounds), 5)
pre_elim_rounds = tourney.get_pre_elimination_rounds()
self.assertTrue(pre_elim_rounds is not None)
self.assertEqual(len(pre_elim_rounds), 3)
i = 1
for round in pre_elim_rounds:
self.assertEqual(i, round.round_num)
i = i + 1
elim_rounds = tourney.get_elim_rounds()
self.assertTrue(elim_rounds is not None)
self.assertEqual(len(elim_rounds), 2)
i = 2
for round in elim_rounds:
self.assertEqual(i, round.round_num)
i = i + 2
#now check the round results
round1 = pre_elim_rounds[0]
round1_results = round1.results
self.assertEqual(3, len(round1_results))
result1 = round1_results[0]
winner = result1.winner
loser = result1.loser
self.assertTrue(winner is not None)
self.assertTrue(loser is not None)
self.assertEqual("bob", winner.player.player_name)
self.assertEqual("janine", loser.player.player_name)
self.assertEqual(100, result1.list1_score)
self.assertEqual(0, result1.list2_score)
self.assertEqual(winner, result1.list1)
self.assertEqual(loser, result1.list2)
for round in pre_elim_rounds:
self.assertEqual(3, len(round.results))
final_round = elim_rounds[0]
results = final_round.results
result = results[0]
winner = result.winner.player
loser = result.loser.player
self.assertTrue(winner is not None)
self.assertTrue(loser is not None)
self.assertEqual("jenny", winner.player_name)
self.assertEqual("lyle", loser.player_name)
self.assertEqual(100, result.list1_score)
self.assertEqual(88, result.list2_score)
self.assertEqual(winner, result.list1.player)
self.assertEqual(loser, result.list2.player)
self.assertEqual(100, result.winning_score())
self.assertEqual(88, result.losing_score())
#check the rankings
rankings = t.rankings
self.assertTrue(rankings is not None)
self.assertEqual(6, len(rankings))
winner = rankings[0]
self.assertTrue(winner is not None)
self.assertEqual("jenny", winner.player.player_name)
self.assertEqual(1, winner.rank)
self.assertEqual(13, winner.score)
self.assertEqual(416, winner.mov)
self.assertEqual(20, winner.sos)
loser = rankings[len(rankings) - 1]
self.assertTrue(loser is not None)
self.assertEqual("janine", loser.player.player_name)
self.assertEqual(6, loser.rank)
self.assertEqual(0, loser.score)
self.assertEqual(56, loser.mov)
self.assertEqual(25, loser.sos)
def set_and_get_json(self, request, player_name, event):
#see https://editor.datatables.net/manual/server
event_details = ""
players = self.tourney.tourney_players
#get the client data
action = request.values['action']
swiss_rank = request.values['data[swiss_rank]']
champ_rank = request.values['data[championship_rank]']
if len(champ_rank) == 0:
champ_rank = None
dropped = str2bool(request.values['data[dropped]'])
score = request.values['data[score]']
if len(score) == 0:
score = None
mov = request.values['data[mov]']
if len(mov) == 0:
mov = None
sos = request.values['data[sos]']
if len(sos) == 0:
sos = None
player_id = request.values['data[player_id]']
if len(player_id) >0:
player_id = long(player_id)
ranking = None
player = None
for p in players:
if p.id == player_id:
player = p
player.player_name = player_name
break
#figure out the actions
if action == EDIT:
#grab the rankings
rankings = self.tourney.rankings
#find it
for r in rankings:
if r.player_id == player_id:
#edit it
ranking = r
ranking.score = score
ranking.mov = mov
ranking.sos = sos
ranking.rank = swiss_rank
ranking.elim_rank = champ_rank
ranking.dropped = dropped
event.event_details = "edited player %s " % ( player.player_name )
break
elif action == CREATE:
player = TourneyPlayer( tourney_id=self.tourney.id, player_name=player_name)
self.tourney.tourney_players.append(player)
self.pm.db_connector.get_session().add(player)
ranking = TourneyRanking( tourney_id=self.tourney.id, player=player,
score=score, mov=mov, sos=sos, rank=swiss_rank, elim_rank=champ_rank, dropped=dropped )
tourney_list = TourneyList( tourney_id=self.tourney.id, player=player )
self.tourney.tourney_lists.append(tourney_list)
self.pm.db_connector.get_session().add(tourney_list)
self.tourney.rankings.append( ranking)
self.pm.db_connector.get_session().add(ranking)
event.event_details = "added player %s " % ( player.player_name )
self.pm.db_connector.get_session().commit()
return json.dumps( { "row" : { "player_id": player.id, "player_name": player.get_player_name(),
"score": ranking.score, "swiss_rank" : ranking.rank,
"championship_rank": ranking.elim_rank, "mov": ranking.mov,
"sos": ranking.sos, "dropped": ranking.dropped, "list":ranking.pretty_print(self.url_root)}} )
def set_and_get_json(self, request, player_name, event):
#see https://editor.datatables.net/manual/server
event_details = ""
players = self.tourney.tourney_players
#get the client data
action = request.values['action']
swiss_rank = request.values['data[swiss_rank]']
champ_rank = request.values['data[championship_rank]']
if len(champ_rank) == 0:
champ_rank = None
dropped = str2bool(request.values['data[dropped]'])
score = request.values['data[score]']
if len(score) == 0:
score = None
mov = request.values['data[mov]']
if len(mov) == 0:
mov = None
sos = request.values['data[sos]']
if len(sos) == 0:
sos = None
player_id = request.values['data[player_id]']
if len(player_id) > 0:
player_id = long(player_id)
ranking = None
player = None
for p in players:
if p.id == player_id:
player = p
player.player_name = player_name
break
#figure out the actions
if action == EDIT:
#grab the rankings
rankings = self.tourney.rankings
#find it
for r in rankings:
if r.player_id == player_id:
#edit it
ranking = r
ranking.score = score
ranking.mov = mov
ranking.sos = sos
ranking.rank = swiss_rank
ranking.elim_rank = champ_rank
ranking.dropped = dropped
event.event_details = "edited player %s " % (
player.player_name)
break
elif action == CREATE:
player = TourneyPlayer(tourney_id=self.tourney.id,
player_name=player_name)
self.tourney.tourney_players.append(player)
self.pm.db_connector.get_session().add(player)
ranking = TourneyRanking(tourney_id=self.tourney.id,
player=player,
score=score,
mov=mov,
sos=sos,
rank=swiss_rank,
elim_rank=champ_rank,
dropped=dropped)
tourney_list = TourneyList(tourney_id=self.tourney.id,
player=player)
self.tourney.tourney_lists.append(tourney_list)
self.pm.db_connector.get_session().add(tourney_list)
self.tourney.rankings.append(ranking)
self.pm.db_connector.get_session().add(ranking)
event.event_details = "added player %s " % (player.player_name)
self.pm.db_connector.get_session().commit()
return json.dumps({
"row": {
"player_id": player.id,
"player_name": player.get_player_name(),
"score": ranking.score,
"swiss_rank": ranking.rank,
"championship_rank": ranking.elim_rank,
"mov": ranking.mov,
"sos": ranking.sos,
"dropped": ranking.dropped,
"list": ranking.pretty_print(self.url_root)
}
})
