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)