def create_user(self, request): """Creates a User. Args: request: The USER_REQUEST objects, which includes a users chosen name and an email. Returns: StringMessage: A message that is sent to the client, saying that the user has been created. Raises: endpoints.BadRequestException: If no user name is provided. endpoints.ConflictException: If the user already exists. endpoints.BadRequestException: If no email is provided. endpoints.ConflictException: If a user with that email already exists. """ if request.user_name is None: raise endpoints.BadRequestException( 'You must enter a user name to create a new user!') elif User.query(User.name == request.user_name).get(): raise endpoints.ConflictException( 'A User with username {} already exists!'.format( request.user_name)) if request.email is None: raise endpoints.BadRequestException( 'You must enter an email id to create a new user!') elif User.query(User.email == request.email).get(): raise endpoints.ConflictException( 'A User with email {} already exists!'.format(request.email)) # Create a new user with the user_name and email. user = User(name=request.user_name, email=request.email) # Add the user to the datastore with kind 'User' user.put() return StringMessage( message='User {} created!'.format(request.user_name))
def check_coords_validity(row_coord, col_coord): """Raise errors if the row or column coordinates are not valid""" if row_coord not in ROWS: raise endpoints.ConflictException( 'Row coordinate must be between 1 - 10') if col_coord not in COLUMNS: raise endpoints.ConflictException( 'Column coordinate must be between A - J')
def assign_ship_on_board(self, request): """One of the players, tries to assing one boat to his board game""" player = Player.query(Player.name == request.player_name).get() """we validate that the player is in the Data Base""" if not player: raise endpoints.NotFoundException('player not found') game = gameutils.get_by_urlsafe(request.urlsafe_key, Game) """we validate that the game where we want to create the board exists""" if not game: raise endpoints.NotFoundException( 'Game not found in the DB, please start a new game') board = Board.query(Board.key == player.board).get() """we validate that the board where we want to create the board exists""" if not board: raise endpoints.NotFoundException('board not found') """we validate that the board of the player is active, the player can't create multiple boards for the same Game""" if not player.board and not player.board_active: raise endpoints.ConflictException( 'This player has already an empty board have already a board') if player.board != board.key: raise endpoints.ConflictException( 'the board for this player is not the proper') if gameutils.valid_positions(request.start_x_position, request.start_y_position, SHIPS_IDS[request.ship_id], request.orientation): raise endpoints.BadRequestException( 'Please verify the position that you choose for the boat') """Here we check if the boat sent in the request is already active in the board""" if gameutils.check_if_boat_is_active(request.ship_id, board): raise endpoints.BadRequestException( 'Please the selected boat that you sent ' 'in the request is already active in the board') if gameutils.place_boat_in_board(board, request.start_x_position, request.start_y_position, request.ship_id, request.orientation): raise endpoints.BadRequestException( 'The place for the boat is not available, ' 'Please verify the position that you choose for the boat') try: gameutils.log_board_on_console(board) board.put() except ValueError: raise endpoints.BadRequestException( 'please verify the information ') return StringMessage( message='Boat Assigned!'.format(request.player_name))
def make_move(self, request): """One of the players, tries to hit the opponent boat""" player = Player.query(Player.name == request.player_name).get() """we validate that the player is in the Data Base""" if not player: raise endpoints.NotFoundException('player not found') game = gameutils.get_by_urlsafe(request.urlsafe_key, Game) """we validate that the game where we want to create the board exists""" if not game: raise endpoints.NotFoundException( 'Game not found in the DB, please start a new game') board = Board.query(Board.key == player.board).get() """we validate that the board where we want to create the board exists""" if not board: raise endpoints.NotFoundException('board not found') """we validate that the board of the player is active, the player can't create multiple boards for the same Game""" if not player.board and not player.board_active: raise endpoints.ConflictException( 'This player has already an empty board have already a board') if player.board != board.key: raise endpoints.ConflictException( 'the board for this player is not the proper') if not gameutils.valid_target_pointed(request.x_position, request.y_position): raise endpoints.ConflictException( 'the targeted position is not ok') try: result = gameutils.search_in_board(board, request.x_position, request.y_position) if result == "error": raise endpoints.ConflictException( 'there is a problem with the BOARD') else: score = Score.query(Score.player_name == player.name, Score.board == board, Score.game == game) board.add_target(request.x_position, request.y_position) game.add_move_to_history(request.x_position, request.y_position, player.name) message = score.target_hitted(player, request.x_position, request.y_position, board, game) if score.check_if_win(): message = "You sunk the last Boat, you win!!!" board.deactivate() return StringMessage(message=message) except ValueError: raise endpoints.BadRequestException( 'please verify the information ')
def create_user(self, request): """Creates a User. :param username (req): A unique username without leading spaces. :type username: string :param email (opt): A unique and valid email. Email is validated using MAILGUN email validation API. :type email: string :param email_notification (opt): True by default. If True, user will receive email notifications of outstanding active games. :type email_notification: boolean :returns message: A message confirming user was created, or an error message. :rtype message: string :raises: ConflictException""" # Some format checking if not request.username: raise endpoints.ConflictException( 'User name cannot be null') if len(request.username) != len(request.username.lstrip(' ')): raise endpoints.ConflictException( 'User name can not have leading spaces') if request.username.isspace(): raise endpoints.ConflictException( 'User name cannot be null') # Checking for duplicate entries if User.query(User.username == request.username).get(): raise endpoints.ConflictException( 'A user with the name {} already exists!'. format(request.username)) # Only check if email is valid if there is an email to check if request.email: if User.query(User.email == request.email).get(): raise endpoints.ConflictException( 'A user with the email {} already exists!'. format(request.email)) # Checking if the email is valid via MAILGUN APIs if not User.is_email_valid(request.email): return CreateUserResultForm( message="Email address invalid! User is not created.") # All is good, saving User object user = User( username=request.username, email=request.email, email_notification=request.email_notification) user.put() else: user = User(username=request.username) user.put() return CreateUserResultForm(message='User {} created!'. format(request.username))
def create_user(cls, auth_user, user_name): """ Register a username to a user's email address""" if User.query(User.email == auth_user.email()).get(): raise endpoints.ConflictException('You have already registered!') if User.query(User.name == user_name).get(): raise endpoints.ConflictException( 'A User with that name already exists!') user = User(name=user_name, email=auth_user.email()) user.put() return user
def create_user(self, request): """Create a User. Requires a unique username""" if User.query(User.name == request.user_name).get(): raise endpoints.ConflictException( 'A user with that name already exists!') if User.query(User.email == request.email).get(): raise endpoints.ConflictException( 'A user with that email address already exists!') user = User(name=request.user_name, email=request.email) user.put() return StringMessage( message='User {} is created!'.format(request.user_name))
def check_board_boundaries(piece_alignment, num_spaces, row_index, col_index): """Raise errors if the peice is being placed outside of the bounds of the board""" if (piece_alignment == 'vertical' and row_index + num_spaces > len(ROWS)): raise endpoints.ConflictException( 'Your piece has gone past the boundaries of the board') if (piece_alignment == 'horizontal' and col_index + num_spaces > len(COLUMNS)): raise endpoints.ConflictException( 'Your piece has gone past the boundaries of the board')
def check_placement_validity(game, player_pieces, piece_type, piece_coords): """Raise errors if piece placement is invalid: if the piece has already been placed, or if the piece being placed intersects with another piece""" for placed_piece in player_pieces: # Raise error if the piece has already been placed on the # player's board if placed_piece.ship == piece_type: raise endpoints.ConflictException( 'This piece has already been placed for this player') # Raise error if piece intersects with any other piece for placed_coordinate in placed_piece.coordinates: if placed_coordinate in piece_coords: raise endpoints.ConflictException( 'Your piece intersects with {}'.format(placed_coordinate))
def get_game_history(self, request): game = get_by_urlsafe(request.urlsafe_game_key, Game) if game: return game.to_historyform() else: raise endpoints.ConflictException('Thie game is not exist')
def addBook(self, request): """create a book.""" self._ensureAdmin() b_key = ndb.Key(Book, request.sbId.upper()) if b_key.get(): raise endpoints.ConflictException( 'Another book with same id already exists: %s' % request.sbId) email = endpoints.get_current_user().email() book = Book(key=b_key, title=request.title.lower(), author=request.author, sbId=request.sbId.upper(), language=request.language, volume=request.volume, isbn=request.isbn, price=request.price, notes=request.notes, suggestedGrade=request.suggestedGrade, category=request.category, publisher=request.publisher, mediaType=request.mediaType, editionYear=request.editionYear, donor=request.donor, comments=request.comments, reference=request.reference, createdBy=email, createdDate=date.today()) book.put() return request
def create(self, request): """ Creates a new Session. Only available to the organizer of the conference :param request: SessionForm :return: SessionForm """ if not request.websafeConfKey: raise endpoints.BadRequestException('Conference key required.') # try to prepare the Session instance session = self.__prep_new_session(request) # see if it exists already if session.key.get(): raise endpoints.ConflictException( 'Session with key %s already exists' % session.key.urlsafe()) # deal with Speaker creation/updating speakers = [self.__prepare_speaker(form) for form in request.speakers] # try the transaction request.websafeKey = self._create(session, speakers).urlsafe() # Add a task to the queue for getting featured speaker changes taskqueue.add(params={'conf_key': request.websafeConfKey}, url='/tasks/update_featured_speaker') return request
def cancel_match(self, request): """Cancel an active match""" match = get_by_urlsafe(request.match_key, Match) if not match: raise endpoints.ConflictException( 'Cannot find match with key {}'.format(request.match_key)) if not match.is_active: raise endpoints.ConflictException('Match already inactive') match.games_remaining = 0 match.is_active = False match.put() return StringMessage( message='Match {} cancelled'.format(request.match_key))
def new_game(self, request): """Creates new game""" player1 = User.query(User.name == request.player1).get() if not player1: raise endpoints.NotFoundException('Player1 does not exist!') player2 = User.query(User.name == request.player2).get() if not player2: raise endpoints.NotFoundException('Player2 does not exist!') if player1 == player2: raise endpoints.ConflictException('Cannot play against yourself') # randomize who gets the 1st turn next_turn = random.randint(1, 2) if next_turn == 1: next_turn_name = player1.name else: next_turn_name = player2.name # reset the tic tac toe board board = [' '] * 9 # create a new game record in datastore game = Game.new_game(player1.key, player2.key, next_turn_name, board) return game.to_form( '{} will have the first move'.format(next_turn_name))
def cancel_game(self, request): """Cancels the specified game.""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game: if game.cancelled: raise endpoints.ConflictException( """This game has already been\ cancelled!""") if game.game_over: raise endpoints.ConflictException( """This game is already over.\ You cannot cancel it!""") game.cancelled = True game.end_game(True) return game.to_form('Game cancelled!') else: raise endpoints.NotFoundException('Game not found!')
def check_not_double_hit(pieces, target_coord): """Check for ensuring a coordinate that has already been hit is not being hit again""" pieces_hit_coords = [piece.hit_marks for piece in pieces] for hit_coords in pieces_hit_coords: if target_coord in hit_coords: raise endpoints.ConflictException( 'This coordinate has already been hit')
def create_user(self, request): if User.query(User.name == request.user_name).get(): raise endpoints.ConflictException( 'A User with that name already exists!') user = User(name=request.user_name, email=request.email) user.put() return StringMessage( message='User {} created!'.format(request.user_name))
def create(cls, user_name, email=''): """Create a user""" if cls.query(cls.user_name == user_name).get(): msg = 'Error, that username already exists' raise endpoints.ConflictException(msg) user = cls(user_name=user_name, email=email) user.put() return user
def create_user(self, request): """Creates new user to play the game""" if User.query(User.name == request.name).get(): raise endpoints.ConflictException( 'A User with that name already exists!') user = User(name=request.name, wins=0, email=request.email) user.put() return JSONMessage(message="User {} added!".format(request.name))
def cancel_game(self, request): """Cancel an active game""" game = get_by_urlsafe(request.game_key, Game) # check game key if not game: raise endpoints.ConflictException( 'Cannot find game (key={})'.format(request.game_key)) if not game.is_active: raise endpoints.ConflictException('This game is already finished') game.round = 9 game.is_active = False game.put() return StringMessage( message='Game {} cancelled'.format(request.game_key))
def check_not_double_miss(game, target_player, target_coord): """Ensure that the coordinate being struck has not previsouly been attempted and missed against target player for given game""" misses = Miss.query(Miss.game == game.key).filter( Miss.target_player == target_player.key).fetch() miss_coords = [missCoord.coordinate for missCoord in misses] if target_coord in miss_coords: raise endpoints.ConflictException( 'This coordinate has already been struck and missed')
def create_user(self, request): """Create a new user for Hangman""" if User.query(User.user_name == request.user_name).get(): raise endpoints.ConflictException( "Try again with a new handle, that one is taken.") user = User(user_name=request.user_name, email_address=request.email_address) user.put() return StringMessage( message="Welcome to Hangman, {}".format(request.user_name))
def resume_game(self, request): """ This function resumes a game that has been saved. Input: Game safe url key""" game = utils.get_by_urlsafe(request.urlsafekey, Game) if game.status == "save": game.status = "start" game.put() return MessageForm(message=" The game has been resume") else: raise endpoints.ConflictException('Cannot resume a Game over')
def create_user(self, request): """Create a User. Requires a unique username""" if User.query(User.name == request.user_name).get(): raise endpoints.ConflictException( 'A User with that name already exists!') user = User(name=request.user_name, email=request.email, games_played=0, wins=0, average_score=0.0) user.put() return StringMessage(message='User {} created!'.format( request.user_name))
def signIn(self, request): """ This function register a new user as player. Input: A unique username and email address""" username = request.username email = request.email if not utils.valid_username(username) or not utils.valid_email(email): raise endpoints.ConflictException('Invalid Input') if Player.query(Player.username == request.username).get(): raise endpoints.ConflictException( 'A User with that name already exists!') Player(username=username, email=email).put() # create default player if not exist if not Player.query(Player.username == "computer").get(): self._defaultPlayer() return MessageForm(message="Welcome Player %s. Enjoy racing!!!" % username)
def cancel_game(self, request): """Cancel current active game""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if game and not game.game_over: game.key.delete() return StringMessage(message='Game canceled!') elif game and game.game_over: raise endpoints.ConflictException('Game already over!') else: raise endpoints.NotFoundException('No active game found!')
def create_empty_board(self, request): """One of the players, creates the game and gets the game-id and gives that ID to the other player in order to play between each other""" player = Player.query(Player.name == request.player_name).get() game = gameutils.get_by_urlsafe(request.urlsafe_key, Game) """ HERE WE START THE PROPER VALIDATIONS FOR THIS ENDPOINT""" """we validate that the player is in the Data Base""" if not player: raise endpoints.NotFoundException( 'A Player with that name does not exist!, ' 'we need a second player in order to join the game') """we validate that the game where we want to create the board exists""" if not game: raise endpoints.NotFoundException( 'Game not found in the DB, please start a new game') """we validate that the game where we want to create the board is not Over""" if not game.game_over == False: raise endpoints.ConflictException('Game is over') """we validate that the board of the player is active, the player can't create multiple boards for the same Game""" if player.board and player.board_active: raise endpoints.ConflictException( 'This player has already an empty board have already a board') try: board = Board.new_board(player, Board.create_empty_board(), game) player.board_active = True player.board = board.key player.put() board.put() except ValueError: raise endpoints.BadRequestException( 'please verify the information ' 'of the board') # Use a task queue to update the average attempts remaining. # This operation is not needed to complete the creation of a new game # so it is performed out of sequence. return board.to_form("Board created", player.name, board.aircraft_carrier, board.battleship, board.submarine, board.destroyer, board.patrol_boat)
def create_user(self, request): """Create a User. Requires a unique username.""" if User.query(User.username == request.username).get(): raise endpoints.ConflictException( 'A User with that name already exists!') user = User(username=request.username, display_name=request.display_name, email=request.email) user.put() return user.to_form()
def save_game(self, request): """ This function saves a game; The game can be played later. Input: Game safe url key""" game = utils.get_by_urlsafe(request.urlsafekey, Game) if game.status != "over": game.status = "save" game.put() return MessageForm(message=" The game has been save") else: raise endpoints.ConflictException('Cannot save a Game over')
def get_game_history(self, request): """Returns a history of all guesses made in game.""" game = get_by_urlsafe(request.urlsafe_game_key, Game) if not game: raise endpoints.ConflictException( 'Cannot find game with key {}'.format( request.urlsafe_game_key)) else: history = History.query(ancestor=game.key).order(History.order) return HistoryForms(items=[guess.to_form() for guess in history])