Implementing self-selected game

prijateli_tree/app/database.py

@@ -392,3 +392,28 @@ class GameSessionPlayer(Base):
     def language(self, db: Session = next(get_db())):
         user = db.query(User).filter_by(id=self.user_id).one()
         return db.query(Language).filter_by(id=user.language_id).one()
+
+
+class PlayerNetwork(Base):
+    __tablename__ = "player_networks"
+    id = Column(Integer, Identity(start=1, cycle=True), primary_key=True)
+    game_id = Column(
+        Integer,
+        ForeignKey("games.id", name="game_players_game_id_fkey"),
+        nullable=False,
+    )
+    player_id = Column(
+        Integer,
+        ForeignKey("game_players.id", name="game_players_player_id_fkey"),
+        nullable=False,
+    )
+    neighbor_id = Column(
+        Integer,
+        ForeignKey("game_players.id", name="game_players_neighbor_id_fkey"),
+        nullable=False,
+    )
+
+    player = relationship("GamePlayer", foreign_keys="PlayerNetwork.player_id")
+    neighbor = relationship(
+        "GamePlayer", foreign_keys="PlayerNetwork.neighbor_id"
+    )

prijateli_tree/app/routers/administration.py

@@ -36,6 +36,7 @@
     KEY_LOGIN_SECRET,
     NETWORK_TYPE_INTEGRATED,
     NETWORK_TYPE_SEGREGATED,
+    NETWORK_TYPE_SELF_SELECTED,
     NUMBER_OF_GAMES,
     NUMBER_OF_ROUNDS,
     ROLE_ADMIN,
@@ -384,6 +385,61 @@ def create_session_games(
         add_players_to_game(pos_players, game, db)
 
 
+def create_self_selected_games(
+    session,
+    game,
+    db: Session = Depends(get_db),
+) -> None:
+    """
+    Creates a self-selected game
+    """
+    for index in range(session.num_games):
+        previous_game = game
+        game_types = (
+            db.query(GameType)
+            .filter(
+                GameType.network.in_([NETWORK_TYPE_SELF_SELECTED]),
+                GameType.names_hidden.is_(False),
+            )
+            .all()
+        )
+        game_type = random.choice(game_types)
+        n_rounds = random.choice(ROUNDS_ARRAY)
+
+        # Add score
+        random_score = random.choices(WINNING_SCORES, weights=WINNING_WEIGHTS)[
+            0
+        ]
+
+        game = Game(
+            created_by=session.created_by,
+            game_session_id=session.id,
+            game_type_id=game_type.id,
+            rounds=n_rounds,
+            winning_score=random_score,
+        )
+
+        db.add(game)
+        db.commit()
+        db.refresh(game)
+
+        previous_game.next_game_id = game.id
+        db.commit()
+
+        # Sommething missing here about the network
+
+        # randomize location in network conditional on language
+        # one group is always in 1-2-3 and the other 4-5-6
+        group_1 = [p for p in previous_game.players if p.position in (1, 2, 3)]
+        random.shuffle(group_1)
+
+        group_2 = [p for p in previous_game.players if p.position in (4, 5, 6)]
+        random.shuffle(group_2)
+
+        pos_players = group_1 + group_2
+        add_players_to_game(pos_players, game, db)
+
+
 def add_players_to_game(pos_players: list[GamePlayer], game, db) -> None:
     """ """
     rand_bag = random.sample(game.game_type.bag, len(game.game_type.bag))

prijateli_tree/app/routers/games.py

@@ -3,6 +3,7 @@
 import logging
 from http import HTTPStatus
 from pathlib import Path
+from typing import Annotated
 
 from fastapi import APIRouter, Depends, Form, HTTPException, Request, Response
 from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
@@ -14,16 +15,22 @@
     GameAnswer,
     GamePlayer,
     GameSessionPlayer,
+    PlayerNetwork,
+    User,
     get_db,
 )
 from prijateli_tree.app.utils.constants import (
     DENAR_FACTOR,
     FILE_MODE_READ,
+    NETWORK_TYPE_INTEGRATED,
+    NETWORK_TYPE_SELF_SELECTED,
     POST_SURVEY_LINK,
     PRE_SURVEY_LINK,
     STANDARD_ENCODING,
 )
 from prijateli_tree.app.utils.games import (
+    GameUtil,
+    check_if_neighbors,
     did_player_win,
     get_bag_color,
     get_current_round,
@@ -131,6 +138,7 @@ def start_of_game(
         "points": game.winning_score,
         "text": template_text,
         "practice_game": game.practice,
+        "game_type": game.game_type.network,
     }
 
     return templates.TemplateResponse("start_of_game.html", result)
@@ -163,6 +171,15 @@ def view_round(
     }
     # Get current round
     if current_round == 1:
+        if game.game_type.network == NETWORK_TYPE_SELF_SELECTED:
+            neighbors_exist = check_if_neighbors(player_id, db)
+            if not neighbors_exist:
+                redirect_url = request.url_for(
+                    "choose_neighbors", game_id=game_id, player_id=player_id
+                )
+                return RedirectResponse(
+                    url=redirect_url, status_code=HTTPStatus.FOUND
+                )
         template_data["ball"] = player.initial_ball
     elif current_round > game.rounds:
         redirect_url = request.url_for(
@@ -179,6 +196,100 @@ def view_round(
     )
 
 
+@router.get("/{game_id}/player/{player_id}/choose_neighbors")
+def choose_neighbors(
+    request: Request,
+    game_id: int,
+    player_id: int,
+    db: Session = Depends(get_db),
+) -> Response:
+    """
+    Function that will allow each player to choose their neighbors
+    """
+    game, player = get_game_and_player(game_id, player_id, db)
+    template_text = languages[get_lang_from_player_id(player_id, db)]
+    header = get_header_data(player, db)
+
+    # Get number of neighbors the player has
+    # We just use  the integrated network to get the number of neighbors
+    game_util = GameUtil(NETWORK_TYPE_INTEGRATED)
+    num_neighbors = len(game_util.neighbors[player.position])
+
+    # Get the users of the players
+    user_ids = [p.user_id for p in game.players]
+
+    # Remove the current player from the list
+    user_ids.remove(player.user_id)
+
+    # Query users
+    users = db.query(User).filter(User.id.in_(user_ids)).all()
+
+    template_data = {
+        "text": template_text,
+        "player_id": player_id,
+        "game_id": game_id,
+        "num_neighbors": num_neighbors,
+        "students": users,
+        **header,
+    }
+
+    return templates.TemplateResponse(
+        "choose_neighbors.html", {"request": request, **template_data}
+    )
+
+
+@router.post("/{game_id}/player/{player_id}/add_neighbors")
+def add_neighbors(
+    request: Request,
+    game_id: int,
+    player_id: int,
+    player_one: Annotated[int, Form()],
+    player_two: Annotated[int, Form()],
+    player_three: Annotated[int, Form()] | None = Form(None),
+    db: Session = Depends(get_db),
+) -> RedirectResponse:
+    """
+    Function that will add the neighbors to the database
+    """
+    # Get the players
+    neighbor_player_ids = []
+    for user_id in [player_one, player_two, player_three]:
+        if user_id is not None:
+            neighbor_player_ids.append(
+                db.query(GamePlayer)
+                .filter_by(user_id=user_id, game_id=game_id)
+                .one_or_none()
+                .id
+            )
+
+    if len(set(neighbor_player_ids)) != len(neighbor_player_ids):
+        # Do not let them move forward if neighbor is duplicated
+        redirect_url = request.url_for(
+            "choose_neighbors", game_id=game_id, player_id=player_id
+        )
+
+        return RedirectResponse(
+            url=redirect_url,
+            status_code=HTTPStatus.FOUND,
+        )
+
+    for neighbor_id in neighbor_player_ids:
+        new_neighbor = PlayerNetwork(
+            game_id=game_id,
+            player_id=player_id,
+            neighbor_id=neighbor_id,
+        )
+        db.add(new_neighbor)
+        db.commit()
+        db.refresh(new_neighbor)
+
+    redirect_url = request.url_for(
+        "view_round", game_id=game_id, player_id=player_id
+    )
+
+    return RedirectResponse(url=redirect_url, status_code=HTTPStatus.SEE_OTHER)
+
+
 @router.post("/{game_id}/player/{player_id}/answer")
 def route_add_answer(
     request: Request,
@@ -424,7 +535,6 @@ def go_to_next_game(
     game, player = get_game_and_player(game_id, player_id, db)
 
     if game.next_game_id is None:
-        # TODO: end of session screen
         redirect_url = request.url_for(
             "get_qualtrics", game_id=game_id, player_id=player_id
         )
@@ -445,7 +555,6 @@ def go_to_next_game(
     if game.practice:
         # Check if next game is practice
         next_game = db.query(Game).filter_by(id=game.next_game_id).one()
-        # If next game is NOT practice
         if not next_game.practice:
             # Show end of practice screen
             redirect_url = request.url_for(
@@ -454,12 +563,6 @@ def go_to_next_game(
                 player_id=next_player_id,
             )
 
-            return RedirectResponse(
-                redirect_url,
-                status_code=HTTPStatus.FOUND,
-            )
-
-    # next_player_id
     redirect_url = request.url_for(
         "start_of_game",
         game_id=game.next_game_id,
@@ -486,21 +589,20 @@ def real_game_transition(
     Function that returns the start of game page and
     template.
     """
-    game, player = get_game_and_player(game_id, player_id, db)
+    _, player = get_game_and_player(game_id, player_id, db)
     header = get_header_data(player, db)
     template_text = languages[get_lang_from_player_id(player_id, db)]
 
     result = {
         "request": request,
         "player_id": player_id,
         "game_id": game_id,
-        "points": game.winning_score,
         "text": template_text,
         "completed_game": True,
         **header,
     }
 
-    return templates.TemplateResponse("real_game_transition.html", result)
+    return templates.TemplateResponse("self_selected_intro.html", result)
 
 
 @router.get(

prijateli_tree/app/templates/choose_neighbors.html

@@ -0,0 +1,74 @@
+{% extends "base.html" %}
+{% block title %}
+  PrijateliTree - Choose Neighbors
+{% endblock title %}
+{% block helper_script %}
+  <script>
+    fetch('{{ url_for("create_session") }}', {
+          method: 'POST',
+          body: formData
+        })
+      .then(resp => {
+        window.location.href = resp.url
+      }) // or, resp.text(), etc
+      .catch(error => {
+          console.error(error);
+      });
+    function cleanParams() {
+      // Used to clear the URL of parameters after the banner alert is closed.
+      window.history.replaceState(null, '', window.location.pathname);
+    }
+  </script>
+{% endblock helper_script %}
+{% block content %}
+  {% if error %}
+    <div class="alert alert-danger alert-dismissible fade show" role="alert">
+      <strong>ERROR:</strong> {{ error }}
+      <button type="button"
+              class="btn-close"
+              data-bs-dismiss="alert"
+              aria-label="Close"
+              onclick="cleanParams()"></button>
+    </div>
+  {% endif %}
+  <div class="container-sm general-container">
+    <h3 style="margin-bottom: 40px;">
+      {{ text.different_game_choices.please_choose_players | replace('{X}', num_neighbors) }}
+    </h3>
+    <div class="row justify-content-center">
+      <!-- Added row and justify-content-center classes -->
+      <div class="col-sm-4">
+        <form method="post"
+              action='{{ url_for("add_neighbors", game_id=game_id, player_id=player_id) }}'>
+          <div class="mb-3 row">
+            <label for="pos-one" class="col-sm-4 form-label">{{ text.util.player }} 1</label>
+            <div class="col-sm-8">
+              <select id="pos-one" class="form-select form-select-sm" name="player_one">
+                {% for s in students|sort(attribute='last_name') %}<option value="{{ s.id }}">{{ s.name_str }}</option>{% endfor %}
+              </select>
+            </div>
+          </div>
+          <div class="mb-3 row">
+            <label for="pos-two" class="col-sm-4 form-label">{{ text.util.player }} 2</label>
+            <div class="col-sm-8">
+              <select id="pos-two" class="form-select form-select-sm" name="player_two">
+                {% for s in students|sort(attribute='last_name') %}<option value="{{ s.id }}">{{ s.name_str }}</option>{% endfor %}
+              </select>
+            </div>
+          </div>
+          {% if num_neighbors > 2 %}
+            <div class="mb-3 row">
+              <label for="pos-three" class="col-sm-4 form-label">{{ text.util.player }} 3</label>
+              <div class="col-sm-8">
+                <select id="pos-three" class="form-select form-select-sm" name="player_three">
+                  {% for s in students|sort(attribute='last_name') %}<option value="{{ s.id }}">{{ s.name_str }}</option>{% endfor %}
+                </select>
+              </div>
+            </div>
+          {% endif %}
+          <button type="submit" class="btn btn-primary float-end">{{ text.ready_to_play.im_ready }}</button>
+        </form>
+      </div>
+    </div>
+  </div>
+{% endblock content %}

prijateli_tree/app/templates/start_of_game.html

@@ -8,6 +8,9 @@
       <h1>
         {% if practice_game %}
           {{ text.intro_practice.now_you_will_play }}
+        {% elif game_type == "self-selected" %}
+          {{ text.different_game_intro.different_version }}
+          {{ text.different_game_intro.instead_of }}
         {% else %}
           {{ text.ready_to_play.get_ready }}
         {% endif %}