def editgames():
try:
games = PersistenceManager(myapp.db_connector).get_games(myapp.db_connector.get_session())
return( render_template('games-edit.html', games=games) )
except Exception:
#give it another shot...
games = PersistenceManager(myapp.db_connector).get_games(myapp.db_connector.get_session())
return( render_template('games-edit.html', games=games) )
def leaderboard():
bottom_ten_greens = PersistenceManager(myapp.db_connector).get_worst_green_luck_scores(myapp.db_connector.get_session()).all()[0:10]
bottom_ten_reds = PersistenceManager(myapp.db_connector).get_worst_red_luck_scores(myapp.db_connector.get_session()).all()[0:10]
top_ten_greens = PersistenceManager(myapp.db_connector).get_best_green_luck_scores(myapp.db_connector.get_session()).all()[0:10]
top_ten_reds = PersistenceManager(myapp.db_connector).get_best_red_luck_scores(myapp.db_connector.get_session()).all()[0:10]
return render_template( 'leaderboard.html',
bottom_ten_greens=bottom_ten_greens,
bottom_ten_reds=bottom_ten_reds,
top_ten_greens=top_ten_greens,
top_ten_reds=top_ten_reds)
def populate_luck_scores():
pm = PersistenceManager(myapp.db_connector)
pm.delete_all_luck_results(myapp.db_connector.get_session())
games = PersistenceManager(myapp.db_connector).get_games(myapp.db_connector.get_session())
i = 0
print "populating " + str(len(games)) + " luck results "
for game in games:
if i % 100 == 0:
print "calculating luck result for " + str(i) + "th game"
i += 1
luck_result = calculate_luck_result(game, game_tape=None)
if luck_result is not None:
myapp.db_connector.get_session().add( luck_result )
myapp.db_connector.get_session().commit()
return redirect(url_for('leaderboard'))
def put_or_post(self, helper, tourney_id):
if not helper.isint(tourney_id):
return helper.bail("invalid tourney_id %d passed to player get" % ( tourney_id), 403)
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
if tourney is None:
return helper.bail("failed to look up tourney id %d for player get" % ( tourney_id), 403)
json_data = None
try:
json_data = request.get_json(force=True)
except Exception:
return helper.bail("bad json received!", 403)
if json_data is not None:
bail = helper.check_token(json_data, tourney)
if bail:
return bail, None
if not json_data.has_key(PLAYERS):
return helper.bail("player put missing player key", 403), None
bail, tl1, tl2 = helper.extract_players(json_data, tourney)
if bail:
return bail
pm.db_connector.get_session().commit()
players = []
for player in tourney.tourney_players:
players.append({NAME: player.get_player_name(), ID: player.id})
return None, players
def game():
id = str(request.args.get('id'))
pm = PersistenceManager(myapp.db_connector)
game = pm.get_game(session,id)
if game == None:
return redirect(url_for('new'))
player1 = game.game_players[0]
player2 = game.game_players[1]
winning_player = "Unknown"
if game.game_winner is not None:
winning_player = game.game_winner.name
#summary_stats = GameSummaryStats(game)
game_tape = GameTape(game)
game_tape.score()
luck_result = pm.get_luck_score(session, game.id)
if luck_result is None:
luck_result = calculate_luck_result(game, game_tape=game_tape)
if luck_result is not None:
myapp.db_connector.get_session().add(luck_result)
myapp.db_connector.get_session().commit()
return render_template( 'game_summary.html',
game=game,
player1=player1,
player2=player2,
winner=winning_player,
game_tape=game_tape,
colorscale=colorscale() )
def get(self):
pm = PersistenceManager(myapp.db_connector)
ids = pm.get_tourney_ids()
ret = []
for id in ids:
ret.append(id[0])
return json.dumps({TOURNAMENTS: ret})
def post(self):
try:
query = request.form['query']
except KeyError:
json_data = request.get_json(force=True)
query = json_data['query']
try:
query = query.decode('utf-8')
except (UnicodeEncodeError, UnicodeDecodeError):
abort(400)
pm = PersistenceManager(myapp.db_connector)
tourneys = pm.db_connector.get_session().query(Tourney) \
.join(TourneyVenue) \
.filter(
or_(
Tourney.tourney_name.like('%{}%'.format(query)),
TourneyVenue.venue.like('%{}%'.format(query))
)
)
response = {
t.id: {
'name': t.tourney_name,
'venue': t.venue.venue,
'date': t.tourney_date.strftime('%Y-%m-%d'), # no timezone was kept :(
}
for t in tourneys}
return jsonify(response)
def get(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
if not helper.isint(tourney_id):
return helper.bail("invalid tourney_id %d passed to player get" % ( tourney_id), 403)
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
if tourney is None:
return helper.bail("failed to look up tourney id %d for player get" % ( tourney_id), 403)
players = []
for player in tourney.tourney_players:
players.append({NAME: player.get_player_name(), ID: player.id})
response = jsonify({PLAYERS: players})
response.status_code = 200
return response
def post(self, tourney_id, player_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
json_data = None
try:
json_data = request.get_json(force=True)
except Exception:
return helper.bail("bad json received!", 403)
if not helper.isint(tourney_id):
return helper.bail("invalid tourney_id %d passed to player post" % ( tourney_id), 400)
if not helper.isint(player_id):
return helper.bail("invalid player %d passed to player post" % ( player_id), 400)
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
bail = helper.check_token(json_data, tourney)
if bail:
return bail
player = tourney.get_player_by_id(player_id)
if player is None:
return helper.bail("couldn't find player %d, bailing out" % ( player_id), 400)
dirty = False
# add list via XWS
if XWS in json_data:
dirty = True
try:
tourney_list = player.tourney_lists[-1]
XWSToJuggler(json_data[XWS]).convert(pm, tourney_list)
except:
pm.db_connector.get_session().rollback()
return helper.bail('Could not add list via XWS', 400)
# other potential edits
if dirty:
pm.db_connector.get_session().commit()
return jsonify({
'player': {
'id': player.id,
'tourney_id': tourney.id,
'name': player.get_player_name(),
}
})
def luck_graph():
id = str(request.args.get('game_id'))
game = PersistenceManager().get_game(session,id)
player_id = long(request.args.get('player'))
dice_type = request.args.get('dice_type')
lp = LuckPlot( game, player_id, dice_type)
return lp.plot()
def setUp(self):
self.persistence_manager = PersistenceManager(True)
#just keep a top level reference to these guys for ease of use
self.session = db_connector.get_session()
#and then create the database schema, reference tables
self.persistence_manager.create_schema()
self.persistence_manager.populate_reference_tables()
self.session.commit()
def advantage():
id = str(request.args.get('game_id'))
use_initial = int(request.args.get('initial'))
game = PersistenceManager().get_game(session,id)
ap = AdvantagePlot( game, use_initial )
output = ap.plot()
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def api_games():
try:
games = PersistenceManager(myapp.db_connector).get_games(
myapp.db_connector.get_session())
# transforming into JSON-serializable objects
schema = GameSchema(many=True)
games_json = schema.dump(games)
return jsonify(games_json)
except Exception as e:
print("It is busted returned {}" + e)
return {}
def delete_game():
id = str(request.args.get('id'))
game = PersistenceManager(myapp.db_connector).get_game(session,id)
if game == None:
return redirect(url_for('new'))
#doing this manually as I banged my head against the wall trying to get it to work using the sql alchemy cascade logic...
luck_results = PersistenceManager(myapp.db_connector).get_luck_score(session, game.id)
if luck_results is not None:
for lr in luck_results:
myapp.db_connector.get_session().delete(lr)
for throw in game.game_throws:
for result in throw.results:
for adjustment in result.adjustments:
myapp.db_connector.get_session().delete(adjustment)
myapp.db_connector.get_session().delete(result)
myapp.db_connector.get_session().delete(throw)
myapp.db_connector.get_session().delete(game)
myapp.db_connector.get_session().commit()
return redirect(url_for('editgames'))
def versus():
id = str(request.args.get('game_id'))
game = PersistenceManager().get_game(session,id)
attacker_id = long(request.args.get('attacker'))
defender_id = long(request.args.get('defender'))
vp = VersusPlot( game, attacker_id, defender_id)
output = vp.plot()
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
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 setUp(self):
user = os.environ['USER']
password = os.environ['PASSWORD']
sqlfile = "./dbs/prod.sql"
cmd = "/usr/local/mysql/bin/mysql -u %s -p%s 'sozin$lists' < %s" % (
user, password, sqlfile)
print os.system(cmd)
self.pm = PersistenceManager(db_connector)
self.session = db_connector.get_session()
def damage():
id = str(request.args.get('game_id'))
game = PersistenceManager().get_game(session, id)
if game.game_tape is None:
game_tape = GameTape(game)
game_tape.score()
dp = DamagePlot( game )
output = dp.plot()
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def search(self):
ret = []
seen = {}
pm = PersistenceManager(myapp.db_connector)
for rec in self.query:
list_id = rec[0]
if not seen.has_key(list_id):
list = pm.get_tourney_list(list_id)
seen[list_id] = 1
ret.append(list)
return ret
def post(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
try:
email = request.form['email']
except KeyError:
json_data = request.get_json(force=True)
email = json_data['email']
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
if tourney is None:
return helper.bail("tourney %d not found" % ( tourney_id ), 404)
if email != tourney.email:
return helper.bail("incorrect email for tourney {}".format(tourney_id), 404)
if tourney.api_token is None:
tourney.api_token = str(uuid.uuid4())
pm.db_connector.get_session().commit()
return jsonify({"api_token": tourney.api_token})
def download_game():
games = PersistenceManager(myapp.db_connector).get_games(myapp.db_connector.get_session())
rows = []
make_header = True
for g in games:
ret = get_game_tape_text(g, make_header)
for r in ret:
rows.append(r)
if make_header is True:
make_header = False
disposition = "attachment; filename=all_dice.csv"
return Response(generate(rows), mimetype='text/csv', headers={'Content-Disposition': disposition} )
def delete(self, tourney_id, player_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
json_data = None
try:
json_data = request.get_json(force=True)
except Exception:
return helper.bail("bad json received!", 403)
if not helper.isint(tourney_id):
return helper.bail("invalid tourney_id %d passed to player delete" % ( tourney_id), 403)
if not helper.isint(player_id):
return helper.bail("invalid player %d passed to player delete" % ( player_id), 403)
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
bail = helper.check_token(json_data, tourney)
if bail:
return bail
player = tourney.get_player_by_id(player_id)
if player is None:
return helper.bail("couldn't find player %d, bailing out" % ( player_id), 403)
pm.db_connector.get_session().delete(player)
pm.db_connector.get_session().commit()
def __init__(self, config=None, **kwargs):
self.config = config
self.user_login = self.config.get("login").lower()
self.user_password = self.config.get("password")
self.persistence = PersistenceManager(self.config.get("database"))
self.session_file = self.config.get("session_file")
self.s = requests.Session()
self.c = requests.Session()
self.proxies = self.config.get('proxies')
if self.proxies:
self.s.proxies.update(self.proxies)
self.s.proxies.update(self.proxies)
# to do: check what is user agent
self.user_agent = random.sample(self.config.get("list_of_ua"), 1)[0]
self.login()
def get(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
t = pm.get_tourney_by_id(tourney_id)
if t is None:
response = jsonify(message="tourney %d not found" % ( tourney_id ))
response.status_code = 404
return response
# and log it
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="API",
event_details="tournament API: tourney GET")
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return jsonify(TourneyToJsonConverter().convert(t))
def post(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
bail, players = self.put_or_post(helper, tourney_id)
if bail:
return bail
# only return the players that the caller created
json_data = None
try:
json_data = request.get_json(force=True)
except Exception:
return helper.bail("bad json received!", 403)
new_players = json_data[PLAYERS]
ret = []
for p in players:
for np in new_players:
if p[NAME] == np[PLAYER_NAME]:
ret.append(p)
response = jsonify({PLAYERS: ret})
response.status_code = 201
return response
def delete(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
self.helper = helper
t = pm.get_tourney_by_id(tourney_id)
if t is None:
return helper.bail("tourney %d not found" % ( tourney_id ), 403)
json_data = None
try:
json_data = request.get_json(force=True)
except Exception:
return helper.bail("bad json received!", 403)
if json_data is None:
return helper.bail("delete call for tourney_id %d missing json payload, giving up " % (tourney_id), 403)
bail = helper.check_token(json_data, t)
if bail:
return bail
# whew. aaaaalmost there...
try:
pm.delete_tourney_by_id(tourney_id)
except Exception:
return helper.bail("unable to delete tourney %d, bailing out " % ( tourney_id ), 403)
#and log it
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="API",
event_details="tournament API: tourney delete %d" % ( tourney_id ))
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
response = jsonify(message="deleted tourney id %d" % ( tourney_id ))
response.status_code = 204
return response
divisions_href[division_name] = pm.get_division(
division_name, league)
tier_player.division = divisions_href[division_name]
tier_player.tier = tier_player.division.tier
tier_player.challengeboards_handle = decode(
tsv_record['challengeboards_name'])
tier_player.challonge_id = player['id']
print player['group_player_ids'][0]
tier_player.group_id = player['group_player_ids'][0]
tier_player.name = lookup_name
tier_player.email_address = decode(tsv_record['email_address'])
tier_player.person_name = decode(tsv_record['person_name'])
tier_player.reddit_handle = decode(tsv_record['reddit_handle'])
tier_player.timezone = decode(tsv_record['time_zone'])
pm.db_connector.get_session().add(tier_player)
pm.db_connector.get_session().commit()
if __name__ == "__main__":
c = ChallongeMatchCSVImporter(sys.argv[1])
pm = PersistenceManager(myapp.db_connector)
challonge_user = os.getenv('CHALLONGE_USER')
challonge_key = os.getenv('CHALLONGE_API_KEY')
ch = ChallongeHelper(challonge_user, challonge_key)
league = pm.get_league("X-Wing Vassal League Season Three")
#create all the divisions for each tier
create_divisions(c, pm, league)
create_players(c, pm, ch, league)
create_matchups(c, pm, ch, league)
def testPutAndDeleteTournament(self):
players = [
{
"name": "Lyle Hayhurst",
"mov": 622,
"score": 20,
"sos": 2.00,
'dropped': False,
"rank": {
"swiss": 1,
"elimination": 2
}
},
{
"name": "Matt Babiash",
"mov": 647,
"score": 15,
"sos": 3.14,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
},
{
"name": "Brandon Prokos",
"mov": 647,
"score": 15,
"sos": 0.76,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
},
{
"name": "Phil Kalata",
"mov": 647,
"score": 15,
"sos": 45,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
},
{
"name": "Zach Carriger",
"mov": 647,
"score": 15,
"sos": 45,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
},
{
"name": "David Pontier",
"mov": 647,
"score": 15,
"sos": 45,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
},
]
trounds = [{
"round-type":
"swiss",
"round-number":
1,
"matches": [{
"player1": "Lyle Hayhurst",
"player1points": 100,
"player2": "Brandon Prokos",
"player2points": 48,
"result": "win"
}, {
"player1": "Zach Carriger",
"player1points": 32,
"player2": "Phil Kalata",
"player2points": 0,
"result": "win"
}]
}, {
"round-type":
"elimination",
"round-number":
4,
"matches": [{
"player1": "Lyle Hayhurst",
"player1points": 100,
"player2": "Matt Babiash",
"player2points": 80,
"result": "win"
}, {
"player1": "Phil Kalata",
"player1points": 0,
"player2": "David Pontier",
"player2points": 100,
"result": "win"
}]
}]
sets = [
"Core Set", "Wave 1", "Wave 2", "Wave 3", "Wave 4", "Wave 5",
"Wave 6", "GR-75 Expansion", "CR90 Expansion",
"Imperial Aces Expansion", "Rebel Aces Expansion"
]
venue = {
'country': 'United States',
'state': 'Illinois',
'city': 'Chicago',
'venue': 'Dice Dojo'
}
t = {
"tournament": {
"name": "foobar",
"date": "2015-05-25",
"type": "Store Championship",
"round_length": 60,
"participant_count": 30,
'venue': venue,
'sets_used': sets,
'format': 'Standard - 100 Point Dogfight',
'players': players,
"rounds": trounds
}
}
resp = post(dev_url, data=json.dumps(t))
self.assertEqual(201, resp.status_code)
js = resp.json()
self.assertTrue(js.has_key('tournament'))
js = js['tournament']
self.assertTrue(js.has_key('name'))
self.assertTrue(js.has_key('id'))
self.assertTrue(js['name'] == 'foobar')
# look it up in the db and verify that stuff matched out ok
myapp.db_connector.close()
myapp.db_connector.connect()
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(int(js['id']))
self.assertTrue(tourney is not None)
self.assertEqual(tourney.tourney_name, 'foobar')
self.assertEqual(str(tourney.tourney_date), '2015-05-25')
self.assertEqual(tourney.format, 'Standard - 100 Point Dogfight')
self.assertEqual(tourney.tourney_type, "Store Championship")
self.assertEqual(tourney.round_length, 60)
self.assertEqual(tourney.participant_count, 30)
self.assertEqual(tourney.venue.country, 'United States')
self.assertEqual(tourney.venue.state, 'Illinois')
self.assertEqual(tourney.venue.city, 'Chicago')
#and the players/rankings
self.assertEqual(len(tourney.tourney_players), 6)
self.assertEqual(len(tourney.rankings), 6)
p1 = tourney.tourney_players[0]
p2 = tourney.tourney_players[2]
self.assertEqual('Lyle Hayhurst', p1.player_name)
self.assertEqual('Brandon Prokos', p2.player_name)
self.assertEqual(622, p1.result.mov)
self.assertEqual(.99, p1.result.sos)
self.assertEqual(20, p1.result.score)
self.assertEqual(False, p1.result.dropped)
self.assertEqual(1, p1.result.rank)
self.assertEqual(2, p1.result.elim_rank)
self.assertEqual(647, p2.result.mov)
self.assertEqual(.76, p2.result.sos)
self.assertEqual(15, p2.result.score)
self.assertEqual(True, p2.result.dropped)
self.assertEqual(2, p2.result.rank)
self.assertEqual(4, p2.result.elim_rank)
#and finally the round by round results
rounds = tourney.rounds
self.assertEqual(2, len(rounds))
pre_elim_rounds = tourney.get_pre_elimination_rounds()
self.assertEqual(1, len(pre_elim_rounds))
r = pre_elim_rounds[0]
self.assertEqual(1, r.round_num)
self.assertEqual('swiss', r.round_type_str())
self.assertEqual(2, len(r.results))
res1 = r.results[0]
res2 = r.results[1]
self.assertEqual("Lyle Hayhurst", res1.player1_name())
self.assertEqual("Brandon Prokos", res1.player2_name())
self.assertEqual(p1, res1.winner.player)
self.assertEqual(p2, res1.loser.player)
self.assertEqual("win", res1.get_result_for_json())
self.assertEqual(100, res1.list1_score)
self.assertEqual(48, res1.list2_score)
id = tourney.id
#resubmit it to try to create dupes
t['api_token'] = js['api_token']
url = dev_endpoint + 'tournament/' + str(tourney.id)
resp = put(url, data=json.dumps(t))
self.assertEqual(200, resp.status_code)
#ok, change one of the results
trounds[0]['matches'][0]['player1points'] = 99
t['tournament']['name'] = 'changed name'
resp = put(url, data=json.dumps(t))
self.assertEqual(200, resp.status_code)
#ok, now delete the thing
j = {"api_token": tourney.api_token}
delete_url = dev_endpoint + 'tournament/' + str(id)
resp = delete(delete_url, data=json.dumps(j))
print resp.text
self.assertEqual(204, resp.status_code)
def testAxelCase(self):
t = {
"tournament": {
"name": "playertests",
"date": "2015-05-25",
"type": "Store Championship",
"round_length": 60,
"participant_count": 30
}
}
resp = post(dev_url, data=json.dumps(t))
self.assertEqual(201, resp.status_code)
tjson = resp.json()
self.assertTrue(tjson is not None)
tjson = tjson['tournament']
tourney_id = tjson["id"]
api_token = tjson['api_token']
self.assertTrue(api_token is not None and len(api_token) > 0)
#add the players
p = [{"name": "bob"}, {"name": "bill"}]
t = {'api_token': api_token, 'players': p}
player_get_url = dev_endpoint + 'tournament/' + str(
tourney_id) + "/players"
resp = post(player_get_url, data=json.dumps(t))
print resp.text
self.assertEqual(201, resp.status_code)
pjson = resp.json()
self.assertTrue(pjson.has_key('players'))
players = pjson['players']
bob = players[0]
self.assertTrue(bob['name'] == 'bob')
self.assertTrue(bob.has_key("id"))
self.assertTrue(self.isint(bob['id']))
self.assertTrue(int(bob['id'] > 0))
bill = players[1]
self.assertTrue(bill['name'] == 'bill')
self.assertTrue(bill.has_key("id"))
self.assertTrue(self.isint(bill['id']))
self.assertTrue(int(bill['id'] > 0))
p = [{
"player_id": bob['id'],
"mov": 622,
"score": 20,
"sos": 1.00,
'dropped': False,
"rank": {
"swiss": 1,
"elimination": 2
}
}, {
'player_id': bill['id'],
"mov": 647,
"score": 15,
"sos": 0.00,
'dropped': True,
"rank": {
"swiss": 2,
"elimination": 4
}
}]
#ok, now enter the rest of the data
t = {
'api_token': api_token,
'tournament': {
'format':
'Standard - 100 Point Dogfight',
'players':
p,
"rounds": [{
"round-type":
"swiss",
"round-number":
1,
"matches": [
{
"player1_id": bob['id'],
"player1points": 100,
"player2_id": bill['id'],
"player2points": 48,
"result": "win"
},
]
}]
}
}
url = dev_endpoint + 'tournament/' + str(tourney_id)
resp = put(url, data=json.dumps(t))
self.assertEqual(200, resp.status_code)
tjson = resp.json()
self.assertTrue(tjson is not None)
myapp.db_connector.close()
myapp.db_connector.connect()
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
self.assertTrue(tourney is not None)
self.assertTrue(len(tourney.tourney_players) == 2)
def testPlayerAPI(self):
t = {
"tournament": {
"name": "playertests",
"date": "2015-05-25",
"type": "Store Championship",
"round_length": 60,
"participant_count": 30,
"players": [{
"name": "bob"
}, {
"name": "bill"
}]
}
}
resp = post(dev_url, data=json.dumps(t))
self.assertEqual(201, resp.status_code)
tjson = resp.json()
self.assertTrue(tjson is not None)
tjson = tjson['tournament']
tourney_id = tjson["id"]
api_token = tjson['api_token']
self.assertTrue(api_token is not None and len(api_token) > 0)
self.assertTrue(tourney_id is not None)
players = tjson['players']
self.assertTrue(len(players) == 2)
bob = players[0]
self.assertTrue(bob['name'] == 'bob')
self.assertTrue(bob.has_key("id"))
self.assertTrue(self.isint(bob['id']))
self.assertTrue(int(bob['id'] > 0))
bill = players[1]
self.assertTrue(bill['name'] == 'bill')
self.assertTrue(bill.has_key("id"))
self.assertTrue(self.isint(bill['id']))
self.assertTrue(int(bill['id'] > 0))
#ok, get works just fine.
#ty out player get
player_get_url = dev_endpoint + 'tournament/' + str(
tourney_id) + "/players"
print player_get_url
resp = get(player_get_url)
print resp.text
self.assertEqual(200, resp.status_code)
pjson = resp.json()
self.assertTrue(pjson.has_key('players'))
players = pjson['players']
bob = players[0]
self.assertTrue(bob['name'] == 'bob')
self.assertTrue(bob.has_key("id"))
self.assertTrue(self.isint(bob['id']))
self.assertTrue(int(bob['id'] > 0))
bill = players[1]
self.assertTrue(bill['name'] == 'bill')
self.assertTrue(bill.has_key("id"))
self.assertTrue(self.isint(bill['id']))
self.assertTrue(int(bill['id'] > 0))
#and now the player put
p = {
"api_token":
api_token,
"players": [{
'player_id': bob['id'],
'name': 'bob2'
}, {
'player_id': bill['id'],
'name': 'bill2'
}]
}
resp = put(player_get_url, data=json.dumps(p))
print resp.text
self.assertEqual(200, resp.status_code)
#look it up in the database and verify that the names were changed properly
myapp.db_connector.close()
myapp.db_connector.connect()
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
self.assertTrue(tourney is not None)
p1 = tourney.get_player_by_name("bob2")
self.assertTrue(p1 is not None)
self.assertTrue(p1.player_name == "bob2")
self.assertTrue(p1.id == bob['id'])
p2 = tourney.get_player_by_name("bill2")
self.assertTrue(p2 is not None)
self.assertTrue(p2.player_name == "bill2")
self.assertTrue(p2.id == bill['id'])
#add some new names via post
p = {
"api_token": api_token,
"players": [{
'name': "joe"
}, {
"name": "jenny"
}]
}
resp = post(player_get_url, data=json.dumps(p))
print resp.text
self.assertEqual(201, resp.status_code)
tjson = resp.json()
self.assertTrue(tjson is not None)
tjson = tjson['players']
print tjson
p1 = tjson[0]
self.assertTrue(p1 is not None)
self.assertTrue(p1['name'] == 'joe')
self.assertTrue(p1['id'] is not None)
p2 = tjson[1]
self.assertTrue(p2 is not None)
self.assertTrue(p2['name'] == 'jenny')
self.assertTrue(p2['id'] is not None)
#look it up in the database and verify that it stuck
myapp.db_connector.close()
myapp.db_connector.connect()
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
self.assertTrue(tourney is not None)
dp1 = tourney.get_player_by_name("joe")
self.assertTrue(dp1 is not None)
self.assertTrue(dp1.player_name == "joe")
self.assertTrue(dp1.id == p1['id'])
dp2 = tourney.get_player_by_name("jenny")
self.assertTrue(dp2 is not None)
self.assertTrue(dp2.player_name == "jenny")
self.assertTrue(dp2.id == p2['id'])
#ok, now try to delete!
#try to take out jenny
d = {"api_token": api_token}
delete_url = dev_endpoint + 'tournament/' + str(
tourney_id) + "/player/" + str(p2['id'])
resp = delete(delete_url, data=json.dumps(d))
print resp.text
self.assertEqual(200, resp.status_code)
myapp.db_connector.close()
myapp.db_connector.connect()
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
self.assertTrue(tourney is not None)
dp1 = tourney.get_player_by_name("joe")
self.assertTrue(dp1 is not None)
self.assertTrue(dp1.player_name == "joe")
self.assertTrue(dp1.id == p1['id'])
dp2 = tourney.get_player_by_name("jenny")
self.assertTrue(dp2 is None)
