def put(self, player_name):
if not request.json:
return create_error_response(415, "Unsupported Media Type", "use JSON")
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(404, "Player not found")
try:
validate(request.json, PlayerBuilder.playerSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
new_name = request.json["name"]
#If the new name already in use, return 409
if new_name != player_name:
db_player_new_name = Player.query.filter_by(name=new_name).first()
if db_player_new_name is not None:
return create_error_response(409, "Alredy exists", "Player already exists with name " + str(new_name))
db_player.name = new_name
db.session.add(db_player)
db.session.commit()
#Return the location in the header in case the name changes
return Response(status=201, headers={
"Location": url_for("playerresource", player_name=new_name)
})
def get(self, game_name, player_name):
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(
404, "No game found with name " + str(game_name))
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(
404, "No player found with name " + str(player_name))
db_player_score = PlayerScore.query.filter_by(player=db_player,
game=db_game).first()
if db_player_score is None:
return create_error_response(
404, "No score found with player name " + str(player_name) +
" and game name " + str(game_name))
body = ScoreBuilder(name=db_player.name, game=db_game.game_token)
if db_player_score.score is not None:
body["score"] = db_player_score.score
body.add_namespace("gamescr", NAMESPACE_URL)
body.add_control(
"self",
url_for("playerscoreresource",
game_name=game_name,
player_name=player_name))
body.add_control("profile", PROFILE_URL)
body.add_control("collection",
url_for("gamescoreboard", game_name=game_name))
body.add_control_edit_playerscore(game_name=game_name,
player_name=player_name)
body.add_control_delete_playerscore(game_name=game_name,
player_name=player_name)
body.add_control_player(player_name=player_name)
return Response(json.dumps(body), 200, mimetype=MASON)
def post(self):
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
try:
validate(request.json, GametypeBuilder.gametypeSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
gametype = GameType(name=request.json["name"])
if "min_players" in request.json:
gametype.min_players = request.json["min_players"]
if "max_players" in request.json:
gametype.max_players = request.json["max_players"]
try:
db.session.add(gametype)
db.session.commit()
except IntegrityError:
db.session.rollback()
return create_error_response(
409, "Already exists",
"Gametype with this name already exists " +
str(request.json["name"]))
return Response(status=201,
headers={
"Location":
url_for("gametyperesource",
gametype_name=request.json["name"])
})
def put(self, gametype_name):
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
nameChange = False
db_gametype = GameType.query.filter_by(name=gametype_name).first()
if db_gametype is None:
return create_error_response(404, "Gametype not found")
try:
validate(request.json, GametypeBuilder.gametypeSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
new_name = request.json["name"]
#If the new name already in use, return 409
if new_name != gametype_name:
nameChange = True
db_gametype_new_name = GameType.query.filter_by(
name=new_name).first()
if db_gametype_new_name is not None:
return create_error_response(
409, "Already exists",
"Gametype already exists with name " + str(new_name))
db_gametype.name = new_name
#if min_players specified in the request
try:
new_min_players = request.json["min_players"]
db_gametype.min_players = new_min_players
except KeyError:
#min_players not specified, set to null
db_gametype.min_players = None
#if max_players specificed in the request
try:
new_max_players = request.json["max_players"]
db_gametype.max_players = new_max_players
except KeyError:
#max_players not specified, set to null
db_gametype.max_players = None
db.session.add(db_gametype)
db.session.commit()
#Return the location in the header in case the name changes
if nameChange:
return Response(status=201,
headers={
"Location":
url_for("gametyperesource",
gametype_name=new_name)
})
else:
return Response(status=204)
def get(self, gametype_name):
#Check whether gametype exists
db_gametype = GameType.query.filter_by(name=gametype_name).first()
if db_gametype is None:
return create_error_response(404, "Gametype not found")
body = GametypeBuilder(name=gametype_name)
min_players = db_gametype.min_players
#Check whether game type has min_players or max_players set
if min_players is not None:
body["min_players"] = min_players
max_players = db_gametype.max_players
if max_players is not None:
body["max_players"] = max_players
body.add_namespace("gamescr", NAMESPACE_URL)
body.add_control(
"self", url_for("gametyperesource", gametype_name=gametype_name))
body.add_control("profile", PROFILE_URL)
body.add_control("collection", url_for("gametypecollection"))
body.add_control_edit_gametype(name=gametype_name)
body.add_control_leaderboard(name=gametype_name)
body.add_control_delete_gametype(name=gametype_name)
return Response(json.dumps(body), 200, mimetype=MASON)
def delete(self, player_name):
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(404, "Player not found")
db.session.delete(db_player)
db.session.commit()
return Response(status=204)
def delete(self, gametype_name):
db_gametype = GameType.query.filter_by(name=gametype_name).first()
if db_gametype is None:
return create_error_response(404, "Gametype not found")
db.session.delete(db_gametype)
db.session.commit()
return Response(status=204)
def delete(self, game_name, player_name):
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(
404, "No game found with name " + str(game_name))
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(
404, "No player found with name " + str(player_name))
db_player_score = PlayerScore.query.filter_by(player=db_player,
game=db_game).first()
if db_player_score is None:
return create_error_response(
404, "No score found with player name " + str(player_name) +
" and game name " + str(game_name))
db.session.delete(db_player_score)
db.session.commit()
return Response(status=204)
def post(self, game_name):
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
try:
validate(request.json, ScoreBuilder.scoreSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
score = PlayerScore(score=request.json["score"])
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(
404, "Game not found",
"Game with this name doesn't exist " + str(game_name))
score.game_id = db_game.id
db_player = Player.query.filter_by(name=request.json["player"]).first()
if db_player is None:
return create_error_response(
404, "Player not found",
"Player with this name doesn't exist " +
str(request.json["player"]))
score.player_id = db_player.id
#Check if player already has score in this game
prevscores = PlayerScore.query.filter_by(game_id=db_game.id).filter_by(
player_id=db_player.id).first()
if prevscores is not None:
return create_error_response(
409, "Already exists",
"Playerscore for this player already exists in game " +
game_name)
db.session.add(score)
db.session.commit()
return Response(status=201,
headers={
"Location":
url_for("playerscoreresource",
game_name=game_name,
player_name=db_player.name)
})
def post(self):
if not request.json:
return create_error_response(415, "Unsupported Media Type", "use JSON")
try:
validate(request.json, PlayerBuilder.playerSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
player = Player(
name = request.json["name"]
)
try:
db.session.add(player)
db.session.commit()
except IntegrityError:
db.session.rollback()
return create_error_response(409, "Already exists", "Player already exists with name " + str(request.json["name"]))
return Response(status=201, headers={
"Location": url_for("playerresource", player_name=request.json["name"])
})
def get(self, player_name):
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(404, "Player not found")
body = PlayerBuilder(
name = player_name
)
body.add_namespace("gamescr", NAMESPACE_URL)
body.add_control("self", url_for("playerresource", player_name=player_name))
body.add_control("profile", PROFILE_URL)
body.add_control("collection", url_for("playercollection"))
body.add_control_edit_player(name=player_name)
body.add_control_leaderboard(name=player_name)
body.add_control_delete_player(name=player_name)
return Response(json.dumps(body), 200, mimetype=MASON)
def get(self, game_name):
items = []
#Check whether game exists
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(404, "Game not found")
scores = PlayerScore.query.filter_by(game_id=db_game.id).all()
for db_score in scores:
player = db_score.player.name
game = db_score.game.game_token
body = ScoreBuilder(player=player, game=game)
score = db_score.score
if score is not None:
body["score"] = score
else:
body["score"] = str(0.0)
#Controls for an item
body.add_control(
"self",
url_for("playerscoreresource",
game_name=game,
player_name=player))
body.add_control("profile", PROFILE_URL)
items.append(body)
body = ScoreBuilder()
#Controls for collection
body.add_namespace("gamescr", NAMESPACE_URL)
body.add_control("self", url_for("gamescoreboard",
game_name=game_name))
body.add_control("up", url_for("gameresource", game_name=game_name))
body.add_control_add_score(name=game_name)
body["items"] = items
return Response(json.dumps(body), 200, mimetype=MASON)
def get(self, game_name):
#Check whether game exists
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(404, "Game not found")
body = GameBuilder(name=db_game.game_token,
status=db_game.status,
created=str(db_game.created_at))
#Get game_type if exists
if db_game.game_type is not None:
body["game_type"] = db_game.game_type.name
#Get host if exists
if db_game.host is not None:
body["host"] = db_game.host.name
#Get tournament if exists
if db_game.tournament is not None: # pragma: no cover
body["tournament"] = db_game.tournament.name
if db_game.finished_at is not None:
body["finished"] = str(db_game.finished_at)
body.add_namespace("gamescr", NAMESPACE_URL)
body.add_control("self", url_for("gameresource", game_name=game_name))
body.add_control("profile", PROFILE_URL)
body.add_control("collection", url_for("gamecollection"))
if db_game.game_type is not None:
body.add_control_gametype(name=db_game.game_type.name)
body.add_control_all_players()
body.add_control_scores(name=game_name)
if db_game.tournament is not None: # pragma: no cover
body.add_control_tournament(name=db_game.tournament.name)
body.add_control_add_score(name=game_name)
body.add_control_edit_game(name=game_name)
body.add_control_delete_game(name=game_name)
return Response(json.dumps(body), 200, mimetype=MASON)
def post(self):
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
try:
validate(request.json, GameBuilder.gameSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
db_gametype = GameType.query.filter_by(
name=request.json["game_type"]).first()
if db_gametype is None:
return create_error_response(
409, "Gametype not found",
"Gametype with this name doesn't exist " +
str(request.json["game_type"]))
game = Game(game_type_id=db_gametype.id)
db_host = Player.query.filter_by(name=request.json["host"]).first()
if db_host is None:
return create_error_response(
409, "Host not found", "Player with this name doesn't exist " +
str(request.json["host"]))
game.host_id = db_host.id
if "status" in request.json:
game.status = request.json["status"]
if "tournament" in request.json: # pragma: no cover
db_tournament = Tournament.query.filter_by(
name=request.json["tournament"]).first()
if db_tournament is None:
return create_error_response(
409, "Tournament not found",
"Tournament with this name doesn't exist " +
str(request.json["tournament"]))
game.tournament_id = db_tournament.id
#Name is either decided by the user or generated from gametype
if "name" in request.json:
game.game_token = request.json["name"]
try:
db.session.add(game)
db.session.commit()
except IntegrityError:
db.session.rollback()
return create_error_response(
409, "Already exists",
"Game with this name already exists " +
str(request.json["name"]))
else:
limiter = 0
while True:
if limiter > 10:
return Response(
status=507,
response="Unexpected error, please name game manually")
game.game_token = request.json["game_type"] + ''.join(
random.choices(string.ascii_lowercase + string.digits,
k=6))
try:
limiter += 1
db.session.add(game)
db.session.commit()
break
except IntegrityError:
continue
return Response(status=201,
headers={
"Location":
url_for("gameresource", game_name=game.game_token)
})
def put(self, game_name):
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
db_game = Game.query.filter_by(game_token=game_name).first()
nameChange = False
if db_game is None:
return create_error_response(404, "Game not found")
try:
validate(request.json, GameBuilder.gameSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
if "name" in request.json:
new_name = request.json["name"]
#If the new name already in use, return 409
if new_name != game_name:
nameChange = True
db_game_new_name = Game.query.filter_by(
game_token=new_name).first()
if db_game_new_name is not None:
return create_error_response(
409, "Alredy exists",
"Game already exists with name " + str(new_name))
db_game.game_token = new_name
#if status changes from 1 to 0 (game ends) or 0 to 1 (game is active again), log the time the game ends/
#remove it
if "status" in request.json:
new_status = request.json["status"]
if db_game.finished_at is None:
if new_status == 0:
db_game.finished_at = datetime.datetime.now()
else:
if new_status == 1:
db_game.finished_at = None
db_game.status = new_status
else:
if db_game.finished_at is not None:
db_game.finished_at = None
#If gametype updated, check that it is valid
new_gametype = request.json["game_type"]
db_new_gametype = GameType.query.filter_by(name=new_gametype).first()
if db_new_gametype is None:
return create_error_response(
409, "Gametype not valid",
"No gametype exists with name " + str(new_gametype))
else:
db_game.game_type = db_new_gametype
#If host name updated, check that it is valid
new_host_name = request.json["host"]
db_new_host = Player.query.filter_by(name=new_host_name).first()
if db_new_host is None:
return create_error_response(
409, "Host name not valid",
"No player exists with name " + str(new_host_name))
else:
db_game.host = db_new_host
#If tournament updated, check that is valid
if "tournament" in request.json: # pragma: no cover
new_tournament_name = request.json["tournament"]
db_new_tournament = Tournament.query.filter_by(
name=new_tournament_name).first()
if db_new_tournament is None:
return create_error_response(
409, "Tournament name not valid",
"No tournament exists with name " +
str(new_tournament_name))
else:
db_game.tournament = db_new_tournament
else:
db_game.tournament = None
db.session.add(db_game)
db.session.commit()
#Return the location in the header in case the name changes
if nameChange:
return Response(status=201,
headers={
"Location":
url_for("gameresource",
game_name=db_game.game_token)
})
else:
return Response(status=204)
def put(self, game_name, player_name):
url_changed = False
if not request.json:
return create_error_response(415, "Unsupported Media Type",
"use JSON")
db_game = Game.query.filter_by(game_token=game_name).first()
if db_game is None:
return create_error_response(
404, "No game found with name " + str(game_name))
db_player = Player.query.filter_by(name=player_name).first()
if db_player is None:
return create_error_response(
404, "No player found with name " + str(player_name))
db_player_score = PlayerScore.query.filter_by(
player=db_player).filter_by(game=db_game).first()
if db_player_score is None:
return create_error_response(
404, "No score found with player name " + str(player_name) +
" and game name " + str(game_name))
try:
validate(request.json, ScoreBuilder.scoreSchema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
#If the player of the player score changes
new_player = request.json["player"]
if new_player != player_name:
db_new_player = Player.query.filter_by(name=new_player).first()
if db_new_player is None:
return create_error_response(
409, "Player does not exist",
"No player exists with name " + str(new_player))
else:
db_player_score_duplicate = PlayerScore.query.filter_by(
game=db_game).filter_by(player=db_new_player).first()
if db_player_score_duplicate is not None:
return create_error_response(
409, "Player score already exists",
"Player score already " + "exists with name " +
str(new_player))
db_player_score.player = db_new_player
url_changed = True
#When score changes
new_score = request.json["score"]
db_player_score.score = new_score
db.session.add(db_player_score)
db.session.commit()
#If url changed
if url_changed:
return Response(status=201,
headers={
"Location":
url_for(
"playerscoreresource",
player_name=db_player_score.player.name,
game_name=db_player_score.game.game_token)
})
else:
return Response(status=204)
