def join_room_api(request):
# grab data from input json
try:
raw_data = parse_body_json_or_400(
request, required_keys=["room", "nickname", "password"])
except InvalidRequestJsonError as e:
return JsonResponse({"error": str(e)})
room = Room.get_for_encoded_uuid_or_404(raw_data["room"])
# use a JoinRoomForm to share validation with the regular path
form_data = JoinRoomForm.for_room(room).initial
form_data.update({
"player_name": raw_data["nickname"],
"passphrase": raw_data["password"],
"is_spectator": raw_data.get("is_specator", False),
})
join_form = JoinRoomForm(form_data)
if join_form.is_valid():
player = join_form.create_player()
_save_session_player(request.session, player)
return redirect("get_socket_key", encoded_room_uuid=room.encoded_uuid)
else:
return HttpResponse(join_form.errors.as_json(),
content_type="application/json",
status=400)
def get_socket_key(request, encoded_room_uuid):
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
player = _get_session_player(request.session, room)
data = {
"socket_key": _create_temporary_socket_key(player),
}
return JsonResponse(data)
def history(request):
hide_solo = request.GET.get('hide_solo')
if hide_solo:
base_rooms = Room.get_with_multiple_players()
else:
base_rooms = Room.objects.all()
room_list = base_rooms.order_by("-created_date")
paginator = Paginator(room_list, 10) # Show 25 contacts per page
page = request.GET.get('page')
try:
rooms = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
rooms = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
rooms = paginator.page(paginator.num_pages)
params = {
'hide_solo': hide_solo,
'rooms': rooms,
}
return render(request, "bingosync/history.html", params)
def rooms(request):
if request.method == "POST":
form = RoomForm(request.POST)
if form.is_valid():
room = form.create_room()
creator = room.creator
_save_session_player(request.session, creator)
return redirect("room_view", encoded_room_uuid=room.encoded_uuid)
else:
logger.warning("RoomForm errors: %r, custom_json was: %r",
form.errors,
form.data.get("custom_json", "")[:2000])
else:
form = RoomForm()
rooms = Room.get_listed_rooms()
any_idle_rooms = any(room.is_idle for room in rooms)
all_idle_rooms = all(room.is_idle for room in rooms)
params = {
"form": form,
"rooms": rooms,
"variants": ALL_VARIANTS,
"hide_idle_rooms": any_idle_rooms and not all_idle_rooms,
}
return render(request, "bingosync/index.html", params)
def room_view(request, encoded_room_uuid):
if request.method == "POST":
join_form = JoinRoomForm(request.POST)
if join_form.is_valid():
player = join_form.create_player()
_save_session_player(request.session, player)
return redirect("room_view", encoded_room_uuid=encoded_room_uuid)
else:
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
return _join_room(request, join_form, room)
else:
try:
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
initial_values = {
"game_type": room.current_game.game_type.group.value,
"variant_type": room.current_game.game_type.value,
"lockout_mode": room.current_game.lockout_mode.value,
"hide_card": room.hide_card,
}
new_card_form = RoomForm(initial=initial_values)
new_card_form.helper.layout = Layout(
"game_type",
"variant_type",
"custom_json",
"lockout_mode",
"seed",
"hide_card",
)
new_card_form.helper['variant_type'].wrap(Field,
wrapper_class='hidden')
new_card_form.helper['custom_json'].wrap(Field,
wrapper_class='hidden')
player = _get_session_player(request.session, room)
params = {
"room": room,
"game": room.current_game,
"player": player,
"sockets_url": SOCKETS_URL,
"new_card_form": new_card_form,
"temporary_socket_key": _create_temporary_socket_key(player)
}
return render(request, "bingosync/bingosync.html", params)
except NotAuthenticatedError:
join_form = JoinRoomForm.for_room(room)
return _join_room(request, join_form, room)
def select_color(request):
data = parse_body_json_or_400(request, required_keys=["room", "color"])
room = Room.get_for_encoded_uuid_or_404(data["room"])
player = _get_session_player(request.session, room)
color = Color.for_name(data["color"])
color_event = player.update_color(color)
publish_color_event(color_event)
return HttpResponse("Received data: ", str(data))
def board_revealed(request):
data = parse_body_json_or_400(request, required_keys=["room"])
room = Room.get_for_encoded_uuid_or_404(data["room"])
player = _get_session_player(request.session, room)
revealed_event = RevealedEvent(player=player, player_color_value=player.color.value)
revealed_event.save()
publish_revealed_event(revealed_event)
return HttpResponse("Received data: " + str(data))
def room_settings(request, encoded_room_uuid):
room = Room.get_for_encoded_uuid(encoded_room_uuid)
panel = loader.get_template("bingosync/room_settings_panel.html").render(
{
"game": room.current_game,
"room": room
}, request)
return JsonResponse({
"panel": panel,
"settings": room.settings
})
def chat_message(request):
data = parse_body_json_or_400(request, required_keys=["room", "text"])
room = Room.get_for_encoded_uuid_or_404(data["room"])
player = _get_session_player(request.session, room)
text = data["text"]
chat_event = ChatEvent(player=player, player_color_value=player.color.value, body=text)
chat_event.save()
publish_chat_event(chat_event)
return HttpResponse("Recieved data: " + str(data))
def new_card(request):
data = json.loads(request.body.decode("utf8"))
room = Room.get_for_encoded_uuid(data["room"])
player = _get_session_player(request.session, room)
lockout_mode = LockoutMode.for_value(int(data["lockout_mode"]))
hide_card = data["hide_card"]
seed = data["seed"]
custom_json = data.get("custom_json", "")
#create new game
game_type = GameType.for_value(int(data["game_type"]))
try:
# variant_type is not sent if the game only has 1 variant, so use it if
# it's present but fall back to the regular game_type otherwise
if "variant_type" in data:
game_type = GameType.for_value(int(data["variant_type"]))
except ValueError:
pass
generator = game_type.generator_instance()
try:
custom_board = generator.validate_custom_json(custom_json)
except InvalidBoardException as e:
return HttpResponseBadRequest("Invalid board: " + str(e))
if not seed:
seed = str(random.randint(1, 1000000)) if game_type.uses_seed else "0"
board_json = game_type.generator_instance().get_card(seed, custom_board)
with transaction.atomic():
game = Game.from_board(board_json,
room=room,
game_type_value=game_type.value,
lockout_mode_value=lockout_mode.value,
seed=seed)
if hide_card != room.hide_card:
room.hide_card = hide_card
room.update_active() # This saves the room
new_card_event = NewCardEvent(player=player,
player_color_value=player.color.value,
game_type_value=game_type.value,
seed=seed,
hide_card=hide_card)
new_card_event.save()
publish_new_card_event(new_card_event)
return HttpResponse("Recieved data: " + str(data))
def reconcile_connections(request):
connected_url = SOCKETS_PUBLISH_URL + "/connected"
response = requests.get(connected_url)
connected_rooms = response.json()
active_rooms = Room.get_listed_rooms()
for room in active_rooms:
connected_player_uuids = connected_rooms.get(room.encoded_uuid, [])
for player in room.connected_players:
if player.encoded_uuid not in connected_player_uuids:
ConnectionEvent.atomically_disconnect(player)
room.update_active()
return HttpResponse()
def goal_selected(request):
data = parse_body_json_or_400(request, required_keys=["room", "slot", "color", "remove_color"])
room = Room.get_for_encoded_uuid_or_404(data["room"])
player = _get_session_player(request.session, room)
game = room.current_game
slot = int(data["slot"])
color = Color.for_name(data["color"])
remove_color = data["remove_color"]
goal_event = game.update_goal(player, slot, color, remove_color)
if not goal_event:
return HttpResponseBadRequest("Blocked by Lockout")
publish_goal_event(goal_event)
return HttpResponse("Recieved data: " + str(data))
def room_feed(request, encoded_room_uuid):
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
# lookup the player to force authentication
_get_session_player(request.session, room)
events_to_return = []
all_included = True
if request.GET.get('full') == 'true':
events_to_return = Event.get_all_for_room(room)
else:
recent_events = Event.get_all_recent_for_room(room)
events_to_return = recent_events["events"]
all_included = recent_events["all_included"]
all_jsons = [event.to_json() for event in events_to_return]
return JsonResponse({'events': all_jsons, 'allIncluded': all_included}, safe=False)
def room_disconnect(request, encoded_room_uuid):
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
_clear_session_player(request.session, room)
return redirect("rooms")
def room_board(request, encoded_room_uuid):
room = Room.get_for_encoded_uuid_or_404(encoded_room_uuid)
board = room.current_game.board
return JsonResponse(board, safe=False)
