def test_crud(self):
with self.app_context():
room = RoomModel(_id=1,
company='Test Company',
location='Test Location',
name='Test Name',
description='Some Test Description',
rateofescape='10/10',
image='test.jpg',
duration='60 minutes',
playedon='01/01/2018')
self.assertIsNone(RoomModel.find_by_id(1))
room.save_to_db()
self.assertIsNotNone(
RoomModel.find_by_name_company('Test Name', 'Test Company'))
self.assertIsNotNone(RoomModel.find_by_id(1))
self.assertIsNotNone(RoomModel.get_all_rooms())
room.delete_from_db()
self.assertIsNone(RoomModel.find_by_id(1))
self.assertEqual(RoomModel.get_all_rooms(), {'rooms': []})
def put(self, id_user, id_estate, id_room):
data = EditRoom.parser_edit.parse_args()
try:
room = RoomModel.find_by_id(id_room, id_estate)
estate = EstateModel.find_by_id(id_estate)
# We handle the case of an owner can only modify the characteristics of his property
# without having access to the edition of the other owners
if id_user != estate.id_user:
raise PermissionError
# Filling data
room.name = room.name if data.name is None else data.name
room.characteristic = room.characteristic if data.characteristic is None else data.characteristic
room.save_to_db()
return room.json(), 200
except NoResultFound:
return {'message': 'Please make sure the id is correct'}, 400
except PermissionError:
return {'message': 'Access denied'}, 403
except:
return {
'message': 'An error occurred while inserting the room'
}, 500
def put(self, id):
room = RoomModel.find_by_id(id)
if not room:
return {'message': 'room not found'}
data = Room.parser.parse_args()
room.characteristics = data['characteristics']
room.save_to_db()
return room.json()
def get(self, id):
room = RoomModel.find_by_title(id)
if room is None:
try:
room = RoomModel.find_by_id(int(id))
except ValueError:
return {'message': 'The Room was not found.'}, 404
if room:
return room.json()
return {'message': 'The Room was not found.'}, 404
def start_loop(self):
with self.app.app_context():
directions = ['n', 'e', 's', 'w']
while True:
time.sleep(1)
# Get all players who are automatically traversing
traversing_players = PlayerModel.find_all_by_single_path(False)
if not traversing_players or len(traversing_players) < 1:
continue
# Make every record of traversing_players the JSON dict available.
for player in traversing_players:
player_data = player.json()
# Only register next move if the player is passed cooldown.
if int(time.time()) < player_data['nextAvailableMove'] + 2:
continue
player_path = json.loads(player_data["currentPath"])["path"]
# Player has a path, travel based on it.
if len(player_path) > 0:
direction = player_path.pop(0)
traverse_to_room = Traverse.TraverseOnce(player_data['password'], direction)
traverse_to_room = traverse_to_room[0]
if len(traverse_to_room['errors']) > 0:
setattr(player, 'nextAvailableMove', (int(time.time()) + int(traverse_to_room['cooldown'])))
player.save_to_db()
continue
setattr(player, 'nextAvailableMove', int(time.time()) + int(traverse_to_room['cooldown']))
setattr(player, 'currentRoomId', traverse_to_room['room_id'])
setattr(player, 'currentPath', json.dumps({"path": player_path}))
player.save_to_db()
print(f"player traveled {direction} to {traverse_to_room['room_id']}")
continue
# return traverse_to_room
current_room = RoomModel.find_by_id(player_data['currentRoomId'])
current_room_data = None
if current_room:
current_room_data = current_room.json()
else:
# Get the room the player is currently in:
player_status_response = requests.get('https://lambda-treasure-hunt.herokuapp.com/api/adv/init/', headers={'authorization': player_data['password']}).json()
time.sleep(1)
if len(player_status_response['errors']) > 0:
setattr(player, 'nextAvailableMove', (int(time.time()) + int(player_status_response['cooldown'])))
player.save_to_db()
continue
direction = player_status_response['exits'][0]
traverse_to_room = Traverse.TraverseOnce(player_data['password'], direction)
traverse_to_room = traverse_to_room[0]
if len(traverse_to_room['errors']) > 0:
setattr(player, 'nextAvailableMove', (int(time.time()) + int(traverse_to_room['cooldown'])))
player.save_to_db()
continue
setattr(player, 'nextAvailableMove', (int(time.time()) + int(traverse_to_room['cooldown'])))
setattr(player, 'currentRoomId', traverse_to_room['room_id'])
player.save_to_db()
continue
# Check if any exits are unexplored by our database.
for direction in directions:
if current_room_data['exits'][direction] == '?':
# move to that room.
traverse_to_room = Traverse.TraverseOnce(player_data['password'], direction)
traverse_to_room = traverse_to_room[0]
if len(traverse_to_room['errors']) > 0:
setattr(player, 'nextAvailableMove', (int(time.time()) + int(traverse_to_room['cooldown'])))
player.save_to_db()
continue
setattr(player, 'nextAvailableMove', int(time.time()) + traverse_to_room['cooldown'])
setattr(player, 'currentRoomId', traverse_to_room['room_id'])
player.save_to_db()
continue
# No unexplored directions found - get shortest path to room that DOES have an unexplored exit/room
player = PlayerModel.find_by_password(player_data['password'])
player_data = player.json()
travel_path = self.GraphTraversal.path_to_unexplored(player_data['currentRoomId'])
setattr(player, 'currentPath', json.dumps(travel_path))
player.save_to_db()
def TraverseOnce(self, token, move):
opposite_dirs = {
"n": "s",
"e": "w",
"s": "n",
"w": "e"
}
time.sleep(1)
# Get the room the player is currently in:
player_status_response = requests.get(
'https://lambda-treasure-hunt.herokuapp.com/api/adv/init/', headers={'authorization': token}).json()
if len(player_status_response['errors']) > 0:
return player_status_response, 400
time.sleep(1)
# if the direction the player wants to move is in their current rooms direction list (if its a possible direction to move)
if move in player_status_response["exits"]:
# See if we have the players current room in our database.
found_room = RoomModel.find_by_id(
player_status_response['room_id'])
# If we don't have the room in our database, we haven't seen it before. So we add it to our database.
if not found_room:
# room_coordinates turns "(32,45)" -> ["32", "45"]
room_coordinates = re.findall(
r"\d+", player_status_response['coordinates'])
avail_exits = {
"n": None if "n" not in player_status_response["exits"] else "?",
"w": None if "w" not in player_status_response["exits"] else "?",
"e": None if "e" not in player_status_response["exits"] else "?",
"s": None if "s" not in player_status_response["exits"] else "?",
}
new_room_data = {
"id": player_status_response['room_id'],
"title": player_status_response['title'],
"description": player_status_response['description'],
"x": int(room_coordinates[0]),
"y": int(room_coordinates[1]),
"terrain": player_status_response['terrain'],
"elevation": player_status_response['elevation']
}
new_room_data.update(avail_exits)
found_room = RoomModel(**new_room_data)
# Now travel and save the next room result in the previous room
player_travel_request = requests.post('https://lambda-treasure-hunt.herokuapp.com/api/adv/move/', json={
"direction": move}, headers={'authorization': token}).json()
try:
new_room_id = player_travel_request['room_id']
traveled_into_room = RoomModel.find_by_id(new_room_id)
if not traveled_into_room:
# Create room record for the room we just traveled into if not found
new_room_coordinates = re.findall(
r"\d+", player_travel_request['coordinates'])
avail_exits = {
"n": None if "n" not in player_travel_request["exits"] else "?",
"w": None if "w" not in player_travel_request["exits"] else "?",
"e": None if "e" not in player_travel_request["exits"] else "?",
"s": None if "s" not in player_travel_request["exits"] else "?",
}
traveled_into_room_data = {
"id": new_room_id,
"title": player_travel_request['title'],
"description": player_travel_request['description'],
"x": int(new_room_coordinates[0]),
"y": int(new_room_coordinates[1]),
"terrain": player_travel_request['terrain'],
"elevation": player_travel_request['elevation']
}
traveled_into_room_data.update(avail_exits)
traveled_into_room = RoomModel(
**traveled_into_room_data)
setattr(traveled_into_room, opposite_dirs[move], str(
found_room.json()['id']))
setattr(found_room, move, new_room_id)
found_room.save_to_db()
return player_travel_request, 200
except KeyError:
return player_travel_request, 400
# Room is found
else:
# Check if we have the next room's id that the player is traveling to. If we do, travel there and return response to user.
if move in found_room.json()["exits"] and found_room.json()["exits"][move] is not None and found_room.json()["exits"][move] is not "?":
next_room = found_room.json()["exits"][move]
player_travel_request = requests.post('https://lambda-treasure-hunt.herokuapp.com/api/adv/move/', json={
"direction": move, "next_room_id": str(next_room)}, headers={'authorization': token}).json()
return player_travel_request, 200
# If we don't, travel that direction without wise explorer bonus. Then save that direction result in our found_room for next time.
else:
player_travel_request = requests.post('https://lambda-treasure-hunt.herokuapp.com/api/adv/move/', json={
"direction": move}, headers={'authorization': token}).json()
try:
# Create new room we just traveled into, and save the direction to the previous room.
new_found_room = RoomModel.find_by_id(
player_travel_request["room_id"])
new_room_id = player_travel_request['room_id']
if not new_found_room:
room_coordinates = re.findall(
r"\d+", player_travel_request['coordinates'])
avail_exits = {
"n": None if "n" not in player_travel_request["exits"] else "?",
"w": None if "w" not in player_travel_request["exits"] else "?",
"e": None if "e" not in player_travel_request["exits"] else "?",
"s": None if "s" not in player_travel_request["exits"] else "?",
}
new_room_data = {
"id": new_room_id,
"title": player_travel_request['title'],
"description": player_travel_request['description'],
"x": int(room_coordinates[0]),
"y": int(room_coordinates[1]),
"terrain": player_travel_request['terrain'],
"elevation": player_travel_request['elevation']
}
new_room_data.update(avail_exits)
new_found_room = RoomModel(**new_room_data)
setattr(new_found_room, opposite_dirs[move], str(
player_status_response["room_id"]))
setattr(found_room, move, new_room_id)
new_found_room.save_to_db()
found_room.save_to_db()
return player_travel_request, 200
except KeyError:
return player_travel_request, 400
else:
return {'error': True, 'message': 'There is no exit in that direction.'}, 400
def delete(self, id):
room = RoomModel.find_by_id(id)
if room:
room.delete_from_db()
return {'message': 'room has been deleted'}
def get(self, _id):
room = RoomModel.find_by_id(_id)
if room:
return room.json()
return {'message': 'Room not Found'}, 404
