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 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:
xws = None
tourney_list = player.get_first_tourney_list()
if tourney_list and tourney_list.archtype_list:
xws = XWSListConverter(tourney_list.archtype_list).data
players.append({NAME: player.get_player_name(), ID: player.id, XWS: xws})
return None, players
def get_tourney_data():
tourney_id = request.args['tourney_id']
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
de = RankingEditor( pm, tourney )
return de.get_json()
def unlock_tourney():
key = request.args.get('key')
tourney_id = request.args.get('tourney_id')
pm = PersistenceManager(myapp.db_connector)
state = ""
try:
tourney = pm.get_tourney_by_id(tourney_id)
if len(key) and tourney.email == key:
response = jsonify( result="success")
if tourney.locked == True: #flip the lock
tourney.locked = False
state = "unlocked"
else:
tourney.locked = True
state = "locked"
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="lock/unlock tourney",
event_details="set tourney %s to state %s" % ( tourney.tourney_name, state ))
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return response
else:
response = jsonify(result="fail")
return response
except Exception, e:
error = "someone tried to unlock tourney_id " + tourney_id + " with email address " + key + " ( expected " + tourney.email + " ) "
mail_error( error )
response = jsonify(message=str(e))
response.status_code = (500)
return response
def get_tourney_details():
tourney_id = request.args.get('tourney_id')
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
unlocked = True
if tourney.locked:
unlocked = False
return render_template('edit_tourney.html', tourney_id=tourney_id,
tourney=tourney,
unlocked=unlocked )
def update_tourney_details():
tourney_id = request.form['tourney_id']
name = decode( request.form['name'] )
type = request.form['tourney_type']
print request.form['datepicker']
mmddyyyy = request.form['datepicker'].split('/')
date = datetime.date( int(mmddyyyy[2]),int(mmddyyyy[0]), int(mmddyyyy[1])) #YYYY, MM, DD
round_length = request.form['round_length_userdef']
tourney_format_def = request.form['tourney_format_dropdown']
tourney_format_custom = request.form['tourney_format_custom']
participant_count = int(request.form['participant_count'])
country = decode(request.form['country'])
state = decode(request.form['state'])
city = decode(request.form['city'])
venue = decode(request.form['venue'])
tourney_format = None
if tourney_format_def is None or len(tourney_format_def) == 0:
if tourney_format_custom is None or len(tourney_format_custom) == 0:
tourney_format = xwingmetadata.format_default
else:
tourney_format = decode(tourney_format_custom)
else:
tourney_format = str(tourney_format_def)
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
tourney.tourney_name = name
tourney.tourney_type = type
tourney.tourney_date = date
tourney.round_length = round_length
tourney.format = tourney_format
tourney.participant_count = participant_count
tourney.venue.country = country
tourney.venue.state = state
tourney.venue.city = city
tourney.venue.venue = venue
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="edit tourney information",
event_details="edited " + name )
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return redirect( url_for( 'get_tourney_details', tourney_id=tourney_id) )
def edit_tourney_details():
tourney_id = request.args.get('tourney_id')
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
tourney_date = tourney.tourney_date
date_str = "%d/%d/%d" % ( tourney_date.month, tourney_date.day, tourney_date.year)
print "tourney date is " + date_str
return render_template('edit_tourney_details.html', tourney_id=tourney_id,
tourney=tourney,
tourney_formats = xwingmetadata.formats,
tourney_date = date_str,
unlocked=False )
def export_tourney_lists():
tourney_id = request.args.get('tourney_id')
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
ret = get_tourney_lists_as_text(tourney)
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="export tourney lists",
event_details="exported tourney %s" % ( tourney.tourney_name ))
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return csv_response( ret, "tourney_list_download.csv")
def get(self, tourney_id):
helper = TournamentApiHelper()
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 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 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()
json = TourneyToJsonConverter().convert(t,provide_points=True)
return jsonify(json)
def get(self, tourney_id, player_id):
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
xws = None
tourney_player = tourney.get_player_by_id(player_id)
tourney_list = tourney_player.get_first_tourney_list()
if tourney_list and tourney_list.archtype_list:
xws = XWSListConverter(tourney_list.archtype_list).data
payload = {NAME: tourney_player.get_player_name(),
ID: tourney_player.id,
XWS: xws}
response = jsonify({'player': payload} )
response.status_code = 200
return response
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 edit_ranking_row():
#see https://editor.datatables.net/manual/server
tourney_id = request.args['tourney_id']
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
de = RankingEditor(pm, tourney)
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="edit ranking row")
player_name = request.values['data[player_name]']
player_name = decode(player_name)
ret = de.set_and_get_json(request, player_name, event)
event.event_details = event.event_details + " in tourney " + tourney.tourney_name
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return ret
def post(self, tourney_id):
helper = TournamentApiHelper()
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 delete(self, tourney_id, player_id):
helper = TournamentApiHelper()
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 enter_list():
tourney_id = request.args.get('tourney')
tourney_list_id = request.args.get('tourney_list_id')
pm = PersistenceManager(myapp.db_connector)
tourney_list = None
tourney = None
if tourney_list_id is None:
tourney = pm.get_tourney_by_id(tourney_id)
tourney_list = pm.get_random_tourney_list(tourney)
if tourney_list is None:
return redirect(url_for( "success", tourney_name=tourney.tourney_name ) )
else:
tourney_list = pm.get_tourney_list(tourney_list_id)
tourney = tourney_list.tourney
m = xwingmetadata.XWingMetaData()
image_src = None
if tourney_list.image is not None:
image_src = urllib.quote(tourney_list.image)
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="create list",
event_details="created list %d for tourney %s" % ( tourney_list.id, tourney.tourney_name ))
pm = PersistenceManager(myapp.db_connector)
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
return render_template('list_entry.html',
meta=m,
image_src=image_src,
tourney_list=tourney_list,
tourney_list_id=tourney_list.id,
tourney_id=tourney.id,
tourney=tourney)
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 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 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:
xws = None
tourney_list = player.get_first_tourney_list()
if tourney_list and tourney_list.archtype_list:
xws = XWSListConverter(tourney_list.archtype_list).data
players.append({NAME: player.get_player_name(),
ID: player.id,
XWS: xws})
response = jsonify({PLAYERS: players})
response.status_code = 200
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
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
def put(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
if tourney is None:
response = jsonify(message="tourney %d not found" % (tourney_id))
response.status_code = 403
return response
# go through and try to update what we can.
json_data = None
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
self.helper = helper
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:
bail
if json_data.has_key(TOURNAMENT):
t = json_data[TOURNAMENT]
if t.has_key(NAME):
tourney.tourney_name = t[NAME]
if t.has_key(DATE):
tourney_date = t[DATE]
parsed_date = None
try:
parsed_date = dateutil.parser.parse(tourney_date)
except Exception:
return helper.bail("invalid tourney date %s" % (parsed_date), 403)
tourney.tourney_date = parsed_date
if t.has_key(TYPE):
tourney_type = t[TYPE]
# validate the tourney type
if not tourney_type in TournamentApiHelper.tourney_types:
return helper.bail("invalid tourney type %s" % (tourney_type), 403)
tourney.tourney_type = tourney_type
if t.has_key(ROUND_LENGTH):
tourney.round_length = t[ROUND_LENGTH]
if t.has_key(PARTICIPANT_COUNT):
tourney.participant_count = t[PARTICIPANT_COUNT]
# now try all the other fields.
helper.extract_email(t, tourney)
helper.extract_video_url(t,tourney)
helper.extract_tourney_format(t, tourney)
helper.extract_venue(t, tourney)
bail, tlists_by_id, tlists_by_name = helper.extract_players(t,
tourney) # round by round results, if it exists
if bail:
return bail
bailout = helper.extract_set(t, tourney, pm)
if bailout:
return bailout
bailout = helper.extract_rounds(t, tourney, tlists_by_id, tlists_by_name, pm)
if bailout:
return bailout
# and log it
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="API",
event_details="tournament API: tourney update via POST")
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
response = jsonify(
{TOURNAMENT: {NAME: tourney.get_tourney_name(), "id": tourney.id, API_TOKEN: tourney.api_token}})
response.status_code = 200
return response
else:
return helper.bail(
"invalid tourney submission, must contain required fields, missing %s " % (TOURNAMENTS), 403)
else:
return helper.bail("invalid tourney submission, must contain a json payload", 403)
def put(self, tourney_id):
pm = PersistenceManager(myapp.db_connector)
tourney = pm.get_tourney_by_id(tourney_id)
if tourney is None:
response = jsonify(message="tourney %d not found" % ( tourney_id ))
response.status_code = 403
return response
# go through and try to update what we can.
json_data = None
pm = PersistenceManager(myapp.db_connector)
helper = TournamentApiHelper(pm)
self.helper = helper
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:
bail
if json_data.has_key(TOURNAMENT):
t = json_data[TOURNAMENT]
if t.has_key(NAME):
tourney.tourney_name = t[NAME]
if t.has_key(DATE):
tourney_date = t[DATE]
parsed_date = None
try:
parsed_date = dateutil.parser.parse(tourney_date)
except Exception:
return helper.bail("invalid tourney date %s" % ( parsed_date ), 403)
tourney.tourney_date = parsed_date
if t.has_key(TYPE):
tourney_type = t[TYPE]
#validate the tourney type
if not tourney_type in TournamentApiHelper.tourney_types:
return helper.bail("invalid tourney type %s" % ( tourney_type ), 403)
tourney.tourney_type = tourney_type
if t.has_key(ROUND_LENGTH):
tourney.round_length = t[ROUND_LENGTH]
if t.has_key(PARTICIPANT_COUNT):
tourney.participant_count = t[PARTICIPANT_COUNT]
#now try all the other fields.
helper.extract_email(t, tourney)
helper.extract_tourney_format(t, tourney)
helper.extract_venue(t, tourney)
bail, tlists_by_id, tlists_by_name = helper.extract_players(t,
tourney) #round by round results, if it exists
if bail:
return bail
bailout = helper.extract_set(t, tourney, pm)
if bailout:
return bailout
bailout = helper.extract_rounds(t, tourney, tlists_by_id, tlists_by_name, pm)
if bailout:
return bailout
#and log it
event = Event(remote_address=myapp.remote_address(request),
event_date=func.now(),
event="API",
event_details="tournament API: tourney update via POST")
pm.db_connector.get_session().add(event)
pm.db_connector.get_session().commit()
response = jsonify(
{TOURNAMENT: {NAME: tourney.get_tourney_name(), "id": tourney.id, API_TOKEN: tourney.api_token}})
response.status_code = 200
return response
else:
return helper.bail(
"invalid tourney submission, must contain required fields, missing %s " % ( TOURNAMENTS ), 403)
else:
return helper.bail("invalid tourney submission, must contain a json payload", 403)
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 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( 2.0, 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( 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)
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 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 ))
#now set the players list
p = {"api_token": api_token,
"players": [ { "player_id": bob['id'],
'list': {"faction": "rebel", "pilots": [{"name": "biggsdarklighter", "ship": "xwing",
"upgrades": {"amd": ["r4d6"],
"mod": ["integratedastromech"]}},
{"name": "norrawexley", "ship": "arc170",
"upgrades": {"ept": ["pushthelimit"],
"crew": ["kylekatarn"],
"amd": ["r2d2"],
"mod": ["vectoredthrusters"],
"title": ["allianceoverhaul"]}},
{"name": "sharabey", "ship": "arc170",
"upgrades": {"ept": ["adaptability"],
"crew": ["janors"], "amd": ["r3a2"],
"title": ["allianceoverhaul"]}}],
"vendor": {"yasb": {"builder": "(Yet Another) X-Wing Miniatures Squad Builder",
"builder_url": "https://geordanr.github.io/xwing",
"link": "https://geordanr.github.io/xwing/?f=Rebel%20Alliance&d=v4!s!4:-1,77:-1:20:;204:18,-1,74,3:41:26:;205:170,-1,75,69:41:-1:&sn=Biggs%20Walks%20the%20ARCs&obs="}},
"version": "0.3.0", "name": "Biggs Walks the ARCs"}
} ]
}
resp = put( player_get_url , data=json.dumps(p))
print resp.text
self.assertEqual( 200, resp.status_code)
#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 )
def testPutAndDeleteTournament(self):
players = [
{
"name": "Lyle Hayhurst",
"mov": 622,
"score": 20,
"sos": 50,
"dropped": False,
"rank": {"swiss": 1, "elimination": 2},
},
{
"name": "Matt Babiash",
"mov": 647,
"score": 15,
"sos": 45,
"dropped": True,
"rank": {"swiss": 2, "elimination": 4},
},
{
"name": "Brandon Prokos",
"mov": 647,
"score": 15,
"sos": 45,
"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")
self.assertEqual(tourney.venue.venue, "Dice Dojo")
# 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(50, 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(45, 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 = "http://localhost:5000/api/v1/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 = "http://localhost:5000/api/v1/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 = "http://localhost:5000/api/v1/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": 50,
"dropped": False,
"rank": {"swiss": 1, "elimination": 2},
},
{
"player_id": bill["id"],
"mov": 647,
"score": 15,
"sos": 45,
"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 = "http://localhost:5000/api/v1/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 = "http://localhost:5000/api/v1/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 = "http://localhost:5000/api/v1/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)
