async def clone_location(sid: str, data: LocationCloneData):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(f"{pr.player.name} attempted to clone locations.")
return
try:
room = Room.select().where((Room.name == data["room"])
& (Room.creator == pr.player))[0]
except IndexError:
logger.warning(f"Destination room {data['room']} not found.")
return
src_location = Location.get_by_id(data["location"])
new_location = Location.create(room=room,
name=src_location.name,
index=room.locations.count())
new_groups = {}
for prev_floor in src_location.floors.order_by(Floor.index):
new_floor = new_location.create_floor(prev_floor.name)
for prev_layer in prev_floor.layers:
new_layer = new_floor.layers.where(
Layer.name == prev_layer.name).get()
for src_shape in prev_layer.shapes:
new_group = None
if src_shape.group:
group_id = src_shape.group.uuid
if group_id not in new_groups:
new_groups[group_id] = src_shape.group.make_copy()
new_group = new_groups[group_id]
src_shape.make_copy(new_layer, new_group)
def start_game(room_code):
sessid = request.cookies.get("sessid")
room = Room.select(Room).join(Player, on=Room.owner).where(Player.sessid == sessid, Room.code == room_code).get()
init_game(room)
message_data = {"url": "/game/%s" % room_code}
post_message([Msg("start", message_data)], room=room)
return redirect("/game/%s" % room_code)
async def connect(sid, environ):
user = await authorized_userid(environ["aiohttp.request"])
if user is None:
await sio.emit("redirect", "/", room=sid, namespace=GAME_NS)
return
ref = {
k.split("=")[0]: k.split("=")[1]
for k in unquote(environ["QUERY_STRING"]).strip().split("&")
}
try:
room = (
Room.select().join(User).where((Room.name == ref["room"])
& (User.name == ref["user"]))[0])
except IndexError:
return False
else:
for pr in room.players:
if pr.player == user:
if pr.role != Role.DM and room.is_locked:
return False
break
else:
return False
pr = PlayerRoom.get(room=room, player=user)
await game_state.add_sid(sid, pr)
logger.info(f"User {user.name} connected with identifier {sid}")
sio.enter_room(sid, pr.active_location.get_path(), namespace=GAME_NS)
def get(self):
fields = self.get_only_fields()
roomsset = Room.select()
rooms = map(lambda room: model_to_dict(
room,
append_attrs={'url': self.reverse_url('room', room.id)},
only=fields
), roomsset)
self.set_response(dict(rooms=rooms))
async def connect(sid, environ):
user = await authorized_userid(environ["aiohttp.request"])
if user is None:
await sio.emit("redirect", "/", room=sid, namespace="/planarally")
else:
ref = unquote(environ["HTTP_REFERER"]).strip("/").split("/")
room = (Room.select().join(User).where((Room.name == ref[-1])
& (User.name == ref[-2]))[0])
if room.creator == user:
location = Location.get(room=room, name=room.dm_location)
else:
location = Location.get(room=room, name=room.player_location)
state.add_sid(sid, user=user, room=room, location=location)
logger.info(f"User {user.name} connected with identifier {sid}")
sio.enter_room(sid, location.get_path(), namespace="/planarally")
await sio.emit("Username.Set",
user.name,
room=sid,
namespace="/planarally")
await sio.emit(
"Room.Info.Set",
{
"name": room.name,
"creator": room.creator.name,
"invitationCode": str(room.invitation_code),
},
room=sid,
namespace="/planarally",
)
await sio.emit(
"Notes.Set",
[
note.as_dict()
for note in Note.select().where((Note.user == user)
& (Note.room == room))
],
room=sid,
namespace="/planarally",
)
await sio.emit(
"Asset.List.Set",
Asset.get_user_structure(user),
room=sid,
namespace="/planarally",
)
await load_location(sid, location)
async def show_room(request):
user = await check_authorized(request)
creator = User.by_name(request.match_info["username"])
try:
room = Room.select().where((Room.creator == creator) & (
Room.name == request.match_info["roomname"]))[0]
except IndexError:
logger.info(
f"{user.name} attempted to load non existing room {request.match_info['username']}/{request.match_info['roomname']}"
)
else:
for pr in room.players:
if pr.user == user:
return {"dm": pr.role == Role.DM}
return web.HTTPFound("/rooms")
async def connect(sid, environ):
user = await authorized_userid(environ["aiohttp.request"])
if user is None:
await sio.emit("redirect", "/", room=sid, namespace="/planarally")
else:
# ref = unquote(environ["HTTP_REFERER"]).strip("/").split("/")
ref = {
k.split("=")[0]: k.split("=")[1]
for k in unquote(environ["QUERY_STRING"]).strip().split("&")
}
try:
room = (Room.select().join(User).where(
(Room.name == ref["room"]) & (User.name == ref["user"]))[0])
except IndexError:
return False
if room.creator == user:
location = Location.get(room=room, name=room.dm_location)
else:
location = Location.get(room=room, name=room.player_location)
state.add_sid(sid, user=user, room=room, location=location)
logger.info(f"User {user.name} connected with identifier {sid}")
sio.enter_room(sid, location.get_path(), namespace="/planarally")
await sio.emit("Username.Set",
user.name,
room=sid,
namespace="/planarally")
await sio.emit(
"Room.Info.Set",
{
"name": room.name,
"creator": room.creator.name,
"invitationCode": str(room.invitation_code),
},
room=sid,
namespace="/planarally",
)
await sio.emit(
"Asset.List.Set",
Asset.get_user_structure(user),
room=sid,
namespace="/planarally",
)
await load_location(sid, location)
async def show_room(request):
user = await check_authorized(request)
creator = User.by_name(request.match_info["username"])
try:
room = (Room.select().join(User).where(
(Room.creator == creator)
& (Room.name == request.match_info["roomname"]))[0])
except IndexError:
logger.info(
f"{user.name} attempted to load non existing room {request.match_info['username']}/{request.match_info['roomname']}"
)
else:
if room.creator == user:
return {"dm": True}
if user.name.lower() in (pr.player.name.lower()
for pr in room.players.select().join(User)):
return {"dm": False}
return web.HTTPFound("/rooms")
def get(self, customer_id):
fields = self.get_only_fields()
try:
rooms = Room.select().join(Booking).where(Booking.customer_id == customer_id)
rooms = map(lambda item: model_to_dict(
item,
append_attrs={'url': self.reverse_url('room', item.id)},
exclude=[Booking.customer]),
rooms)
customer = model_to_dict(
Customer.get(id=customer_id),
append_attrs=dict(rooms=rooms),
only=fields)
self.set_response(dict(customer=customer))
except Customer.DoesNotExist:
self.set_response(
{'message': 'A customer with id #{} not found'.format(customer_id)},
status=404)
def join():
"""
Route invoked when a new player joins the room.
Adds player to the room and sets his session cookie.
Posts the join message to other players in the room.
"""
username = request.forms.get("username")
if len(username) == 0:
return HTTPError(403, "Username too short")
room_code = request.forms.get("room").upper()
try:
room = Room.select(Room).where(Room.code == room_code).get()
except Room.DoesNotExist:
return HTTPError(404, "Room does not exist")
sessid = request.cookies.get("sessid", generate_sessid())
player, created = Player.get_or_create(sessid=sessid, room=room, defaults={"name": username})
if created:
message_data = {"player": {"id": player.id, "name": player.name}}
post_message([Msg("join", message_data)], room=room)
response.set_cookie("sessid", sessid, path="/")
return redirect("/game/%s/lobby" % room.code)
import peewee
from models import Room, Booking
print("\n")
print("Printing all rooms in BM on floor 4:")
rooms = Room.select().where((Room.building == "BM") & (Room.floor == 4))
for r in rooms:
print(r.name)
print('\n')
print('Printing all bookings (with room name!):')
bookings = Booking.select()
print("{} bookings found.".format(len(bookings)))
for b in bookings:
print(b.who, b.when, b.room.name)
# print('\n')
# print('Making a new booking:')
# new_booking = Booking(who="Serhii", when="2020-04-07", room=2)
# try:
# new_booking.save()
# except:
# print("Something went wrong with making new booking.")
# raise
# print('\n')
# print('Deleting all bookings by Serhii:')
# query = Booking.delete().where(Booking.who=="Serhii")
# query.execute()
async def connect(sid, environ):
user = await authorized_userid(environ["aiohttp.request"])
if user is None:
await sio.emit("redirect", "/", room=sid, namespace="/planarally")
else:
ref = {
k.split("=")[0]: k.split("=")[1]
for k in unquote(environ["QUERY_STRING"]).strip().split("&")
}
try:
room = (
Room.select()
.join(User)
.where((Room.name == ref["room"]) & (User.name == ref["user"]))[0]
)
except IndexError:
return False
else:
for pr in room.players:
if pr.player == user:
if pr.role != Role.DM and room.is_locked:
return False
break
else:
return False
pr = PlayerRoom.get(room=room, player=user)
# todo: just store PlayerRoom as it has all the info
await game_state.add_sid(sid, pr)
logger.info(f"User {user.name} connected with identifier {sid}")
labels = Label.select().where((Label.user == user) | (Label.visible == True))
label_filters = LabelSelection.select().where(
(LabelSelection.user == user) & (LabelSelection.room == room)
)
sio.enter_room(sid, pr.active_location.get_path(), namespace="/planarally")
await sio.emit("Username.Set", user.name, room=sid, namespace="/planarally")
await sio.emit(
"Labels.Set",
[l.as_dict() for l in labels],
room=sid,
namespace="/planarally",
)
await sio.emit(
"Labels.Filters.Set",
[l.label.uuid for l in label_filters],
room=sid,
namespace="/planarally",
)
await sio.emit(
"Room.Info.Set",
{
"name": room.name,
"creator": room.creator.name,
"invitationCode": str(room.invitation_code),
"isLocked": room.is_locked,
"default_options": room.default_options.as_dict(),
"players": [
{
"id": rp.player.id,
"name": rp.player.name,
"location": rp.active_location.id,
}
for rp in room.players
],
},
room=sid,
namespace="/planarally",
)
await sio.emit(
"Asset.List.Set",
Asset.get_user_structure(user),
room=sid,
namespace="/planarally",
)
if pr.role == Role.DM:
await sio.emit(
"Locations.Settings.Set",
{
l.name: {} if l.options is None else l.options.as_dict()
for l in pr.room.locations
},
room=sid,
namespace="/planarally",
)
await load_location(sid, pr.active_location)
async def connect(sid, environ):
user = await authorized_userid(environ["aiohttp.request"])
if user is None:
await sio.emit("redirect", "/", room=sid, namespace="/planarally")
else:
ref = {
k.split("=")[0]: k.split("=")[1]
for k in unquote(environ["QUERY_STRING"]).strip().split("&")
}
try:
room = (Room.select().join(User).where(
(Room.name == ref["room"]) & (User.name == ref["user"]))[0])
except IndexError:
return False
else:
if user != room.creator and (
user not in [pr.player
for pr in room.players] or room.is_locked):
return False
if room.creator == user:
location = Location.get(room=room, name=room.dm_location)
else:
location = Location.get(room=room, name=room.player_location)
state.add_sid(sid, user=user, room=room, location=location)
logger.info(f"User {user.name} connected with identifier {sid}")
labels = Label.select().where((Label.user == user)
| (Label.visible == True))
label_filters = LabelSelection.select().where(
(LabelSelection.user == user) & (LabelSelection.room == room))
sio.enter_room(sid, location.get_path(), namespace="/planarally")
await sio.emit("Username.Set",
user.name,
room=sid,
namespace="/planarally")
await sio.emit(
"Labels.Set",
[l.as_dict() for l in labels],
room=sid,
namespace="/planarally",
)
await sio.emit(
"Labels.Filters.Set",
[l.label.uuid for l in label_filters],
room=sid,
namespace="/planarally",
)
await sio.emit(
"Room.Info.Set",
{
"name":
room.name,
"creator":
room.creator.name,
"invitationCode":
str(room.invitation_code),
"isLocked":
room.is_locked,
"players": [{
"id": rp.player.id,
"name": rp.player.name
} for rp in room.players],
},
room=sid,
namespace="/planarally",
)
await sio.emit(
"Asset.List.Set",
Asset.get_user_structure(user),
room=sid,
namespace="/planarally",
)
await load_location(sid, location)
# ["BP4117",4,"BP",],
# ["BP4116",4,"BP",],
# ["BP4115",4,"BP",],
# ["BP4114",4,"BP",],
# ["BP4113",4,"BP",],
# ["BP5118",5,"BP",],
# ["BP5117",5,"BP",],
# ["BP5116",5,"BP",],
# ["BP5115",5,"BP",],
# ["BP5114",5,"BP",],
# ["BP5113",5,"BP",],
# ]
# for ri in rs:
# r = Room(name=ri[0], floor=ri[1], building=ri[2])
# try:
# r.save()
# print("Success!")
# except peewee.IntegrityError:
# pass
# b = Booking(who="David", when="2020-04-05", room=1)
# b.save()
r = Room.select()
print(len(r))
bb = Booking.select()
print(len(bb))
b = bb[0]
print(b.who, b.when, b.room.name)
