wip invalidate cache when room is finished

slug is another term in our app
this is the room id

.github/workflows/deploy.yml

@@ -11,17 +11,34 @@ jobs:
   notify-argocd:
     runs-on: ubuntu-latest
     steps:
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: "meet,secrets"
       -
         name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Load sops secrets
+        uses: rouja/actions-sops@main
+        with:
+          secret-file: secrets/numerique-gouv/meet/secrets.enc.env
+          age-key: ${{ secrets.SOPS_PRIVATE }}
       -
         name: Call argocd github webhook
         run: |
           data='{"ref": "'$GITHUB_REF'","repository": {"html_url":"'$GITHUB_SERVER_URL'/'$GITHUB_REPOSITORY'"}}'
-          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac ''${{ secrets.ARGOCD_WEBHOOK_SECRET }}'' | awk '{print "X-Hub-Signature: sha1="$2}')
-          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" ${{ vars.ARGOCD_WEBHOOK_URL }}
-          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac ''${{ secrets.ARGOCD_PRODUCTION_WEBHOOK_SECRET }}'' | awk '{print "X-Hub-Signature: sha1="$2}')
-          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" ${{ secrets.ARGOCD_PRODUCTION_WEBHOOK_URL }}
+          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac ''${ARGOCD_WEBHOOK_SECRET}'' | awk '{print "X-Hub-Signature: sha1="$2}')
+          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" $ARGOCD_WEBHOOK_URL
+          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac ''${ARGOCD_PRODUCTION_WEBHOOK_SECRET}'' | awk '{print "X-Hub-Signature: sha1="$2}')
+          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" $ARGOCD_PRODUCTION_WEBHOOK_URL
 
   start-test-on-preprod:
     needs:

.github/workflows/docker-hub.yml

@@ -19,9 +19,26 @@ jobs:
   build-and-push-backend:
     runs-on: ubuntu-latest
     steps:
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: "meet,secrets"
       -
         name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Load sops secrets
+        uses: rouja/actions-sops@main
+        with:
+          secret-file: secrets/numerique-gouv/meet/secrets.enc.env
+          age-key: ${{ secrets.SOPS_PRIVATE }}
       -
         name: Docker meta
         id: meta
@@ -31,7 +48,7 @@ jobs:
       -
         name: Login to DockerHub
         if: github.event_name != 'pull_request'
-        run: echo "${{ secrets.DOCKER_HUB_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_HUB_USER }}" --password-stdin
+        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
       -
         name: Run trivy scan
         uses: numerique-gouv/action-trivy-cache@main
@@ -52,9 +69,26 @@ jobs:
   build-and-push-frontend:
     runs-on: ubuntu-latest
     steps:
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: "meet,secrets"
       -
         name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Load sops secrets
+        uses: rouja/actions-sops@main
+        with:
+          secret-file: secrets/numerique-gouv/meet/secrets.enc.env
+          age-key: ${{ secrets.SOPS_PRIVATE }}
       -
         name: Docker meta
         id: meta
@@ -64,7 +98,7 @@ jobs:
       -
         name: Login to DockerHub
         if: github.event_name != 'pull_request'
-        run: echo "${{ secrets.DOCKER_HUB_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_HUB_USER }}" --password-stdin
+        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
       -
         name: Run trivy scan
         uses: numerique-gouv/action-trivy-cache@main
@@ -86,9 +120,26 @@ jobs:
   build-and-push-summary:
     runs-on: ubuntu-latest
     steps:
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: "meet,secrets"
       -
         name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Load sops secrets
+        uses: rouja/actions-sops@main
+        with:
+          secret-file: secrets/numerique-gouv/meet/secrets.enc.env
+          age-key: ${{ secrets.SOPS_PRIVATE }}
       -
         name: Docker meta
         id: meta
@@ -98,7 +149,7 @@ jobs:
       -
         name: Login to DockerHub
         if: github.event_name != 'pull_request'
-        run: echo "${{ secrets.DOCKER_HUB_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_HUB_USER }}" --password-stdin
+        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
       -
         name: Build and push
         uses: docker/build-push-action@v6
@@ -111,20 +162,39 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
+
   notify-argocd:
     needs:
       - build-and-push-frontend
       - build-and-push-backend
       - build-and-push-summary
     runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
+    if: |
+      github.event_name != 'pull_request'
     steps:
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: "meet,secrets"
       -
         name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Load sops secrets
+        uses: rouja/actions-sops@main
+        with:
+          secret-file: secrets/numerique-gouv/meet/secrets.enc.env
+          age-key: ${{ secrets.SOPS_PRIVATE }}
       -
         name: Call argocd github webhook
         run: |
-          data='{"ref": "'$GITHUB_REF'","repository": {"html_url":"'$GITHUB_SERVER_URL'/numerique-gouv/lasuite-deploiement"}}'
-          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac "${{ secrets.ARGOCD_PREPROD_WEBHOOK_SECRET }}" | awk '{print "X-Hub-Signature: sha1="$2}')
-          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" ${{ vars.ARGOCD_PREPROD_WEBHOOK_URL }}
+          data='{"ref": "'$GITHUB_REF'","repository": {"html_url":"'$GITHUB_SERVER_URL'/'$GITHUB_REPOSITORY'"}}'
+          sig=$(echo -n ${data} | openssl dgst -sha1 -hmac ''${ARGOCD_WEBHOOK_SECRET}'' | awk '{print "X-Hub-Signature: sha1="$2}')
+          curl -X POST -H 'X-GitHub-Event:push' -H "Content-Type: application/json" -H "${sig}" --data "${data}" $ARGOCD_WEBHOOK_URL

.github/workflows/helmfile-linter.yml

@@ -0,0 +1,22 @@
+name: Helmfile lint
+run-name: Helmfile lint
+
+on:
+  pull_request:
+    branches:
+      - 'main'
+
+jobs:
+  helmfile-lint:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/helmfile/helmfile:latest
+    steps:
+      -
+        uses: numerique-gouv/action-helmfile-lint@main
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          age-key: ${{ secrets.SOPS_PRIVATE }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+          helmfile-src: "src/helm"
+          repositories: "meet,secrets"

.github/workflows/meet.yml

@@ -81,7 +81,7 @@ jobs:
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.10"
       - name: Install development dependencies
         run: pip install --user .[dev]
       - name: Check code formatting with ruff
@@ -110,16 +110,6 @@ jobs:
           - 5432:5432
         # needed because the postgres container does not provide a healthcheck
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
-      redis:
-        image: redis:5
-        ports:
-          - 6379:6379
-        # Set health checks to wait until redis has started
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
 
     env:
       DJANGO_CONFIGURATION: Test
@@ -131,7 +121,6 @@ jobs:
       DB_USER: dinum
       DB_PASSWORD: pass
       DB_PORT: 5432
-      REDIS_URL: redis://localhost:6379/1
       STORAGES_STATICFILES_BACKEND: django.contrib.staticfiles.storage.StaticFilesStorage
       LIVEKIT_API_SECRET: secret
       LIVEKIT_API_KEY: devkey
@@ -155,7 +144,7 @@ jobs:
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.10"
 
       - name: Install development dependencies
         run: pip install --user .[dev]
@@ -186,56 +175,25 @@ jobs:
       - name: Check format
         run: cd src/frontend/ && npm run check
 
-  lint-sdk:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: src/sdk/library
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Check linting
-        run: npm run lint
-
-      - name: Check format
-        run: npm run check
-
-  build-sdk:
-    runs-on: ubuntu-latest
-    needs: lint-sdk
-    defaults:
-      run:
-        working-directory: src/sdk/library
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build SDK
-        run: npm run build
-
   i18n-crowdin:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/create-github-app-token@v1
+      -
+        uses: actions/create-github-app-token@v1
         id: app-token
         with:
           app-id: ${{ secrets.APP_ID }}
           private-key: ${{ secrets.PRIVATE_KEY }}
           owner: ${{ github.repository_owner }}
           repositories: "infrastructure,secrets"
-      - name: Checkout repository
+      -
+        name: Checkout repository
         uses: actions/checkout@v4
         with:
           submodules: recursive
           token: ${{ steps.app-token.outputs.token }}
-      - name: Load sops secrets
+      -
+        name: Load sops secrets
         uses: rouja/actions-sops@main
         with:
           secret-file: secrets/numerique-gouv/meet/secrets.enc.env
@@ -249,7 +207,7 @@ jobs:
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.10"
 
       - name: Install development dependencies
         working-directory: src/backend

.github/workflows/release-helm-chart.yaml

@@ -1,33 +0,0 @@
-name: Release Chart
-run-name: Release Chart
-
-on:
-  push:
-    paths:
-      - src/helm/meet/**
-
-jobs:
-  release:
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Cleanup
-        run: rm -rf ./src/helm/extra
-
-      - name: Install Helm
-        uses: azure/setup-helm@v4
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-
-      - name: Publish Helm charts
-        uses: numerique-gouv/helm-gh-pages@add-overwrite-option
-        with:
-          charts_dir: ./src/helm
-          linting: on
-          token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -79,6 +79,3 @@ db.sqlite3
 
 # Egress output
 docker/livekit/out
-
-# LiveKit CA configuration
-docker/livekit/rootCA.pem

CHANGELOG.md

@@ -1,4 +1,3 @@
-
 # Changelog
 
 All notable changes to this project will be documented in this file.

Makefile

@@ -301,10 +301,6 @@ build-k8s-cluster: ## build the kubernetes cluster using kind
 	./bin/start-kind.sh
 .PHONY: build-k8s-cluster
 
-install-external-secrets: ## install the kubernetes secrets from Vaultwarden
-	./bin/install-external-secrets.sh
-.PHONY: build-k8s-cluster
-
 start-tilt: ## start the kubernetes cluster using kind
 	tilt up -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster

bin/Tiltfile

@@ -1,10 +1,6 @@
 load('ext://uibutton', 'cmd_button', 'bool_input', 'location')
 load('ext://namespace', 'namespace_create', 'namespace_inject')
 namespace_create('meet')
-
-def clean_old_images(image_name):
-    local('docker images -q %s | tail -n +2 | xargs -r docker rmi' % image_name)
-
 docker_build(
     'localhost:5001/meet-backend:latest',
     context='..',
@@ -19,7 +15,6 @@ docker_build(
         )
     ]
 )
-clean_old_images('localhost:5001/meet-backend')
 
 docker_build(
     'localhost:5001/meet-frontend:latest',
@@ -31,7 +26,6 @@ docker_build(
         sync('../src/frontend', '/home/frontend'),
     ]
 )
-clean_old_images('localhost:5001/meet-frontend')
 
 docker_build(
     'localhost:5001/meet-summary:latest',
@@ -43,24 +37,6 @@ docker_build(
         sync('../src/summary', '/home/summary'),
     ]
 )
-clean_old_images('localhost:5001/meet-summary')
-
-# Copy the mkcert root CA certificate to our Docker build context
-# This is necessary because we need to inject the certificate into our LiveKit container
-local_resource(
-    'copy-root-ca',
-    cmd='cp "$(mkcert -CAROOT)/rootCA.pem" ../docker/livekit/rootCA.pem',
-    deps=[],  # No dependencies needed
-)
-# Build a custom LiveKit Docker image that includes our root CA certificate
-# This allows LiveKit to trust our local development certificates
-docker_build(
-    'localhost:5001/meet-livekit:latest',
-    context='../docker/livekit',
-    dockerfile='./../docker/livekit/Dockerfile',
-    only=['.'],
-)
-clean_old_images('localhost:5001/meet-livekit')
 
 k8s_yaml(local('cd ../src/helm && helmfile -n meet -e ${DEV_ENV:-dev} template .'))
 

bin/install-external-secrets.sh

@@ -1,90 +0,0 @@
-#!/usr/bin/env bash
-set -o errexit
-
-CURRENT_DIR=$(pwd)
-NAMESPACE=${1:-meet}
-SECRET_NAME=${2:-bitwarden-cli-meet}
-TEMP_SECRET_FILE=$(mktemp)
-
-
-cleanup() {
-    rm -f "${TEMP_SECRET_FILE}"
-}
-trap cleanup EXIT
-
-
-# Check if kubectl is available
-check_prerequisites() {
-    if ! command -v kubectl &> /dev/null; then
-        echo "Error: kubectl is not installed or not in PATH"
-        exit 1
-    fi
-}
-
-# Check if secret already exists
-check_secret_exists() {
-    kubectl -n "${NAMESPACE}" get secrets "${SECRET_NAME}" &> /dev/null
-}
-
-
-# Collect user input securely
-get_user_input() {
-    echo "Please provide the following information:"
-    read -p "Enter your Vaultwarden email login: " LOGIN
-    read -s -p "Enter your Vaultwarden password: " PASSWORD
-    echo
-    read -p "Enter your Vaultwarden server url: " URL
-}
-
-# Create and apply the secret
-create_secret() {
-    cat > "${TEMP_SECRET_FILE}" << EOF
-apiVersion: v1
-kind: Secret
-metadata:
-  name: ${SECRET_NAME}
-  namespace: ${NAMESPACE}
-type: Opaque
-stringData:
-  BW_HOST: ${URL}
-  BW_PASSWORD: ${PASSWORD}
-  BW_USERNAME: ${LOGIN}
-EOF
-
-    kubectl -n "${NAMESPACE}" apply -f "${TEMP_SECRET_FILE}"
-}
-
-# Install external-secrets using Helm
-install_external_secrets() {
-    if ! kubectl get ns external-secrets &>/dev/null; then
-        echo "Installing external-secrets…"
-        helm repo add external-secrets https://charts.external-secrets.io
-        helm upgrade --install external-secrets \
-            external-secrets/external-secrets \
-            -n external-secrets \
-            --create-namespace \
-            --set installCRDs=true
-    else
-        echo "External secrets already deployed"
-    fi
-}
-
-main() {
-    check_prerequisites
-
-    if check_secret_exists; then
-        echo "Secret '${SECRET_NAME}' already present in namespace '${NAMESPACE}'"
-        exit 0
-    fi
-
-    echo -e ${TEMP_SECRET_FILE}
-
-    get_user_input
-    echo -e "\nCreating Vaultwarden secret…"
-    create_secret
-    install_external_secrets
-
-    echo "Secret installation completed successfully"
-}
-
-main "$@"

bin/install-hooks.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 mkdir -p "$(dirname -- "${BASH_SOURCE[0]}")/../.git/hooks/"
 PRE_COMMIT_FILE="$(dirname -- "${BASH_SOURCE[0]}")/../.git/hooks/pre-commit"

bin/start-kind.sh

@@ -1,3 +1,139 @@
-#!/usr/bin/env bash
+#!/bin/sh
+set -o errexit
 
-curl https://raw.githubusercontent.com/numerique-gouv/tools/refs/heads/main/kind/create_cluster.sh | bash -s -- meet
+CURRENT_DIR=$(pwd)
+
+echo "0. Create ca"
+# 0. Create ca
+mkcert -install
+cd /tmp
+mkcert "127.0.0.1.nip.io" "*.127.0.0.1.nip.io"
+cd $CURRENT_DIR
+
+echo "1. Create registry container unless it already exists"
+# 1. Create registry container unless it already exists
+reg_name='kind-registry'
+reg_port='5001'
+if [ "$(docker inspect -f '{{.State.Running}}' "${reg_name}" 2>/dev/null || true)" != 'true' ]; then
+	docker run \
+		-d --restart=always -p "127.0.0.1:${reg_port}:5000" --network bridge --name "${reg_name}" \
+		registry:2
+fi
+
+echo "2. Create kind cluster with containerd registry config dir enabled"
+# 2. Create kind cluster with containerd registry config dir enabled
+# TODO: kind will eventually enable this by default and this patch will
+# be unnecessary.
+#
+# See:
+# https://github.com/kubernetes-sigs/kind/issues/2875
+# https://github.com/containerd/containerd/blob/main/docs/cri/config.md#registry-configuration
+# See: https://github.com/containerd/containerd/blob/main/docs/hosts.md
+cat <<EOF | kind create cluster --name visio --config=-
+kind: Cluster
+apiVersion: kind.x-k8s.io/v1alpha4
+containerdConfigPatches:
+- |-
+  [plugins."io.containerd.grpc.v1.cri".registry]
+    config_path = "/etc/containerd/certs.d"
+nodes:
+- role: control-plane
+  image: kindest/node:v1.27.3
+  kubeadmConfigPatches:
+  - |
+    kind: InitConfiguration
+    nodeRegistration:
+      kubeletExtraArgs:
+        node-labels: "ingress-ready=true"
+  extraPortMappings:
+  - containerPort: 80
+    hostPort: 80
+    protocol: TCP
+  - containerPort: 443
+    hostPort: 443
+    protocol: TCP
+EOF
+
+echo "3. Add the registry config to the nodes"
+# 3. Add the registry config to the nodes
+#
+# This is necessary because localhost resolves to loopback addresses that are
+# network-namespace local.
+# In other words: localhost in the container is not localhost on the host.
+#
+# We want a consistent name that works from both ends, so we tell containerd to
+# alias localhost:${reg_port} to the registry container when pulling images
+REGISTRY_DIR="/etc/containerd/certs.d/localhost:${reg_port}"
+for node in $(kind get nodes --name visio); do
+	docker exec "${node}" mkdir -p "${REGISTRY_DIR}"
+	cat <<EOF | docker exec -i "${node}" cp /dev/stdin "${REGISTRY_DIR}/hosts.toml"
+[host."http://${reg_name}:5000"]
+EOF
+done
+
+echo "4. Connect the registry to the cluster network if not already connected"
+# 4. Connect the registry to the cluster network if not already connected
+# This allows kind to bootstrap the network but ensures they're on the same network
+if [ "$(docker inspect -f='{{json .NetworkSettings.Networks.kind}}' "${reg_name}")" = 'null' ]; then
+	docker network connect "kind" "${reg_name}"
+fi
+
+echo "5. Document the local registry"
+# 5. Document the local registry
+# https://github.com/kubernetes/enhancements/tree/master/keps/sig-cluster-lifecycle/generic/1755-communicating-a-local-registry
+cat <<EOF | kubectl apply -f -
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: local-registry-hosting
+  namespace: kube-public
+data:
+  localRegistryHosting.v1: |
+    host: "localhost:${reg_port}"
+    help: "https://kind.sigs.k8s.io/docs/user/local-registry/"
+EOF
+
+cat <<EOF | kubectl apply -f -
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: coredns
+  namespace: kube-system
+data:
+  Corefile: |
+    .:53 {
+        errors
+        health {
+          lameduck 5s
+        }
+        ready
+        kubernetes cluster.local in-addr.arpa ip6.arpa {
+          pods insecure
+          fallthrough in-addr.arpa ip6.arpa
+          ttl 30
+        }
+        prometheus :9153
+        forward . /etc/resolv.conf {
+          max_concurrent 1000
+        }
+        rewrite stop {
+          name regex (.*).127.0.0.1.nip.io ingress-nginx-controller.ingress-nginx.svc.cluster.local answer auto
+        }
+        cache 30
+        loop
+        reload
+        loadbalance
+    }
+EOF
+
+kubectl -n kube-system rollout restart deployments/coredns
+
+echo "6. Install ingress-nginx"
+kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml
+kubectl -n ingress-nginx create secret tls mkcert --key /tmp/127.0.0.1.nip.io+1-key.pem --cert /tmp/127.0.0.1.nip.io+1.pem
+kubectl -n ingress-nginx patch deployments.apps ingress-nginx-controller --type 'json' -p '[{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value":"--default-ssl-certificate=ingress-nginx/mkcert"}]'
+
+echo "7. Setup namespace"
+kubectl create ns meet
+kubectl config set-context --current --namespace=meet
+kubectl -n meet create secret generic mkcert --from-file=rootCA.pem="$(mkcert -CAROOT)/rootCA.pem"

bin/update-git-submodule.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 git submodule update --init --recursive
 git submodule foreach 'git fetch origin; git checkout $(git rev-parse --abbrev-ref HEAD); git reset --hard origin/$(git rev-parse --abbrev-ref HEAD); git submodule update --recursive; git clean -dfx'

bin/update-keys.sh

@@ -1,3 +1,3 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 find . -name "*.enc.*" -exec sops updatekeys -y {} \;

bin/validate-helm-configuration.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 set -e
 

docker/livekit/Dockerfile

@@ -1,6 +0,0 @@
-FROM livekit/livekit-server:latest
-
-# We inject the nip.io certificate manually because the livekit chart doesn't support volume mounting
-COPY rootCA.pem /etc/ssl/certs/
-
-ENTRYPOINT ["/livekit-server"]

docs/examples/livekit.values.yaml

@@ -1,40 +0,0 @@
-replicaCount: 1
-terminationGracePeriodSeconds: 18000
-
-livekit:
-  keys:
-      devkey: secret
-  log_level: debug
-  rtc:
-    use_external_ip: false
-    port_range_start: 50000
-    port_range_end: 60000
-    tcp_port: 7881
-  redis:
-    address: redis-master:6379
-    password: pass
-  turn:
-    enabled: true
-    udp_port: 443
-    domain: livekit.127.0.0.1.nip.io
-    loadBalancerAnnotations: {}
-
-
-loadBalancer:
-  type: nginx
-  annotations:
-    nginx.ingress.kubernetes.io/rewrite-target: /
-    nginx.ingress.kubernetes.io/ssl-redirect: "true"
-  tls:
-    - hosts:
-        - livekit.127.0.0.1.nip.io
-      secretName: livekit-dinum-cert
-
-autoscaling:
-  enabled: false
-  minReplicas: 1
-  maxReplicas: 5
-  targetCPUUtilizationPercentage: 60
-
-nodeSelector: {}
-resources: {}

docs/examples/meet.values.yaml

@@ -1,120 +0,0 @@
-image:
-  repository: lasuite/meet-backend
-  pullPolicy: Always
-  tag: "latest"
-
-backend:
-  replicas: 1
-  envVars:
-    DJANGO_CSRF_TRUSTED_ORIGINS: https://meet.127.0.0.1.nip.io,http://meet.127.0.0.1.nip.io
-    DJANGO_CONFIGURATION: Production
-    DJANGO_ALLOWED_HOSTS: meet.127.0.0.1.nip.io
-    DJANGO_SECRET_KEY: ThisCouldBeAReallyGoodOrPerhapsABadKeyToUseSometimes
-    DJANGO_SETTINGS_MODULE: meet.settings
-    DJANGO_SILENCED_SYSTEM_CHECKS: security.W004, security.W008
-    DJANGO_SUPERUSER_PASSWORD: admin
-    DJANGO_EMAIL_HOST: "mailcatcher"
-    DJANGO_EMAIL_PORT: 1025
-    DJANGO_EMAIL_USE_SSL: False
-    OIDC_OP_JWKS_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/certs
-    OIDC_OP_AUTHORIZATION_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/auth
-    OIDC_OP_TOKEN_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/token
-    OIDC_OP_USER_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/userinfo
-    OIDC_OP_LOGOUT_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/session/end
-    OIDC_RP_CLIENT_ID: meet
-    OIDC_RP_CLIENT_SECRET: ThisIsAnExampleKeyForDevPurposeOnly
-    OIDC_RP_SIGN_ALGO: RS256
-    OIDC_RP_SCOPES: "openid email"
-    OIDC_REDIRECT_ALLOWED_HOSTS: https://meet.127.0.0.1.nip.io
-    OIDC_AUTH_REQUEST_EXTRA_PARAMS: "{'acr_values': 'eidas1'}"
-    LOGIN_REDIRECT_URL: https://meet.127.0.0.1.nip.io
-    LOGIN_REDIRECT_URL_FAILURE: https://meet.127.0.0.1.nip.io
-    LOGOUT_REDIRECT_URL: https://meet.127.0.0.1.nip.io
-    DB_HOST: postgresql
-    DB_NAME: meet
-    DB_USER: dinum
-    DB_PASSWORD: pass
-    DB_PORT: 5432
-    POSTGRES_DB: meet
-    POSTGRES_USER: dinum
-    POSTGRES_PASSWORD: pass
-    REDIS_URL: redis://default:pass@redis-master:6379/1
-    STORAGES_STATICFILES_BACKEND: django.contrib.staticfiles.storage.StaticFilesStorage
-    LIVEKIT_API_SECRET: secret
-    LIVEKIT_API_KEY: devkey
-    LIVEKIT_API_URL: https://livekit.127.0.0.1.nip.io/
-    ALLOW_UNREGISTERED_ROOMS: False
-    FRONTEND_SILENCE_LIVEKIT_DEBUG: False
-
-
-  migrate:
-    command:
-      - "/bin/sh"
-      - "-c"
-      - |
-        python manage.py migrate --no-input &&
-        python manage.py create_demo --force
-    restartPolicy: Never
-
-  command:
-    - "gunicorn"
-    - "-c"
-    - "/usr/local/etc/gunicorn/meet.py"
-    - "meet.wsgi:application"
-    - "--reload"
-
-  createsuperuser:
-    command:
-      - "/bin/sh"
-      - "-c"
-      - |
-        python manage.py createsuperuser --email admin@example.com --password admin
-    restartPolicy: Never
-
-  # Exra volume to manage our local custom CA and avoid to set ssl_verify: false
-  extraVolumeMounts:
-    - name: certs
-      mountPath: /usr/local/lib/python3.12/site-packages/certifi/cacert.pem
-      subPath: cacert.pem
-
-  # Exra volume to manage our local custom CA and avoid to set ssl_verify: false
-  extraVolumes:
-    - name: certs
-      configMap:
-        name: certifi
-        items:
-        - key: cacert.pem
-          path: cacert.pem
-
-frontend:
-  envVars:
-    VITE_PORT: 8080
-    VITE_HOST: 0.0.0.0
-    VITE_API_BASE_URL: https://meet.127.0.0.1.nip.io/
-
-  replicas: 1
-
-  image:
-    repository: lasuite/meet-frontend
-    pullPolicy: Always
-    tag: "latest"
-
-ingress:
-  enabled: true
-  host: meet.127.0.0.1.nip.io
-
-ingressAdmin:
-  enabled: true
-  host: meet.127.0.0.1.nip.io
-
-posthog:
-  ingress:
-    enabled: false
-  ingressAssets:
-    enabled: false
-
-summary:
-  replicas: 0
-
-celery:
-  replicas: 0

docs/examples/postgresql.values.yaml

@@ -1,7 +0,0 @@
-auth:
-  username: dinum
-  password: pass
-  database: meet
-tls:
-  enabled: true
-  autoGenerated: true

docs/examples/redis.values.yaml

@@ -1,3 +0,0 @@
-auth:
-  password: pass
-architecture: standalone

docs/installation.md

@@ -1,233 +0,0 @@
-# Installation on a k8s cluster
-
-This document is a step-by-step guide that describes how to install Visio on a k8s cluster without AI features.
-
-
-## Prerequisites
-
-- k8s cluster with an nginx-ingress controller
-- an OIDC provider (if you don't have one, we will provide an example)
-- a LiveKit server (if you don't have one, we will provide an example)
-- a PostgreSQL server (if you don't have one, we will provide an example)
-- a Memcached server (if you don't have one, we will provide an example)
-
-### Test cluster
-
-If you do not have a test cluster, you can install everything on a local kind cluster. In this case, the simplest way is to use our script **bin/start-kind.sh**.
-
-To be able to use the script, you will need to install:
-
-- Docker (https://docs.docker.com/desktop/)
-- Kind (https://kind.sigs.k8s.io/docs/user/quick-start/#installation)
-- Mkcert (https://github.com/FiloSottile/mkcert#installation)
-- Helm (https://helm.sh/docs/intro/quickstart/#install-helm)
-
-```
-$ ./bin/start-kind.sh
-0. Create ca
-The local CA is already installed in the system trust store! 👍
-The local CA is already installed in the Firefox and/or Chrome/Chromium trust store! 👍
-
-
-Created a new certificate valid for the following names 📜
- - "127.0.0.1.nip.io"
- - "*.127.0.0.1.nip.io"
-
-Reminder: X.509 wildcards only go one level deep, so this won't match a.b.127.0.0.1.nip.io ℹ️
-
-The certificate is at "./127.0.0.1.nip.io+1.pem" and the key at "./127.0.0.1.nip.io+1-key.pem" ✅
-
-It will expire on 23 March 2027 🗓
-
-1. Create registry container unless it already exists
-2. Create kind cluster with containerd registry config dir enabled
-Creating cluster "visio" ...
- ✓ Ensuring node image (kindest/node:v1.27.3) 🖼
- ✓ Preparing nodes 📦  
- ✓ Writing configuration 📜 
- ✓ Starting control-plane 🕹️ 
- ✓ Installing CNI 🔌 
- ✓ Installing StorageClass 💾 
-Set kubectl context to "kind-visio"
-You can now use your cluster with:
-
-kubectl cluster-info --context kind-visio
-
-Thanks for using kind! 😊
-3. Add the registry config to the nodes
-4. Connect the registry to the cluster network if not already connected
-5. Document the local registry
-configmap/local-registry-hosting created
-Warning: resource configmaps/coredns is missing the kubectl.kubernetes.io/last-applied-configuration annotation which is required by kubectl apply. kubectl apply should only be used on resources created declaratively by either kubectl create --save-config or kubectl apply. The missing annotation will be patched automatically.
-configmap/coredns configured
-deployment.apps/coredns restarted
-6. Install ingress-nginx
-namespace/ingress-nginx created
-serviceaccount/ingress-nginx created
-serviceaccount/ingress-nginx-admission created
-role.rbac.authorization.k8s.io/ingress-nginx created
-role.rbac.authorization.k8s.io/ingress-nginx-admission created
-clusterrole.rbac.authorization.k8s.io/ingress-nginx created
-clusterrole.rbac.authorization.k8s.io/ingress-nginx-admission created
-rolebinding.rbac.authorization.k8s.io/ingress-nginx created
-rolebinding.rbac.authorization.k8s.io/ingress-nginx-admission created
-clusterrolebinding.rbac.authorization.k8s.io/ingress-nginx created
-clusterrolebinding.rbac.authorization.k8s.io/ingress-nginx-admission created
-configmap/ingress-nginx-controller created
-service/ingress-nginx-controller created
-service/ingress-nginx-controller-admission created
-deployment.apps/ingress-nginx-controller created
-job.batch/ingress-nginx-admission-create created
-job.batch/ingress-nginx-admission-patch created
-ingressclass.networking.k8s.io/nginx created
-validatingwebhookconfiguration.admissionregistration.k8s.io/ingress-nginx-admission created
-secret/mkcert created
-deployment.apps/ingress-nginx-controller patched
-7. Setup namespace
-namespace/meet created
-Context "kind-visio" modified.
-secret/mkcert created
-$ kind get clusters
-visio
-$ kubectl -n ingress-nginx get po
-NAME                                        READY   STATUS      RESTARTS   AGE
-ingress-nginx-admission-create-jgnc9        0/1     Completed   0          2m44s
-ingress-nginx-admission-patch-wrt47         0/1     Completed   0          2m44s
-ingress-nginx-controller-57c548c4cd-9xwt6   1/1     Running     0          2m44s
-```
-When your k8s cluster is ready, you can start the deployment. This cluster is special because it uses the *.127.0.0.1.nip.io domain and mkcert certificates to have full HTTPS support and easy domain name management.
-
-Please remember that *.127.0.0.1.nip.io will always resolve to 127.0.0.1, except in the k8s cluster where we configure CoreDNS to answer with the ingress-nginx service IP.
-
-## Preparation
-
-### What will you use to authenticate your users ? 
-
-Visio uses OIDC, so if you already have an OIDC provider, obtain the necessary information to use it. In the next step, we will see how to configure Django (and thus Visio) to use it. If you do not have a provider, we will show you how to deploy a local Keycloak instance (this is not a production deployment, just a demo).
-
-If you haven't run the script **bin/start-kind.sh**, you'll need to manually create the namespace by running the following command:
-
-```
-$ kubectl create namespace meet
-```
-
-If you have already run the script, you can skip this step and proceed to the next instruction.
-
-```
-$ kubectl config set-context --current --namespace=meet
-$ helm install keycloak oci://registry-1.docker.io/bitnamicharts/keycloak -f examples/keycloak.values.yaml
-$ #wait until
-$ kubectl get po
-NAME                    READY   STATUS    RESTARTS   AGE
-keycloak-0              1/1     Running   0          6m48s
-keycloak-postgresql-0   1/1     Running   0          6m48s
-```
-
-From here the important information you will need are :
-
-```
-OIDC_OP_JWKS_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/certs
-OIDC_OP_AUTHORIZATION_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/auth
-OIDC_OP_TOKEN_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/token
-OIDC_OP_USER_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/userinfo
-OIDC_OP_LOGOUT_ENDPOINT: https://keycloak.127.0.0.1.nip.io/realms/meet/protocol/openid-connect/session/end
-OIDC_RP_CLIENT_ID: meet
-OIDC_RP_CLIENT_SECRET: ThisIsAnExampleKeyForDevPurposeOnly
-OIDC_RP_SIGN_ALGO: RS256
-OIDC_RP_SCOPES: "openid email"
-```
-
-You can find these values in **examples/keycloak.values.yaml**
-
-### Find livekit server connexion values
-
-Visio use livekit for streaming part so if you have a livekit provider, obtain the necessary information to use it. If you do not have a provider, you can install a livekit testing environment as follows:
-
-Livekit need a redis (and meet too) so we will start by deploying a redis :
-
-```
-$ helm install redis oci://registry-1.docker.io/bitnamicharts/redis -f examples/redis.values.yaml
-$ kubectl get po
-NAME                    READY   STATUS    RESTARTS   AGE
-keycloak-0              1/1     Running   0          26m
-keycloak-postgresql-0   1/1     Running   0          26m
-redis-master-0          1/1     Running   0          35s
-```
-When the redis is ready we can deploy livekit-server.
-
-```
-$ helm repo add livekit https://helm.livekit.io
-$ helm repo update
-$ helm install livekit livekit/livekit-server -f examples/livekit.values.yaml
-$ kubectl get po
-NAME                                      READY   STATUS    RESTARTS   AGE
-keycloak-0                                1/1     Running   0          30m
-keycloak-postgresql-0                     1/1     Running   0          30m
-livekit-livekit-server-5c5fb87f7f-ct6x5   1/1     Running   0          7s
-redis-master-0                            1/1     Running   0          4m30s
-$ curl https://livekit.127.0.0.1.nip.io
-OK
-```
-
-From here important information you will need are :
-
-```
-LIVEKIT_API_SECRET: secret
-LIVEKIT_API_KEY: devkey
-LIVEKIT_API_URL: https://livekit.127.0.0.1.nip.io/
-REDIS_URL: redis://default:pass@redis-master:6379/1
-CELERY_BROKER_URL: redis://default:pass@redis-master:6379/1
-CELERY_RESULT_BACKEND: redis://default:pass@redis-master:6379/1
-```
-
-### Find postgresql connexion values
-
-Visio uses a postgresql db as backend so if you have a provider, obtain the necessary information to use it. If you do not have, you can install a postgresql testing environment as follows:
-
-```
-$ helm install postgresql oci://registry-1.docker.io/bitnamicharts/postgresql -f examples/postgresql.values.yaml
-$ kubectl get po
-NAME                                      READY   STATUS    RESTARTS   AGE
-keycloak-0                                1/1     Running   0          45m
-keycloak-postgresql-0                     1/1     Running   0          45m
-livekit-livekit-server-5c5fb87f7f-ct6x5   1/1     Running   0          15m
-postgresql-0                              1/1     Running   0          50s
-redis-master-0                            1/1     Running   0          19
-```
-From here important information you will need are :
-
-```
-DB_HOST: postgres-postgresql
-DB_NAME: meet
-DB_USER: dinum
-DB_PASSWORD: pass
-DB_PORT: 5432
-POSTGRES_DB: meet
-POSTGRES_USER: dinum
-POSTGRES_PASSWORD: pass
-```
-
-## Deployment
-
-Now you are ready to deploy Visio without AI. AI required more dependencies (Openai-compliant API, LiveKit Egress, Cold storage and a docs deployment to push resumes). To deploy meet you need to provide all previous information to the helm chart.
-
-```
-$ helm repo add meet https://numerique-gouv.github.io/meet/
-$ helm repo update
-$ helm install meet meet/meet -f examples/meet.values.yaml
-```
-
-## Test your deployment
-
-In order to test your deployment you have to log in to your instance. If you use exclusively our examples you can do:
-
-```
-$ kubectl get ingress
-NAME                     CLASS    HOSTS                       ADDRESS     PORTS     AGE
-keycloak                 <none>   keycloak.127.0.0.1.nip.io   localhost   80        58m
-livekit-livekit-server   <none>   livekit.127.0.0.1.nip.io    localhost   80, 443   106m
-meet                     <none>   meet.127.0.0.1.nip.io       localhost   80, 443   52m
-meet-admin               <none>   meet.127.0.0.1.nip.io       localhost   80, 443   52m
-```
-
-You can use Visio on https://meet.127.0.0.1.nip.io. The provisioning user in keycloak is meet/meet.

renovate.json

@@ -14,7 +14,7 @@
       "groupName": "ignored js dependencies",
       "matchManagers": ["npm"],
       "matchPackageNames": [
-        "eslint", "react", "react-dom", "@types/react-dom", "@types/react", "react-i18next"
+        "eslint"
       ]
     }
   ]

src/backend/core/api/serializers.py

@@ -1,5 +1,6 @@
 """Client serializers for the Meet core app."""
 
+from django.conf import settings
 from django.utils.translation import gettext_lazy as _
 
 from rest_framework import serializers
@@ -91,7 +92,7 @@ class ListRoomSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = models.Room
-        fields = ["id", "name", "slug", "access_level"]
+        fields = ["id", "name", "slug", "is_public"]
         read_only_fields = ["id", "slug"]
 
 
@@ -100,7 +101,7 @@ class RoomSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = models.Room
-        fields = ["id", "name", "slug", "configuration", "access_level"]
+        fields = ["id", "name", "slug", "configuration", "is_public"]
         read_only_fields = ["id", "slug"]
 
     def to_representation(self, instance):
@@ -128,22 +129,19 @@ class RoomSerializer(serializers.ModelSerializer):
         if not is_admin:
             del output["configuration"]
 
-        should_access_room = (
-            (
-                instance.access_level == models.RoomAccessLevel.TRUSTED
-                and request.user.is_authenticated
-            )
-            or role is not None
-            or instance.is_public
-        )
-
-        if should_access_room:
+        if role is not None or instance.is_public:
             room_id = f"{instance.id!s}"
             username = request.query_params.get("username", None)
-            output["livekit"] = utils.generate_livekit_config(
-                room_id=room_id, user=request.user, username=username
-            )
 
+            output["livekit"] = {
+                "url": settings.LIVEKIT_CONFIGURATION["url"],
+                "room": room_id,
+                "token": utils.generate_token(
+                    room=room_id, user=request.user, username=username
+                ),
+                "passphrase": utils.get_cached_passphrase(room_id)
+            }
+            
         output["is_administrable"] = is_admin
 
         return output
@@ -180,32 +178,3 @@ class StartRecordingSerializer(serializers.Serializer):
     def update(self, instance, validated_data):
         """Not implemented as this is a validation-only serializer."""
         raise NotImplementedError("StartRecordingSerializer is validation-only")
-
-
-class RequestEntrySerializer(serializers.Serializer):
-    """Validate request entry data."""
-
-    username = serializers.CharField(required=True)
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")
-
-
-class ParticipantEntrySerializer(serializers.Serializer):
-    """Validate participant entry decision data."""
-
-    participant_id = serializers.CharField(required=True)
-    allow_entry = serializers.BooleanField(required=True)
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")

src/backend/core/api/viewsets.py

@@ -9,7 +9,12 @@ from django.http import Http404
 from django.shortcuts import get_object_or_404
 from django.utils.text import slugify
 
-from rest_framework import decorators, mixins, pagination, throttling, viewsets
+from rest_framework import (
+    decorators,
+    mixins,
+    pagination,
+    viewsets,
+)
 from rest_framework import (
     exceptions as drf_exceptions,
 )
@@ -39,17 +44,11 @@ from core.recording.worker.factories import (
 from core.recording.worker.mediator import (
     WorkerServiceMediator,
 )
-from core.services.livekit_events import (
-    LiveKitEventsService,
-    LiveKitWebhookError,
-)
-from core.services.lobby import (
-    LobbyParticipantNotFound,
-    LobbyService,
-)
 
 from . import permissions, serializers
 
+from livekit import api as livekit_api
+
 # pylint: disable=too-many-ancestors
 
 logger = getLogger(__name__)
@@ -154,8 +153,9 @@ class UserViewSet(
         queryset = self.queryset
 
         if self.action == "list":
-            if not settings.ALLOW_UNSECURE_USER_LISTING:
-                return models.User.objects.none()
+            # Exclude all users already in the given document
+            if document_id := self.request.GET.get("document_id", ""):
+                queryset = queryset.exclude(documentaccess__document_id=document_id)
 
             # Filter users by email similarity
             if query := self.request.GET.get("q", ""):
@@ -180,12 +180,6 @@ class UserViewSet(
         )
 
 
-class RequestEntryAnonRateThrottle(throttling.AnonRateThrottle):
-    """Throttle Anonymous user requesting room entry"""
-
-    scope = "request_entry"
-
-
 class RoomViewSet(
     mixins.CreateModelMixin,
     mixins.DestroyModelMixin,
@@ -218,6 +212,10 @@ class RoomViewSet(
         Allow unregistered rooms when activated.
         For unregistered rooms we only return a null id and the livekit room and token.
         """
+
+        # todo - determine whether encryption is needed store a shared secret in memory or in redis
+        # todo - check if a secret already exists, else create one.
+
         try:
             instance = self.get_object()
         except Http404:
@@ -351,114 +349,35 @@ class RoomViewSet(
             {"message": f"Recording stopped for room {room.slug}."}
         )
 
-    @decorators.action(
-        detail=True,
-        methods=["POST"],
-        url_path="request-entry",
-        permission_classes=[],
-        throttle_classes=[RequestEntryAnonRateThrottle],
-    )
-    def request_entry(self, request, pk=None):  # pylint: disable=unused-argument
-        """Request entry to a room"""
-
-        serializer = serializers.RequestEntrySerializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-
-        room = self.get_object()
-        lobby_service = LobbyService()
-
-        participant, livekit = lobby_service.request_entry(
-            room=room,
-            request=request,
-            **serializer.validated_data,
-        )
-        response = drf_response.Response({**participant.to_dict(), "livekit": livekit})
-        lobby_service.prepare_response(response, participant.id)
-
-        return response
-
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="enter",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-        ],
-    )
-    def allow_participant_to_enter(self, request, pk=None):  # pylint: disable=unused-argument
-        """Accept or deny a participant's entry request."""
-
-        serializer = serializers.ParticipantEntrySerializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-
-        room = self.get_object()
-
-        if room.is_public:
-            return drf_response.Response(
-                {"message": "Room has no lobby system."},
-                status=drf_status.HTTP_404_NOT_FOUND,
-            )
-
-        lobby_service = LobbyService()
-
-        try:
-            lobby_service.handle_participant_entry(
-                room_id=room.id,
-                **serializer.validated_data,
-            )
-            return drf_response.Response({"message": "Participant was updated."})
-
-        except LobbyParticipantNotFound:
-            return drf_response.Response(
-                {"message": "Participant not found."},
-                status=drf_status.HTTP_404_NOT_FOUND,
-            )
-
-    @decorators.action(
-        detail=True,
-        methods=["GET"],
-        url_path="waiting-participants",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-        ],
-    )
-    def list_waiting_participants(self, request, pk=None):  # pylint: disable=unused-argument
-        """List waiting participants."""
-        room = self.get_object()
-
-        if room.is_public:
-            return drf_response.Response({"participants": []})
-
-        lobby_service = LobbyService()
-
-        participants = lobby_service.list_waiting_participants(room.id)
-        return drf_response.Response({"participants": participants})
-
     @decorators.action(
         detail=False,
-        methods=["POST"],
-        url_path="webhooks-livekit",
+        methods=["post"],
+        url_path="livekit-webhook",
         permission_classes=[],
+        authentication_classes=[],
     )
-    def webhooks_livekit(self, request):
-        """Process webhooks from LiveKit."""
-
-        livekit_events_service = LiveKitEventsService()
-
-        try:
-            livekit_events_service.receive(request)
+    def handle_livekit_webhook(self, request, pk=None):  # pylint: disable=unused-argument
+        """Handle LiveKit webhook events."""
+        auth_token = request.headers.get("Authorization")
+        if not auth_token:
             return drf_response.Response(
-                {"status": "success"}, status=drf_status.HTTP_200_OK
+                {"error": "Missing LiveKit authentication token"},
+                status=drf_status.HTTP_401_UNAUTHORIZED
             )
-        except LiveKitWebhookError as e:
-            status_code = getattr(e, "status_code", drf_status.HTTP_400_BAD_REQUEST)
 
-            if status_code == drf_status.HTTP_500_INTERNAL_SERVER_ERROR:
-                raise e
+        token_verifier = livekit_api.TokenVerifier()
+        webhook_receiver = livekit_api.WebhookReceiver(token_verifier)
 
-            return drf_response.Response(
-                {"status": "error", "message": str(e)}, status=status_code
-            )
+        webhook_data = webhook_receiver.receive(request.body.decode("utf-8"), auth_token)
+
+        # Todo - livekit triggers a webhook for all events, see if we can restrict webhook to a limited number of events.
+        # Todo - handle Egress stopped / aborted events.
+
+        if webhook_data.event == "room_finished":
+            room_id = webhook_data.room.name
+            utils.clear_cache_passphrase(room_id)
+
+        return drf_response.Response({"message": f"Event processed"})
 
 
 class ResourceAccessListModelMixin:

src/backend/core/authentication/backends.py

@@ -10,7 +10,7 @@ from mozilla_django_oidc.auth import (
 )
 
 from core.models import User
-from core.services.marketing import (
+from core.services.marketing_service import (
     ContactCreationError,
     ContactData,
     get_marketing_service,

src/backend/core/factories.py

@@ -36,6 +36,8 @@ class ResourceFactory(factory.django.DjangoModelFactory):
         model = models.Resource
         skip_postgeneration_save = True
 
+    is_public = factory.Faker("boolean", chance_of_getting_true=50)
+
     @factory.post_generation
     def users(self, create, extracted, **kwargs):
         """Add users to resource from a given list of users."""
@@ -68,7 +70,6 @@ class RoomFactory(ResourceFactory):
 
     name = factory.Faker("catch_phrase")
     slug = factory.LazyAttribute(lambda o: slugify(o.name))
-    access_level = factory.fuzzy.FuzzyChoice(models.RoomAccessLevel)
 
 
 class RecordingFactory(factory.django.DjangoModelFactory):

src/backend/core/migrations/0010_alter_resourceaccess_options_alter_user_options.py

@@ -1,21 +0,0 @@
-# Generated by Django 5.1.4 on 2025-01-13 12:25
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0009_alter_recording_status'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='resourceaccess',
-            options={'ordering': ('-created_at',), 'verbose_name': 'Resource access', 'verbose_name_plural': 'Resource accesses'},
-        ),
-        migrations.AlterModelOptions(
-            name='user',
-            options={'ordering': ('-created_at',), 'verbose_name': 'user', 'verbose_name_plural': 'users'},
-        ),
-    ]

src/backend/core/migrations/0011_remove_resource_is_public_room_access_level.py

@@ -1,22 +0,0 @@
-# Generated by Django 5.1.5 on 2025-02-16 11:42
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0010_alter_resourceaccess_options_alter_user_options'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='resource',
-            name='is_public',
-        ),
-        migrations.AddField(
-            model_name='room',
-            name='access_level',
-            field=models.CharField(choices=[('public', 'Public Access'), ('restricted', 'Restricted Access')], default='public', max_length=50),
-        ),
-    ]

src/backend/core/migrations/0012_alter_room_access_level.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.6 on 2025-03-04 09:51
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0011_remove_resource_is_public_room_access_level'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='room',
-            name='access_level',
-            field=models.CharField(choices=[('public', 'Public Access'), ('trusted', 'Trusted Access'), ('restricted', 'Restricted Access')], default='public', max_length=50),
-        )
-    ]

src/backend/core/models.py

@@ -80,14 +80,6 @@ class RecordingModeChoices(models.TextChoices):
     TRANSCRIPT = "transcript", _("TRANSCRIPT")
 
 
-class RoomAccessLevel(models.TextChoices):
-    """Room access level choices."""
-
-    PUBLIC = "public", _("Public Access")
-    TRUSTED = "trusted", _("Trusted Access")
-    RESTRICTED = "restricted", _("Restricted Access")
-
-
 class BaseModel(models.Model):
     """
     Serves as an abstract base model for other models, ensuring that records are validated
@@ -249,6 +241,7 @@ def get_resource_roles(resource: models.Model, user: User) -> List[str]:
 class Resource(BaseModel):
     """Model to define access control"""
 
+    is_public = models.BooleanField(default=settings.RESOURCE_DEFAULT_IS_PUBLIC)
     users = models.ManyToManyField(
         User,
         through="ResourceAccess",
@@ -368,11 +361,7 @@ class Room(Resource):
         primary_key=True,
     )
     slug = models.SlugField(max_length=100, blank=True, null=True, unique=True)
-    access_level = models.CharField(
-        max_length=50,
-        choices=RoomAccessLevel.choices,
-        default=settings.RESOURCE_DEFAULT_ACCESS_LEVEL,
-    )
+
     configuration = models.JSONField(
         blank=True,
         default=dict,
@@ -405,11 +394,6 @@ class Room(Resource):
             raise ValidationError({"name": f'Room name "{self.name:s}" is reserved.'})
         super().clean_fields(exclude=exclude)
 
-    @property
-    def is_public(self):
-        """Check if a room is public"""
-        return self.access_level == RoomAccessLevel.PUBLIC
-
 
 class BaseAccessManager(models.Manager):
     """Base manager for handling resource access control."""

src/backend/core/services/livekit_events.py

@@ -1,117 +0,0 @@
-"""LiveKit Events Service"""
-
-import uuid
-from enum import Enum
-
-from django.conf import settings
-
-from livekit import api
-
-from .lobby import LobbyService
-
-
-class LiveKitWebhookError(Exception):
-    """Base exception for LiveKit webhook processing errors."""
-
-    status_code = 500
-
-
-class AuthenticationError(LiveKitWebhookError):
-    """Authentication failed."""
-
-    status_code = 401
-
-
-class InvalidPayloadError(LiveKitWebhookError):
-    """Invalid webhook payload."""
-
-    status_code = 400
-
-
-class UnsupportedEventTypeError(LiveKitWebhookError):
-    """Unsupported event type."""
-
-    status_code = 422
-
-
-class ActionFailedError(LiveKitWebhookError):
-    """Webhook action fails to process or complete."""
-
-    status_code = 500
-
-
-class LiveKitWebhookEventType(Enum):
-    """LiveKit webhook event types."""
-
-    # Room events
-    ROOM_STARTED = "room_started"
-    ROOM_FINISHED = "room_finished"
-
-    # Participant events
-    PARTICIPANT_JOINED = "participant_joined"
-    PARTICIPANT_LEFT = "participant_left"
-
-    # Track events
-    TRACK_PUBLISHED = "track_published"
-    TRACK_UNPUBLISHED = "track_unpublished"
-
-    # Egress events
-    EGRESS_STARTED = "egress_started"
-    EGRESS_UPDATED = "egress_updated"
-    EGRESS_ENDED = "egress_ended"
-
-    # Ingress events
-    INGRESS_STARTED = "ingress_started"
-    INGRESS_ENDED = "ingress_ended"
-
-
-class LiveKitEventsService:
-    """Service for processing and handling LiveKit webhook events and notifications."""
-
-    def __init__(self):
-        """Initialize with required services."""
-
-        token_verifier = api.TokenVerifier(
-            settings.LIVEKIT_CONFIGURATION["api_key"],
-            settings.LIVEKIT_CONFIGURATION["api_secret"],
-        )
-        self.webhook_receiver = api.WebhookReceiver(token_verifier)
-        self.lobby_service = LobbyService()
-
-    def receive(self, request):
-        """Process webhook and route to appropriate handler."""
-
-        auth_token = request.headers.get("Authorization")
-        if not auth_token:
-            raise AuthenticationError("Authorization header missing")
-
-        try:
-            data = self.webhook_receiver.receive(
-                request.body.decode("utf-8"), auth_token
-            )
-        except Exception as e:
-            raise InvalidPayloadError("Invalid webhook payload") from e
-
-        try:
-            webhook_type = LiveKitWebhookEventType(data.event)
-        except ValueError as e:
-            raise UnsupportedEventTypeError(
-                f"Unknown webhook type: {data.event}"
-            ) from e
-
-        handler_name = f"_handle_{webhook_type.value}"
-        handler = getattr(self, handler_name, None)
-
-        if not handler or not callable(handler):
-            return
-
-        # pylint: disable=not-callable
-        handler(data)
-
-    def _handle_room_finished(self, data):
-        """Handle 'room_finished' event."""
-        try:
-            room_id = uuid.UUID(data.room.name)
-            self.lobby_service.clear_room_cache(room_id)
-        except Exception as e:
-            raise ActionFailedError("Failed to process room finished event") from e

src/backend/core/services/lobby.py

@@ -1,369 +0,0 @@
-"""Lobby Service"""
-
-import json
-import logging
-import uuid
-from dataclasses import dataclass
-from enum import Enum
-from typing import Dict, List, Optional, Tuple
-from uuid import UUID
-
-from django.conf import settings
-from django.core.cache import cache
-
-from asgiref.sync import async_to_sync
-from livekit.api import LiveKitAPI, SendDataRequest, TwirpError  # pylint: disable=E0611
-
-from core import models, utils
-
-logger = logging.getLogger(__name__)
-
-
-class LobbyParticipantStatus(Enum):
-    """Possible states of a participant in the lobby system.
-    Values are lowercase strings for consistent serialization and API responses.
-    """
-
-    UNKNOWN = "unknown"
-    WAITING = "waiting"
-    ACCEPTED = "accepted"
-    DENIED = "denied"
-
-
-class LobbyError(Exception):
-    """Base exception for lobby-related errors."""
-
-
-class LobbyParticipantParsingError(LobbyError):
-    """Raised when participant data parsing fails."""
-
-
-class LobbyParticipantNotFound(LobbyError):
-    """Raised when participant is not found."""
-
-
-class LobbyNotificationError(LobbyError):
-    """Raised when LiveKit notification fails."""
-
-
-@dataclass
-class LobbyParticipant:
-    """Participant in a lobby system."""
-
-    status: LobbyParticipantStatus
-    username: str
-    color: str
-    id: str
-
-    def to_dict(self) -> Dict[str, str]:
-        """Serialize the participant object to a dict representation."""
-        return {
-            "status": self.status.value,
-            "username": self.username,
-            "id": self.id,
-            "color": self.color,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "LobbyParticipant":
-        """Create a LobbyParticipant instance from a dictionary."""
-        try:
-            status = LobbyParticipantStatus(
-                data.get("status", LobbyParticipantStatus.UNKNOWN.value)
-            )
-            return cls(
-                status=status,
-                username=data["username"],
-                id=data["id"],
-                color=data["color"],
-            )
-        except (KeyError, ValueError) as e:
-            logger.exception("Error creating Participant from dict:")
-            raise LobbyParticipantParsingError("Invalid participant data") from e
-
-
-class LobbyService:
-    """Service for managing participant access through a lobby system.
-
-    Handles participant entry requests, status management, and notifications
-    using cache for state management and LiveKit for real-time updates.
-    """
-
-    @staticmethod
-    def _get_cache_key(room_id: UUID, participant_id: str) -> str:
-        """Generate cache key for participant(s) data."""
-        return f"{settings.LOBBY_KEY_PREFIX}_{room_id!s}_{participant_id}"
-
-    @staticmethod
-    def _get_or_create_participant_id(request) -> str:
-        """Extract unique participant identifier from the request."""
-        return request.COOKIES.get(settings.LOBBY_COOKIE_NAME, uuid.uuid4().hex)
-
-    @staticmethod
-    def prepare_response(response, participant_id):
-        """Set participant cookie if needed."""
-        if not response.cookies.get(settings.LOBBY_COOKIE_NAME):
-            response.set_cookie(
-                key=settings.LOBBY_COOKIE_NAME,
-                value=participant_id,
-                httponly=True,
-                secure=True,
-                samesite="Lax",
-            )
-
-    @staticmethod
-    def can_bypass_lobby(room, user) -> bool:
-        """Determines if a user can bypass the waiting lobby and join a room directly.
-
-        A user can bypass the lobby if:
-        1. The room is public (open to everyone)
-        2. The room has TRUSTED access level and the user is authenticated
-
-        Note: Room access levels can change while participants are waiting in the lobby.
-        This function only checks the current state and should be called each time
-        a participant requests entry to ensure consistent access control, even for
-        participants who have already begun waiting.
-        """
-        return room.is_public or (
-            room.access_level == models.RoomAccessLevel.TRUSTED
-            and user.is_authenticated
-        )
-
-    def request_entry(
-        self,
-        room,
-        request,
-        username: str,
-    ) -> Tuple[LobbyParticipant, Optional[Dict]]:
-        """Request entry to a room for a participant.
-
-        This usual status transitions is:
-        UNKNOWN -> WAITING -> (ACCEPTED | DENIED)
-
-        Flow:
-        1. Check current status
-        2. If waiting, refresh timeout to maintain position
-        3. If unknown, add to waiting list
-        4. If accepted, generate LiveKit config
-        5. If denied, do nothing.
-        """
-
-        participant_id = self._get_or_create_participant_id(request)
-        participant = self._get_participant(room.id, participant_id)
-
-        if self.can_bypass_lobby(room=room, user=request.user):
-            if participant is None:
-                participant = LobbyParticipant(
-                    status=LobbyParticipantStatus.ACCEPTED,
-                    username=username,
-                    id=participant_id,
-                    color=utils.generate_color(participant_id),
-                )
-            else:
-                participant.status = LobbyParticipantStatus.ACCEPTED
-
-            livekit_config = utils.generate_livekit_config(
-                room_id=str(room.id),
-                user=request.user,
-                username=username,
-                color=participant.color,
-            )
-            return participant, livekit_config
-
-        livekit_config = None
-
-        if participant is None:
-            participant = self.enter(room.id, participant_id, username)
-
-        elif participant.status == LobbyParticipantStatus.WAITING:
-            self.refresh_waiting_status(room.id, participant_id)
-
-        elif participant.status == LobbyParticipantStatus.ACCEPTED:
-            # wrongly named, contains access token to join a room
-            livekit_config = utils.generate_livekit_config(
-                room_id=str(room.id),
-                user=request.user,
-                username=username,
-                color=participant.color,
-            )
-
-        return participant, livekit_config
-
-    def refresh_waiting_status(self, room_id: UUID, participant_id: str):
-        """Refresh timeout for waiting participant.
-
-        Extends the waiting period for a participant to maintain their position
-        in the lobby queue. Automatic removal if the participant is not
-        actively checking their status.
-        """
-        cache.touch(
-            self._get_cache_key(room_id, participant_id), settings.LOBBY_WAITING_TIMEOUT
-        )
-
-    def enter(
-        self, room_id: UUID, participant_id: str, username: str
-    ) -> LobbyParticipant:
-        """Add participant to waiting lobby.
-
-        Create a new participant entry in waiting status and notify room
-        participants of the new entry request.
-
-        Raises:
-            LobbyNotificationError: If room notification fails
-        """
-
-        color = utils.generate_color(participant_id)
-
-        participant = LobbyParticipant(
-            status=LobbyParticipantStatus.WAITING,
-            username=username,
-            id=participant_id,
-            color=color,
-        )
-
-        cache_key = self._get_cache_key(room_id, participant_id)
-        cache.set(
-            cache_key,
-            participant.to_dict(),
-            timeout=settings.LOBBY_WAITING_TIMEOUT,
-        )
-
-        try:
-            self.notify_participants(room_id=room_id)
-        except LobbyNotificationError:
-            # If room not created yet, there is no participants to notify
-            pass
-
-        return participant
-
-    def _get_participant(
-        self, room_id: UUID, participant_id: str
-    ) -> Optional[LobbyParticipant]:
-        """Check participant's current status in the lobby."""
-
-        cache_key = self._get_cache_key(room_id, participant_id)
-        data = cache.get(cache_key)
-
-        if not data:
-            return None
-
-        try:
-            return LobbyParticipant.from_dict(data)
-        except LobbyParticipantParsingError:
-            logger.error("Corrupted participant data found and removed: %s", cache_key)
-            cache.delete(cache_key)
-            return None
-
-    def list_waiting_participants(self, room_id: UUID) -> List[dict]:
-        """List all waiting participants for a room."""
-
-        pattern = self._get_cache_key(room_id, "*")
-        keys = cache.keys(pattern)
-
-        if not keys:
-            return []
-
-        data = cache.get_many(keys)
-
-        waiting_participants = []
-        for cache_key, raw_participant in data.items():
-            try:
-                participant = LobbyParticipant.from_dict(raw_participant)
-            except LobbyParticipantParsingError:
-                cache.delete(cache_key)
-                continue
-            if participant.status == LobbyParticipantStatus.WAITING:
-                waiting_participants.append(participant.to_dict())
-
-        return waiting_participants
-
-    def handle_participant_entry(
-        self,
-        room_id: UUID,
-        participant_id: str,
-        allow_entry: bool,
-    ) -> None:
-        """Handle decision on participant entry.
-
-        Updates participant status based on allow_entry:
-        - If accepted: ACCEPTED status with extended timeout matching LiveKit token
-        - If denied: DENIED status with short timeout allowing status check and retry
-        """
-        if allow_entry:
-            decision = {
-                "status": LobbyParticipantStatus.ACCEPTED,
-                "timeout": settings.LOBBY_ACCEPTED_TIMEOUT,
-            }
-        else:
-            decision = {
-                "status": LobbyParticipantStatus.DENIED,
-                "timeout": settings.LOBBY_DENIED_TIMEOUT,
-            }
-
-        self._update_participant_status(room_id, participant_id, **decision)
-
-    def _update_participant_status(
-        self,
-        room_id: UUID,
-        participant_id: str,
-        status: LobbyParticipantStatus,
-        timeout: int,
-    ) -> None:
-        """Update participant status with appropriate timeout."""
-
-        cache_key = self._get_cache_key(room_id, participant_id)
-
-        data = cache.get(cache_key)
-        if not data:
-            logger.error("Participant %s not found", participant_id)
-            raise LobbyParticipantNotFound("Participant not found")
-
-        try:
-            participant = LobbyParticipant.from_dict(data)
-        except LobbyParticipantParsingError:
-            logger.exception(
-                "Removed corrupted data for participant %s:", participant_id
-            )
-            cache.delete(cache_key)
-            raise
-
-        participant.status = status
-        cache.set(cache_key, participant.to_dict(), timeout=timeout)
-
-    @async_to_sync
-    async def notify_participants(self, room_id: UUID):
-        """Notify room participants about a new waiting participant using LiveKit.
-
-        Raises:
-            LobbyNotificationError: If notification fails to send
-        """
-
-        notification_data = {
-            "type": settings.LOBBY_NOTIFICATION_TYPE,
-        }
-
-        lkapi = LiveKitAPI(**settings.LIVEKIT_CONFIGURATION)
-        try:
-            await lkapi.room.send_data(
-                SendDataRequest(
-                    room=str(room_id),
-                    data=json.dumps(notification_data).encode("utf-8"),
-                    kind="RELIABLE",
-                )
-            )
-        except TwirpError as e:
-            logger.exception("Failed to notify room participants")
-            raise LobbyNotificationError("Failed to notify room participants") from e
-        finally:
-            await lkapi.aclose()
-
-    def clear_room_cache(self, room_id: UUID) -> None:
-        """Clear all participant entries from the cache for a specific room."""
-
-        pattern = self._get_cache_key(room_id, "*")
-        keys = cache.keys(pattern)
-
-        if not keys:
-            return
-
-        cache.delete_many(keys)

src/backend/core/tests/authentication/test_backends.py

@@ -9,7 +9,7 @@ import pytest
 from core import models
 from core.authentication.backends import OIDCAuthenticationBackend
 from core.factories import UserFactory
-from core.services import marketing
+from core.services import marketing_service
 
 pytestmark = pytest.mark.django_db
 
@@ -535,7 +535,7 @@ def test_marketing_signup_handles_service_initialization_errors(
 @pytest.mark.parametrize(
     "error",
     [
-        marketing.ContactCreationError,
+        marketing_service.ContactCreationError,
         ImproperlyConfigured,
         ImportError,
     ],

src/backend/core/tests/recording/test_api_recordings_list.py

@@ -59,8 +59,8 @@ def test_api_recordings_list_authenticated_direct(role):
         "id": str(recording.id),
         "created_at": recording.created_at.isoformat().replace("+00:00", "Z"),
         "room": {
-            "access_level": str(room.access_level),
             "id": str(room.id),
+            "is_public": room.is_public,
             "name": room.name,
             "slug": room.slug,
         },

src/backend/core/tests/rooms/test_api_rooms_list.py

@@ -9,16 +9,14 @@ from rest_framework.pagination import PageNumberPagination
 from rest_framework.test import APIClient
 
 from ...factories import RoomFactory, UserFactory
-from ...models import RoomAccessLevel
 
 pytestmark = pytest.mark.django_db
 
 
 def test_api_rooms_list_anonymous():
     """Anonymous users should not be able to list rooms."""
-    RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    RoomFactory(is_public=False)
+    RoomFactory(is_public=True)
 
     client = APIClient()
 
@@ -40,13 +38,10 @@ def test_api_rooms_list_authenticated():
 
     other_user = UserFactory()
 
-    RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    room_user_accesses = RoomFactory(
-        access_level=RoomAccessLevel.RESTRICTED, users=[user]
-    )
-    RoomFactory(access_level=RoomAccessLevel.RESTRICTED, users=[other_user])
+    RoomFactory(is_public=False)
+    RoomFactory(is_public=True)
+    room_user_accesses = RoomFactory(is_public=False, users=[user])
+    RoomFactory(is_public=False, users=[other_user])
 
     response = client.get(
         "/api/v1.0/rooms/",
@@ -110,7 +105,7 @@ def test_api_rooms_list_authenticated_distinct():
     client = APIClient()
     client.force_login(user)
 
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC, users=[user, other_user])
+    room = RoomFactory(is_public=True, users=[user, other_user])
 
     response = client.get(
         "/api/v1.0/rooms/",

src/backend/core/tests/rooms/test_api_rooms_lobby.py

@@ -1,624 +0,0 @@
-"""
-Test rooms API endpoints in the Meet core app: lobby functionality.
-"""
-
-# pylint: disable=W0621,W0613,W0212
-import uuid
-from unittest import mock
-
-from django.core.cache import cache
-
-import pytest
-from rest_framework.test import APIClient
-
-from ... import utils
-from ...factories import RoomFactory, UserFactory
-from ...models import RoomAccessLevel
-from ...services.lobby import (
-    LobbyService,
-)
-
-pytestmark = pytest.mark.django_db
-
-
-# Tests for request_entry endpoint
-
-
-def test_request_entry_anonymous(settings):
-    """Anonymous users should be allowed to request entry to a room."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    client = APIClient()
-
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(utils, "generate_color", return_value="mocked-color"),
-    ):
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "test_user"},
-        )
-
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was properly set
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-
-    participant_id = cookie.value
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": participant_id,
-        "username": "test_user",
-        "status": "waiting",
-        "color": "mocked-color",
-        "livekit": None,
-    }
-
-    # Verify a participant was stored in cache
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert len(lobby_keys) == 1
-
-    # Verify participant data was correctly stored in cache
-    participant_data = cache.get(f"mocked-cache-prefix_{room.id!s}_{participant_id}")
-    assert participant_data.get("username") == "test_user"
-
-
-def test_request_entry_authenticated_user(settings):
-    """Authenticated users should be allowed to request entry."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    user = UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(utils, "generate_color", return_value="mocked-color"),
-    ):
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "test_user"},
-        )
-
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was properly set
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-
-    participant_id = cookie.value
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": participant_id,
-        "username": "test_user",
-        "status": "waiting",
-        "color": "mocked-color",
-        "livekit": None,
-    }
-
-    # Verify a participant was stored in cache
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert len(lobby_keys) == 1
-
-    # Verify participant data was correctly stored in cache
-    participant_data = cache.get(f"mocked-cache-prefix_{room.id!s}_{participant_id}")
-    assert participant_data.get("username") == "test_user"
-
-
-def test_request_entry_with_existing_participants(settings):
-    """Anonymous users should be allowed to request entry to a room with existing participants."""
-    # Create a restricted access room
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    client = APIClient()
-
-    # Configure test settings for cookies and cache
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Add two participants already waiting in the lobby
-    cache.set(
-        f"mocked-cache-prefix_{room.id}_participant1",
-        {
-            "id": "participant1",
-            "username": "user1",
-            "status": "waiting",
-            "color": "#123456",
-        },
-    )
-    cache.set(
-        f"mocked-cache-prefix_{room.id}_participant2",
-        {
-            "id": "participant2",
-            "username": "user2",
-            "status": "accepted",
-            "color": "#654321",
-        },
-    )
-
-    # Verify two participants are in the lobby before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert len(lobby_keys) == 2
-
-    # Mock external service calls to isolate the test
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(utils, "generate_color", return_value="mocked-color"),
-    ):
-        # Make request as a new anonymous user
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "test_user"},
-        )
-
-    # Verify successful response
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was properly set for the new participant
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-
-    participant_id = cookie.value
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": participant_id,
-        "username": "test_user",
-        "status": "waiting",
-        "color": "mocked-color",
-        "livekit": None,
-    }
-
-    # Verify now three participants are in the lobby cache
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert len(lobby_keys) == 3
-
-    # Verify the new participant data was correctly stored in cache
-    participant_data = cache.get(f"mocked-cache-prefix_{room.id!s}_{participant_id}")
-    assert participant_data.get("username") == "test_user"
-
-
-def test_request_entry_public_room(settings):
-    """Entry requests to public rooms should return ACCEPTED status with LiveKit config."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    client = APIClient()
-
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(
-            LobbyService, "_get_or_create_participant_id", return_value="123"
-        ),
-        mock.patch.object(
-            utils, "generate_livekit_config", return_value={"token": "test-token"}
-        ),
-        mock.patch.object(utils, "generate_color", return_value="mocked-color"),
-    ):
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "test_user"},
-        )
-
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was set
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-    assert cookie.value == "123"
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": "123",
-        "username": "test_user",
-        "status": "accepted",
-        "color": "mocked-color",
-        "livekit": {"token": "test-token"},
-    }
-
-    # Verify lobby cache is still empty after the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-
-def test_request_entry_authenticated_user_public_room(settings):
-    """While authenticated, entry request to public rooms should get accepted."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    user = UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(
-            LobbyService, "_get_or_create_participant_id", return_value="123"
-        ),
-        mock.patch.object(
-            utils, "generate_livekit_config", return_value={"token": "test-token"}
-        ),
-        mock.patch.object(utils, "generate_color", return_value="mocked-color"),
-    ):
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "test_user"},
-        )
-
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was set
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-    assert cookie.value == "123"
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": "123",
-        "username": "test_user",
-        "status": "accepted",
-        "color": "mocked-color",
-        "livekit": {"token": "test-token"},
-    }
-
-    # Verify lobby cache is still empty after the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-
-def test_request_entry_waiting_participant_public_room(settings):
-    """While waiting, entry request to public rooms should get accepted."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    client = APIClient()
-
-    settings.LOBBY_COOKIE_NAME = "mocked-cookie"
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Add a waiting participant to the room's lobby cache
-    cache.set(
-        f"mocked-cache-prefix_{room.id}_participant1",
-        {
-            "id": "participant1",
-            "username": "user1",
-            "status": "waiting",
-            "color": "#123456",
-        },
-    )
-
-    # Simulate a browser with existing participant cookie
-    client.cookies.load({"mocked-cookie": "participant1"})
-
-    with (
-        mock.patch.object(LobbyService, "notify_participants", return_value=None),
-        mock.patch.object(
-            utils, "generate_livekit_config", return_value={"token": "test-token"}
-        ),
-    ):
-        response = client.post(
-            f"/api/v1.0/rooms/{room.id}/request-entry/",
-            {"username": "user1"},
-        )
-
-    assert response.status_code == 200
-
-    # Verify the lobby cookie was set
-    cookie = response.cookies.get("mocked-cookie")
-    assert cookie is not None
-    assert cookie.value == "participant1"
-
-    # Verify response content matches expected structure and values
-    assert response.json() == {
-        "id": "participant1",
-        "username": "user1",
-        "status": "accepted",
-        "color": "#123456",
-        "livekit": {"token": "test-token"},
-    }
-
-    # Verify participant remains in the lobby cache after acceptance
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert len(lobby_keys) == 1
-
-
-def test_request_entry_invalid_data():
-    """Should return 400 for invalid request data."""
-    room = RoomFactory()
-    client = APIClient()
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/request-entry/",
-        {},  # Missing required username field
-    )
-
-    assert response.status_code == 400
-
-
-def test_request_entry_room_not_found():
-    """Should return 404 for non-existent room."""
-    client = APIClient()
-
-    response = client.post(
-        f"/api/v1.0/rooms/{uuid.uuid4()!s}/request-entry/",
-        {"username": "anonymous"},
-    )
-
-    assert response.status_code == 404
-
-
-# Tests for allow_participant_to_enter endpoint
-
-
-def test_allow_participant_to_enter_anonymous():
-    """Anonymous users should not be allowed to manage entry requests."""
-    room = RoomFactory()
-    client = APIClient()
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "test-id", "allow_entry": True},
-    )
-
-    assert response.status_code == 401
-
-
-def test_allow_participant_to_enter_non_owner():
-    """Non-privileged users should not be allowed to manage entry requests."""
-    room = RoomFactory()
-    user = UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "test-id", "allow_entry": True},
-    )
-
-    assert response.status_code == 403
-
-
-def test_allow_participant_to_enter_public_room():
-    """Should return 404 for public rooms that don't use the lobby system."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "test-id", "allow_entry": True},
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {"message": "Room has no lobby system."}
-
-
-@pytest.mark.parametrize(
-    "allow_entry, updated_status", [(True, "accepted"), (False, "denied")]
-)
-def test_allow_participant_to_enter_success(settings, allow_entry, updated_status):
-    """Should successfully update participant status when everything is correct."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    cache.set(
-        f"mocked-cache-prefix_{room.id!s}_participant1",
-        {
-            "id": "test-id",
-            "status": "waiting",
-            "username": "foo",
-            "color": "123",
-        },
-    )
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "participant1", "allow_entry": allow_entry},
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Participant was updated."}
-
-    participant_data = cache.get(f"mocked-cache-prefix_{room.id!s}_participant1")
-    assert participant_data.get("status") == updated_status
-
-
-def test_allow_participant_to_enter_participant_not_found(settings):
-    """Should handle case when participant is not found."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    participant_data = cache.get(f"mocked-cache-prefix_{room.id!s}_test-id")
-    assert participant_data is None
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {"participant_id": "test-id", "allow_entry": True},
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {"message": "Participant not found."}
-
-
-def test_allow_participant_to_enter_invalid_data():
-    """Should return 400 for invalid request data."""
-    room = RoomFactory()
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/enter/",
-        {},  # Missing required fields
-    )
-
-    assert response.status_code == 400
-
-
-# Tests for list_waiting_participants endpoint
-
-
-def test_list_waiting_participants_anonymous():
-    """Anonymous users should not be allowed to list waiting participants."""
-    room = RoomFactory()
-    client = APIClient()
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-
-    assert response.status_code == 401
-
-
-def test_list_waiting_participants_non_owner():
-    """Non-privileged users should not be allowed to list waiting participants."""
-    room = RoomFactory()
-    user = UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-
-    assert response.status_code == 403
-
-
-def test_list_waiting_participants_public_room():
-    """Should return empty list for public rooms."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    with mock.patch(
-        "core.api.viewsets.LobbyService", autospec=True
-    ) as mocked_lobby_service:
-        response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-
-    # Verify lobby service was not instantiated
-    mocked_lobby_service.assert_not_called()
-
-    assert response.status_code == 200
-    assert response.json() == {"participants": []}
-
-
-def test_list_waiting_participants_success(settings):
-    """Should successfully return list of waiting participants."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Add participants in the lobby
-    cache.set(
-        f"mocked-cache-prefix_{room.id}_participant1",
-        {
-            "id": "participant1",
-            "username": "user1",
-            "status": "waiting",
-            "color": "#123456",
-        },
-    )
-    cache.set(
-        f"mocked-cache-prefix_{room.id}_participant2",
-        {
-            "id": "participant2",
-            "username": "user2",
-            "status": "waiting",
-            "color": "#654321",
-        },
-    )
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-
-    assert response.status_code == 200
-
-    participants = response.json().get("participants")
-    assert sorted(participants, key=lambda p: p["id"]) == [
-        {
-            "id": "participant1",
-            "username": "user1",
-            "status": "waiting",
-            "color": "#123456",
-        },
-        {
-            "id": "participant2",
-            "username": "user2",
-            "status": "waiting",
-            "color": "#654321",
-        },
-    ]
-
-
-def test_list_waiting_participants_empty(settings):
-    """Should handle case when there are no waiting participants."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    user = UserFactory()
-    # Make user the room owner
-    room.accesses.create(user=user, role="owner")
-
-    client = APIClient()
-    client.force_login(user)
-
-    settings.LOBBY_KEY_PREFIX = "mocked-cache-prefix"
-
-    # Lobby cache should be empty before the request
-    lobby_keys = cache.keys(f"mocked-cache-prefix_{room.id}_*")
-    assert not lobby_keys
-
-    response = client.get(f"/api/v1.0/rooms/{room.id}/waiting-participants/")
-
-    assert response.status_code == 200
-    assert response.json() == {"participants": []}

src/backend/core/tests/rooms/test_api_rooms_retrieve.py

@@ -12,7 +12,6 @@ import pytest
 from rest_framework.test import APIClient
 
 from ...factories import RoomFactory, UserFactory, UserResourceAccessFactory
-from ...models import RoomAccessLevel
 
 pytestmark = pytest.mark.django_db
 
@@ -22,34 +21,15 @@ def test_api_rooms_retrieve_anonymous_private_pk():
     Anonymous users should be allowed to retrieve a private room but should not be
     given any token.
     """
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory(is_public=False)
     client = APIClient()
     response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
 
     assert response.status_code == 200
     assert response.json() == {
-        "access_level": "restricted",
-        "id": str(room.id),
-        "is_administrable": False,
-        "name": room.name,
-        "slug": room.slug,
-    }
-
-
-def test_api_rooms_retrieve_anonymous_trusted_pk():
-    """
-    Anonymous users should be allowed to retrieve a room that has a trusted access_level,
-    but should not be given any token.
-    """
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-    client = APIClient()
-    response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "access_level": "trusted",
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -57,7 +37,7 @@ def test_api_rooms_retrieve_anonymous_trusted_pk():
 
 def test_api_rooms_retrieve_anonymous_private_pk_no_dashes():
     """It should be possible to get a room by its id stripped of its dashes."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory(is_public=False)
     id_no_dashes = str(room.id)
 
     client = APIClient()
@@ -65,9 +45,9 @@ def test_api_rooms_retrieve_anonymous_private_pk_no_dashes():
 
     assert response.status_code == 200
     assert response.json() == {
-        "access_level": "restricted",
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -75,15 +55,15 @@ def test_api_rooms_retrieve_anonymous_private_pk_no_dashes():
 
 def test_api_rooms_retrieve_anonymous_private_slug():
     """It should be possible to get a room by its slug."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory(is_public=False)
     client = APIClient()
     response = client.get(f"/api/v1.0/rooms/{room.slug!s}/")
 
     assert response.status_code == 200
     assert response.json() == {
-        "access_level": "restricted",
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -91,15 +71,15 @@ def test_api_rooms_retrieve_anonymous_private_slug():
 
 def test_api_rooms_retrieve_anonymous_private_slug_not_normalized():
     """Getting a room by a slug that is not normalized should work."""
-    room = RoomFactory(name="Réunion", access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory(name="Réunion", is_public=False)
     client = APIClient()
     response = client.get("/api/v1.0/rooms/Réunion/")
 
     assert response.status_code == 200
     assert response.json() == {
-        "access_level": "restricted",
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -191,18 +171,18 @@ def test_api_rooms_retrieve_anonymous_unregistered_not_allowed():
 )
 def test_api_rooms_retrieve_anonymous_public(mock_token):
     """
-    Anonymous users should be able to retrieve a room with a token provided, if the room is public.
+    Anonymous users should be able to retrieve a room with a token provided it is public.
     """
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
+    room = RoomFactory(is_public=True)
     client = APIClient()
     response = client.get(f"/api/v1.0/rooms/{room.id!s}/")
 
     assert response.status_code == 200
     expected_name = f"{room.id!s}"
     assert response.json() == {
-        "access_level": str(room.access_level),
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": True,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -229,7 +209,7 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
     which they are not related, provided the room is public.
     They should not see related users.
     """
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
+    room = RoomFactory(is_public=True)
 
     user = UserFactory()
     client = APIClient()
@@ -242,9 +222,9 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
 
     expected_name = f"{room.id!s}"
     assert response.json() == {
-        "access_level": str(room.access_level),
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": True,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -254,53 +234,7 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
         "slug": room.slug,
     }
 
-    mock_token.assert_called_once_with(
-        room=expected_name, user=user, username=None, color=None
-    )
-
-
-@mock.patch("core.utils.generate_token", return_value="foo")
-@override_settings(
-    LIVEKIT_CONFIGURATION={
-        "api_key": "key",
-        "api_secret": "secret",
-        "url": "test_url_value",
-    }
-)
-def test_api_rooms_retrieve_authenticated_trusted(mock_token):
-    """
-    Authenticated users should be allowed to retrieve a room and get a token for a room to
-    which they are not related, provided the room has a trusted access_level.
-    They should not see related users.
-    """
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-
-    user = UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.get(
-        f"/api/v1.0/rooms/{room.id!s}/",
-    )
-    assert response.status_code == 200
-
-    expected_name = f"{room.id!s}"
-    assert response.json() == {
-        "access_level": str(room.access_level),
-        "id": str(room.id),
-        "is_administrable": False,
-        "livekit": {
-            "url": "test_url_value",
-            "room": expected_name,
-            "token": "foo",
-        },
-        "name": room.name,
-        "slug": room.slug,
-    }
-
-    mock_token.assert_called_once_with(
-        room=expected_name, user=user, username=None, color=None
-    )
+    mock_token.assert_called_once_with(room=expected_name, user=user, username=None)
 
 
 def test_api_rooms_retrieve_authenticated():
@@ -308,7 +242,7 @@ def test_api_rooms_retrieve_authenticated():
     Authenticated users should be allowed to retrieve a private room to which they
     are not related but should not be given any token.
     """
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    room = RoomFactory(is_public=False)
 
     user = UserFactory()
     client = APIClient()
@@ -320,9 +254,9 @@ def test_api_rooms_retrieve_authenticated():
     assert response.status_code == 200
 
     assert response.json() == {
-        "access_level": "restricted",
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -390,9 +324,9 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries):
 
     expected_name = str(room.id)
     assert content_dict == {
-        "access_level": str(room.access_level),
         "id": str(room.id),
         "is_administrable": False,
+        "is_public": room.is_public,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -402,9 +336,7 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries):
         "slug": room.slug,
     }
 
-    mock_token.assert_called_once_with(
-        room=expected_name, user=user, username=None, color=None
-    )
+    mock_token.assert_called_once_with(room=expected_name, user=user, username=None)
 
 
 @mock.patch("core.utils.generate_token", return_value="foo")
@@ -468,9 +400,9 @@ def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries
     )
     expected_name = str(room.id)
     assert content_dict == {
-        "access_level": str(room.access_level),
         "id": str(room.id),
         "is_administrable": True,
+        "is_public": room.is_public,
         "configuration": {},
         "livekit": {
             "url": "test_url_value",
@@ -481,6 +413,4 @@ def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries
         "slug": room.slug,
     }
 
-    mock_token.assert_called_once_with(
-        room=expected_name, user=user, username=None, color=None
-    )
+    mock_token.assert_called_once_with(room=expected_name, user=user, username=None)

src/backend/core/tests/rooms/test_api_rooms_update.py

@@ -8,7 +8,6 @@ import pytest
 from rest_framework.test import APIClient
 
 from ...factories import RoomFactory, UserFactory
-from ...models import RoomAccessLevel
 
 pytestmark = pytest.mark.django_db
 
@@ -55,18 +54,17 @@ def test_api_rooms_update_members():
     not be allowed to update it.
     """
     user = UserFactory()
-    room = RoomFactory(
-        access_level=RoomAccessLevel.PUBLIC, name="Old name", users=[(user, "member")]
-    )
+    room = RoomFactory(name="Old name", users=[(user, "member")])
     client = APIClient()
     client.force_login(user)
 
+    new_is_public = not room.is_public
     response = client.put(
         f"/api/v1.0/rooms/{room.id!s}/",
         {
             "name": "New name",
             "slug": "should-be-ignored",
-            "access_level": RoomAccessLevel.RESTRICTED,
+            "is_public": new_is_public,
             "configuration": {"the_key": "the_value"},
         },
         format="json",
@@ -75,26 +73,24 @@ def test_api_rooms_update_members():
     room.refresh_from_db()
     assert room.name == "Old name"
     assert room.slug == "old-name"
-    assert room.access_level != RoomAccessLevel.RESTRICTED
+    assert room.is_public != new_is_public
     assert room.configuration == {}
 
 
 def test_api_rooms_update_administrators():
     """Administrators or owners of a room should be allowed to update it."""
     user = UserFactory()
-    room = RoomFactory(
-        access_level=RoomAccessLevel.RESTRICTED,
-        users=[(user, random.choice(["administrator", "owner"]))],
-    )
+    room = RoomFactory(users=[(user, random.choice(["administrator", "owner"]))])
     client = APIClient()
     client.force_login(user)
 
+    new_is_public = not room.is_public
     response = client.put(
         f"/api/v1.0/rooms/{room.id!s}/",
         {
             "name": "New name",
             "slug": "should-be-ignored",
-            "access_level": RoomAccessLevel.PUBLIC,
+            "is_public": new_is_public,
             "configuration": {"the_key": "the_value"},
         },
         format="json",
@@ -103,7 +99,7 @@ def test_api_rooms_update_administrators():
     room.refresh_from_db()
     assert room.name == "New name"
     assert room.slug == "new-name"
-    assert room.access_level == RoomAccessLevel.PUBLIC
+    assert room.is_public == new_is_public
     assert room.configuration == {"the_key": "the_value"}
 
 

src/backend/core/tests/rooms/test_api_rooms_webhook.py

@@ -1,191 +0,0 @@
-"""
-Test LiveKit webhook endpoint on the rooms API.
-"""
-
-# ruff: noqa: PLR0913
-# pylint: disable=R0913,W0621,R0917,W0613
-import base64
-import hashlib
-import json
-from unittest import mock
-
-import pytest
-from livekit import api
-
-from ...services.livekit_events import ActionFailedError, LiveKitEventsService
-
-
-@pytest.fixture
-def webhook_event_data():
-    """Sample webhook event data for testing."""
-    return {
-        "event": "room_finished",
-        "room": {
-            "sid": "RM_hycBMAjmt6Ub",
-            "name": "00000000-0000-0000-0000-000000000000",
-            "emptyTimeout": 300,
-            "creationTime": "1692627281",
-            "turnPassword": "2Pvdj+/WV1xV4EkB8klJ9xkXDWY=",
-            "enabledCodecs": [
-                {"mime": "audio/opus"},
-                {"mime": "video/H264"},
-                {"mime": "video/VP8"},
-            ],
-        },
-        "id": "EV_eugWmGhovZmm",
-        "createdAt": "1692985556",
-    }
-
-
-@pytest.fixture
-def serialized_event_data(webhook_event_data):
-    """Serialize event data to JSON."""
-    return json.dumps(webhook_event_data)
-
-
-@pytest.fixture
-def mock_livekit_config(settings):
-    """Mock LiveKit configuration."""
-    settings.LIVEKIT_CONFIGURATION = {
-        "api_key": "test_api_key",
-        "api_secret": "test_api_secret",
-        "url": "https://test-livekit.example.com/",
-    }
-    return settings.LIVEKIT_CONFIGURATION
-
-
-@pytest.fixture
-def auth_token(serialized_event_data, mock_livekit_config):
-    """Generate authentication token for webhook request."""
-    hash64 = base64.b64encode(
-        hashlib.sha256(serialized_event_data.encode()).digest()
-    ).decode()
-    token = api.AccessToken(
-        mock_livekit_config["api_key"], mock_livekit_config["api_secret"]
-    )
-    token.claims.sha256 = hash64
-    return token.to_jwt()
-
-
-def test_missing_auth_header(client, serialized_event_data, mock_livekit_config):
-    """Should return 401 when auth header is missing."""
-    response = client.post(
-        "/api/v1.0/rooms/webhooks-livekit/",
-        data=serialized_event_data,
-        content_type="application/json",
-    )
-
-    assert response.status_code == 401
-    assert response.json() == {
-        "status": "error",
-        "message": "Authorization header missing",
-    }
-
-
-def test_invalid_payload(client, auth_token, mock_livekit_config):
-    """Should return 400 for invalid payload."""
-    response = client.post(
-        "/api/v1.0/rooms/webhooks-livekit/",
-        data=json.dumps({"invalid": "payload"}),
-        content_type="application/json",
-        HTTP_AUTHORIZATION=auth_token,
-    )
-
-    assert response.status_code == 400
-    assert response.json() == {"status": "error", "message": "Invalid webhook payload"}
-
-
-def test_unknown_event_type(client, mock_livekit_config):
-    """Should return 422 for unknown event type."""
-    event_data = json.dumps({"event": "unknown_event_type"})
-
-    # Generate auth token for this specific payload
-    hash64 = base64.b64encode(hashlib.sha256(event_data.encode()).digest()).decode()
-    token = api.AccessToken(
-        mock_livekit_config["api_key"], mock_livekit_config["api_secret"]
-    )
-    token.claims.sha256 = hash64
-    auth_token = token.to_jwt()
-
-    response = client.post(
-        "/api/v1.0/rooms/webhooks-livekit/",
-        data=event_data,
-        content_type="application/json",
-        HTTP_AUTHORIZATION=auth_token,
-    )
-
-    assert response.status_code == 422
-    assert response.json() == {
-        "status": "error",
-        "message": "Unknown webhook type: unknown_event_type",
-    }
-
-
-@mock.patch.object(LiveKitEventsService, "_handle_room_finished")
-def test_handled_event_type(
-    mock_handler,
-    client,
-    serialized_event_data,
-    auth_token,
-    mock_livekit_config,
-):
-    """Should process valid webhook successfully."""
-    response = client.post(
-        "/api/v1.0/rooms/webhooks-livekit/",
-        data=serialized_event_data,
-        content_type="application/json",
-        HTTP_AUTHORIZATION=auth_token,
-    )
-
-    mock_handler.assert_called_once()
-    assert response.status_code == 200
-    assert response.json() == {"status": "success"}
-
-
-def test_unhandled_event_type(client, mock_livekit_config):
-    """Should return 200 for event types that have no handler."""
-    event_data = json.dumps({"event": "room_started"})
-
-    hash64 = base64.b64encode(hashlib.sha256(event_data.encode()).digest()).decode()
-    token = api.AccessToken(
-        mock_livekit_config["api_key"], mock_livekit_config["api_secret"]
-    )
-    token.claims.sha256 = hash64
-    auth_token = token.to_jwt()
-
-    response = client.post(
-        "/api/v1.0/rooms/webhooks-livekit/",
-        data=event_data,
-        content_type="application/json",
-        HTTP_AUTHORIZATION=auth_token,
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "success"}
-
-
-def test_action_error(client, mock_livekit_config):
-    """Should raise exceptions when errors occur during LiveKit webhook processing."""
-    event_data = json.dumps(
-        {
-            "event": "room_finished",
-            "room": {"sid": "RM_hycBMAjmt6Ub", "name": "invalid-uuid"},
-        }
-    )
-    hash64 = base64.b64encode(hashlib.sha256(event_data.encode()).digest()).decode()
-    token = api.AccessToken(
-        mock_livekit_config["api_key"], mock_livekit_config["api_secret"]
-    )
-    token.claims.sha256 = hash64
-    auth_token = token.to_jwt()
-
-    with pytest.raises(
-        ActionFailedError,
-        match="Failed to process room finished event",
-    ):
-        client.post(
-            "/api/v1.0/rooms/webhooks-livekit/",
-            data=event_data,
-            content_type="application/json",
-            HTTP_AUTHORIZATION=auth_token,
-        )

src/backend/core/tests/services/test_livekit_events.py

@@ -1,132 +0,0 @@
-"""
-Test LiveKitEvents service.
-"""
-# pylint: disable=W0621,W0613, W0212
-
-import uuid
-from unittest import mock
-
-import pytest
-
-from core.services.livekit_events import (
-    ActionFailedError,
-    AuthenticationError,
-    InvalidPayloadError,
-    LiveKitEventsService,
-    UnsupportedEventTypeError,
-    api,
-)
-from core.services.lobby import LobbyService
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.fixture
-def mock_livekit_config(settings):
-    """Mock LiveKit configuration."""
-    settings.LIVEKIT_CONFIGURATION = {
-        "api_key": "test_api_key",
-        "api_secret": "test_api_secret",
-        "url": "https://test-livekit.example.com/",
-    }
-    return settings.LIVEKIT_CONFIGURATION
-
-
-@pytest.fixture
-def service(mock_livekit_config):
-    """Initialize LiveKitEventsService."""
-    return LiveKitEventsService()
-
-
-@mock.patch("livekit.api.TokenVerifier")
-@mock.patch("livekit.api.WebhookReceiver")
-def test_initialization(
-    mock_webhook_receiver, mock_token_verifier, mock_livekit_config
-):
-    """Should correctly initialize the service with required dependencies."""
-
-    api_key = mock_livekit_config["api_key"]
-    api_secret = mock_livekit_config["api_secret"]
-
-    service = LiveKitEventsService()
-
-    mock_token_verifier.assert_called_once_with(api_key, api_secret)
-    mock_webhook_receiver.assert_called_once_with(mock_token_verifier.return_value)
-    assert isinstance(service.lobby_service, LobbyService)
-
-
-@mock.patch.object(LobbyService, "clear_room_cache")
-def test_handle_room_finished(mock_clear_cache, service):
-    """Should clear lobby cache when room is finished."""
-
-    mock_room_name = uuid.uuid4()
-
-    mock_data = mock.MagicMock()
-    mock_data.room.name = str(mock_room_name)
-
-    service._handle_room_finished(mock_data)
-
-    mock_clear_cache.assert_called_once_with(mock_room_name)
-
-
-@mock.patch.object(
-    LobbyService, "clear_room_cache", side_effect=Exception("Test error")
-)
-def test_handle_room_finished_error(mock_clear_cache, service):
-    """Should raise ActionFailedError when processing fails."""
-    mock_data = mock.MagicMock()
-    mock_data.room.name = "00000000-0000-0000-0000-000000000000"
-    with pytest.raises(
-        ActionFailedError, match="Failed to process room finished event"
-    ):
-        service._handle_room_finished(mock_data)
-
-
-def test_handle_room_finished_invalid_room_name(service):
-    """Should raise ActionFailedError when processing fails."""
-    mock_data = mock.MagicMock()
-    mock_data.room.name = "invalid"
-    with pytest.raises(
-        ActionFailedError, match="Failed to process room finished event"
-    ):
-        service._handle_room_finished(mock_data)
-
-
-@mock.patch.object(
-    api.WebhookReceiver, "receive", side_effect=Exception("Invalid payload")
-)
-def test_receive_invalid_payload(mock_receive, service):
-    """Should raise InvalidPayloadError for invalid payloads."""
-    mock_request = mock.MagicMock()
-    mock_request.headers = {"Authorization": "test_token"}
-    mock_request.body = b"{}"
-
-    with pytest.raises(InvalidPayloadError, match="Invalid webhook payload"):
-        service.receive(mock_request)
-
-
-def test_receive_missing_auth(service):
-    """Should raise AuthenticationError when auth header is missing."""
-    mock_request = mock.MagicMock()
-    mock_request.headers = {}
-
-    with pytest.raises(AuthenticationError, match="Authorization header missing"):
-        service.receive(mock_request)
-
-
-@mock.patch.object(api.WebhookReceiver, "receive")
-def test_receive_unsupported_event(mock_receive, service):
-    """Should raise LiveKitWebhookError for unsupported events."""
-    mock_request = mock.MagicMock()
-    mock_request.headers = {"Authorization": "test_token"}
-    mock_request.body = b"{}"
-
-    # Mock returned data with unsupported event type
-    mock_data = mock.MagicMock()
-    mock_data.event = "unsupported_event"
-    mock_receive.return_value = mock_data
-
-    with pytest.raises(
-        UnsupportedEventTypeError, match="Unknown webhook type: unsupported_event"
-    ):
-        service.receive(mock_request)

src/backend/core/tests/services/test_lobby.py

@@ -1,893 +0,0 @@
-"""
-Test lobby service.
-"""
-
-# pylint: disable=W0621,W0613, W0212, R0913
-# ruff: noqa: PLR0913
-
-import json
-import uuid
-from unittest import mock
-
-from django.conf import settings
-from django.core.cache import cache
-from django.http import HttpResponse
-
-import pytest
-from livekit.api import TwirpError
-
-from core.factories import RoomFactory
-from core.models import RoomAccessLevel
-from core.services.lobby import (
-    LobbyNotificationError,
-    LobbyParticipant,
-    LobbyParticipantNotFound,
-    LobbyParticipantParsingError,
-    LobbyParticipantStatus,
-    LobbyService,
-)
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.fixture
-def lobby_service():
-    """Return a LobbyService instance."""
-    return LobbyService()
-
-
-@pytest.fixture
-def participant_id():
-    """Return a string ID for test participant."""
-    return "test-participant-id"
-
-
-@pytest.fixture
-def username():
-    """Return a username for test participant."""
-    return "test-username"
-
-
-@pytest.fixture
-def participant_dict():
-    """Return a valid participant dictionary."""
-    return {
-        "status": "waiting",
-        "username": "test-username",
-        "id": "test-participant-id",
-        "color": "#123456",
-    }
-
-
-@pytest.fixture
-def participant_data():
-    """Return a valid LobbyParticipant instance."""
-    return LobbyParticipant(
-        status=LobbyParticipantStatus.WAITING,
-        username="test-username",
-        id="test-participant-id",
-        color="#123456",
-    )
-
-
-def test_lobby_participant_to_dict(participant_data):
-    """Test LobbyParticipant serialization to dict."""
-    result = participant_data.to_dict()
-
-    assert result["status"] == "waiting"
-    assert result["username"] == "test-username"
-    assert result["id"] == "test-participant-id"
-    assert result["color"] == "#123456"
-
-
-def test_lobby_participant_from_dict_success(participant_dict):
-    """Test successful LobbyParticipant creation from dict."""
-    participant = LobbyParticipant.from_dict(participant_dict)
-
-    assert participant.status == LobbyParticipantStatus.WAITING
-    assert participant.username == "test-username"
-    assert participant.id == "test-participant-id"
-    assert participant.color == "#123456"
-
-
-def test_lobby_participant_from_dict_default_status():
-    """Test LobbyParticipant creation with missing status defaults to UNKNOWN."""
-    data_without_status = {
-        "username": "test-username",
-        "id": "test-participant-id",
-        "color": "#123456",
-    }
-
-    participant = LobbyParticipant.from_dict(data_without_status)
-
-    assert participant.status == LobbyParticipantStatus.UNKNOWN
-    assert participant.username == "test-username"
-    assert participant.id == "test-participant-id"
-    assert participant.color == "#123456"
-
-
-def test_lobby_participant_from_dict_missing_fields():
-    """Test LobbyParticipant creation with missing fields."""
-    invalid_data = {"username": "test-username"}
-
-    with pytest.raises(LobbyParticipantParsingError, match="Invalid participant data"):
-        LobbyParticipant.from_dict(invalid_data)
-
-
-def test_lobby_participant_from_dict_invalid_status():
-    """Test LobbyParticipant creation with invalid status."""
-    invalid_data = {
-        "status": "invalid_status",
-        "username": "test-username",
-        "id": "test-participant-id",
-        "color": "#123456",
-    }
-
-    with pytest.raises(LobbyParticipantParsingError, match="Invalid participant data"):
-        LobbyParticipant.from_dict(invalid_data)
-
-
-def test_get_cache_key(lobby_service, participant_id):
-    """Test cache key generation."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key = lobby_service._get_cache_key(room.id, participant_id)
-
-    expected_key = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_{participant_id}"
-    assert cache_key == expected_key
-
-
-def test_get_or_create_participant_id_from_cookie(lobby_service):
-    """Test extracting participant ID from cookie."""
-    request = mock.Mock()
-    request.COOKIES = {settings.LOBBY_COOKIE_NAME: "existing-id"}
-
-    participant_id = lobby_service._get_or_create_participant_id(request)
-
-    assert participant_id == "existing-id"
-
-
-@mock.patch("uuid.uuid4")
-def test_get_or_create_participant_id_new(mock_uuid4, lobby_service):
-    """Test creating new participant ID when cookie is missing."""
-    mock_uuid4.return_value = mock.Mock(hex="generated-id")
-    request = mock.Mock()
-    request.COOKIES = {}
-
-    participant_id = lobby_service._get_or_create_participant_id(request)
-
-    assert participant_id == "generated-id"
-    mock_uuid4.assert_called_once()
-
-
-def test_prepare_response_existing_cookie(lobby_service, participant_id):
-    """Test response preparation with existing cookie."""
-    response = HttpResponse()
-    response.cookies[settings.LOBBY_COOKIE_NAME] = "existing-cookie"
-
-    lobby_service.prepare_response(response, participant_id)
-
-    # Verify cookie wasn't set again
-    cookie = response.cookies.get(settings.LOBBY_COOKIE_NAME)
-    assert cookie.value == "existing-cookie"
-    assert cookie.value != participant_id
-
-
-def test_prepare_response_new_cookie(lobby_service, participant_id):
-    """Test response preparation with new cookie."""
-    response = HttpResponse()
-
-    lobby_service.prepare_response(response, participant_id)
-
-    # Verify cookie was set
-    cookie = response.cookies.get(settings.LOBBY_COOKIE_NAME)
-    assert cookie is not None
-    assert cookie.value == participant_id
-    assert cookie["httponly"] is True
-    assert cookie["secure"] is True
-    assert cookie["samesite"] == "Lax"
-
-    # It's a session cookies (no max_age specified):
-    assert not cookie["max-age"]
-
-
-def test_can_bypass_lobby_public_room(lobby_service):
-    """Should return True for public rooms regardless of user auth."""
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-
-    # Anonymous user
-    user = mock.Mock()
-    user.is_authenticated = False
-    assert lobby_service.can_bypass_lobby(room, user) is True
-
-    # Authenticated user
-    user.is_authenticated = True
-    assert lobby_service.can_bypass_lobby(room, user) is True
-
-
-def test_can_bypass_lobby_trusted_room_authenticated(lobby_service):
-    """Should return True for trusted rooms with authenticated users."""
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-
-    # Authenticated user
-    user = mock.Mock()
-    user.is_authenticated = True
-    assert lobby_service.can_bypass_lobby(room, user) is True
-
-
-def test_can_bypass_lobby_trusted_room_anonymous(lobby_service):
-    """Should return False for trusted rooms with anonymous users."""
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-
-    # Anonymous user
-    user = mock.Mock()
-    user.is_authenticated = False
-    assert lobby_service.can_bypass_lobby(room, user) is False
-
-
-def test_can_bypass_lobby_private_room(lobby_service):
-    """Should return False for private rooms regardless of user auth."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-
-    # Anonymous user
-    user = mock.Mock()
-    user.is_authenticated = False
-    assert lobby_service.can_bypass_lobby(room, user) is False
-
-    # Authenticated user
-    user.is_authenticated = True
-    assert lobby_service.can_bypass_lobby(room, user) is False
-
-
-@mock.patch("core.utils.generate_livekit_config")
-def test_request_entry_public_room(
-    mock_generate_config, lobby_service, participant_id, username
-):
-    """Test requesting entry to a public room."""
-    request = mock.Mock()
-    request.user = mock.Mock()
-
-    room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-
-    mocked_participant = LobbyParticipant(
-        status=LobbyParticipantStatus.UNKNOWN,
-        username=username,
-        id=participant_id,
-        color="#123456",
-    )
-
-    lobby_service._get_or_create_participant_id = mock.Mock(return_value=participant_id)
-    lobby_service._get_participant = mock.Mock(return_value=mocked_participant)
-    mock_generate_config.return_value = {"token": "test-token"}
-
-    participant, livekit_config = lobby_service.request_entry(room, request, username)
-
-    assert participant.status == LobbyParticipantStatus.ACCEPTED
-    assert livekit_config == {"token": "test-token"}
-    mock_generate_config.assert_called_once_with(
-        room_id=str(room.id),
-        user=request.user,
-        username=username,
-        color=participant.color,
-    )
-
-    lobby_service._get_participant.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.utils.generate_livekit_config")
-def test_request_entry_trusted_room(
-    mock_generate_config, lobby_service, participant_id, username
-):
-    """Test requesting entry to a trusted room when the user is authenticated."""
-    request = mock.Mock()
-    request.user = mock.Mock()
-    request.user.is_authenticated = True
-
-    room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)
-
-    mocked_participant = LobbyParticipant(
-        status=LobbyParticipantStatus.UNKNOWN,
-        username=username,
-        id=participant_id,
-        color="#123456",
-    )
-
-    lobby_service._get_or_create_participant_id = mock.Mock(return_value=participant_id)
-    lobby_service._get_participant = mock.Mock(return_value=mocked_participant)
-    mock_generate_config.return_value = {"token": "test-token"}
-
-    participant, livekit_config = lobby_service.request_entry(room, request, username)
-
-    assert participant.status == LobbyParticipantStatus.ACCEPTED
-    assert livekit_config == {"token": "test-token"}
-    mock_generate_config.assert_called_once_with(
-        room_id=str(room.id),
-        user=request.user,
-        username=username,
-        color=participant.color,
-    )
-
-    lobby_service._get_participant.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.services.lobby.LobbyService.enter")
-def test_request_entry_new_participant(
-    mock_enter, lobby_service, participant_id, username
-):
-    """Test requesting entry for a new participant."""
-    request = mock.Mock()
-    request.COOKIES = {settings.LOBBY_COOKIE_NAME: participant_id}
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-
-    lobby_service._get_or_create_participant_id = mock.Mock(return_value=participant_id)
-    lobby_service._get_participant = mock.Mock(return_value=None)
-
-    participant_data = LobbyParticipant(
-        status=LobbyParticipantStatus.WAITING,
-        username=username,
-        id=participant_id,
-        color="#123456",
-    )
-    mock_enter.return_value = participant_data
-
-    participant, livekit_config = lobby_service.request_entry(room, request, username)
-
-    assert participant == participant_data
-    assert livekit_config is None
-    mock_enter.assert_called_once_with(room.id, participant_id, username)
-    lobby_service._get_participant.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.services.lobby.LobbyService.refresh_waiting_status")
-def test_request_entry_waiting_participant(
-    mock_refresh, lobby_service, participant_id, username
-):
-    """Test requesting entry for a waiting participant."""
-    request = mock.Mock()
-    request.COOKIES = {settings.LOBBY_COOKIE_NAME: participant_id}
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-
-    mocked_participant = LobbyParticipant(
-        status=LobbyParticipantStatus.WAITING,
-        username=username,
-        id=participant_id,
-        color="#123456",
-    )
-    lobby_service._get_or_create_participant_id = mock.Mock(return_value=participant_id)
-    lobby_service._get_participant = mock.Mock(return_value=mocked_participant)
-
-    participant, livekit_config = lobby_service.request_entry(room, request, username)
-
-    assert participant.status == LobbyParticipantStatus.WAITING
-    assert livekit_config is None
-    mock_refresh.assert_called_once_with(room.id, participant_id)
-    lobby_service._get_participant.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.utils.generate_livekit_config")
-def test_request_entry_accepted_participant(
-    mock_generate_config, lobby_service, participant_id, username
-):
-    """Test requesting entry for an accepted participant."""
-    request = mock.Mock()
-    request.user = mock.Mock()
-    request.COOKIES = {settings.LOBBY_COOKIE_NAME: participant_id}
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-
-    mocked_participant = LobbyParticipant(
-        status=LobbyParticipantStatus.ACCEPTED,
-        username=username,
-        id=participant_id,
-        color="#123456",
-    )
-    lobby_service._get_or_create_participant_id = mock.Mock(return_value=participant_id)
-    lobby_service._get_participant = mock.Mock(return_value=mocked_participant)
-
-    mock_generate_config.return_value = {"token": "test-token"}
-
-    participant, livekit_config = lobby_service.request_entry(room, request, username)
-
-    assert participant.status == LobbyParticipantStatus.ACCEPTED
-    assert livekit_config == {"token": "test-token"}
-    mock_generate_config.assert_called_once_with(
-        room_id=str(room.id),
-        user=request.user,
-        username=username,
-        color="#123456",
-    )
-    lobby_service._get_participant.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.services.lobby.cache")
-def test_refresh_waiting_status(mock_cache, lobby_service, participant_id):
-    """Test refreshing waiting status for a participant."""
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    lobby_service.refresh_waiting_status(room.id, participant_id)
-    mock_cache.touch.assert_called_once_with(
-        "mocked_cache_key", settings.LOBBY_WAITING_TIMEOUT
-    )
-
-
-# pylint: disable=R0917
-@mock.patch("core.services.lobby.cache")
-@mock.patch("core.utils.generate_color")
-@mock.patch("core.services.lobby.LobbyService.notify_participants")
-def test_enter_success(
-    mock_notify,
-    mock_generate_color,
-    mock_cache,
-    lobby_service,
-    participant_id,
-    username,
-):
-    """Test successful participant entry."""
-    mock_generate_color.return_value = "#123456"
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    participant = lobby_service.enter(room.id, participant_id, username)
-
-    mock_generate_color.assert_called_once_with(participant_id)
-    assert participant.status == LobbyParticipantStatus.WAITING
-    assert participant.username == username
-    assert participant.id == participant_id
-    assert participant.color == "#123456"
-
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-
-    mock_cache.set.assert_called_once_with(
-        "mocked_cache_key",
-        participant.to_dict(),
-        timeout=settings.LOBBY_WAITING_TIMEOUT,
-    )
-    mock_notify.assert_called_once_with(room_id=room.id)
-
-
-# pylint: disable=R0917
-@mock.patch("core.services.lobby.cache")
-@mock.patch("core.utils.generate_color")
-@mock.patch("core.services.lobby.LobbyService.notify_participants")
-def test_enter_with_notification_error(
-    mock_notify,
-    mock_generate_color,
-    mock_cache,
-    lobby_service,
-    participant_id,
-    username,
-):
-    """Test participant entry with notification error."""
-    mock_generate_color.return_value = "#123456"
-    mock_notify.side_effect = LobbyNotificationError("Error notifying")
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    participant = lobby_service.enter(room.id, participant_id, username)
-
-    mock_generate_color.assert_called_once_with(participant_id)
-    assert participant.status == LobbyParticipantStatus.WAITING
-    assert participant.username == username
-
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-
-    mock_cache.set.assert_called_once_with(
-        "mocked_cache_key",
-        participant.to_dict(),
-        timeout=settings.LOBBY_WAITING_TIMEOUT,
-    )
-
-
-@mock.patch("core.services.lobby.cache")
-def test_get_participant_not_found(mock_cache, lobby_service, participant_id):
-    """Test getting a participant that doesn't exist."""
-    mock_cache.get.return_value = None
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    result = lobby_service._get_participant(room.id, participant_id)
-
-    assert result is None
-
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-    mock_cache.get.assert_called_once_with("mocked_cache_key")
-
-
-@mock.patch("core.services.lobby.cache")
-@mock.patch("core.services.lobby.LobbyParticipant.from_dict")
-def test_get_participant_parsing_error(
-    mock_from_dict, mock_cache, lobby_service, participant_id
-):
-    """Test handling corrupted participant data."""
-    mock_cache.get.return_value = {"some": "data"}
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-    mock_from_dict.side_effect = LobbyParticipantParsingError("Invalid data")
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    result = lobby_service._get_participant(room.id, participant_id)
-
-    assert result is None
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-    mock_cache.delete.assert_called_once_with("mocked_cache_key")
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants_empty(mock_cache, lobby_service):
-    """Test listing waiting participants when none exist."""
-    mock_cache.keys.return_value = []
-
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    result = lobby_service.list_waiting_participants(room.id)
-
-    assert result == []
-    pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.keys.assert_called_once_with(pattern)
-    mock_cache.get_many.assert_not_called()
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants(mock_cache, lobby_service, participant_dict):
-    """Test listing waiting participants with valid data."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    mock_cache.keys.return_value = [cache_key]
-    mock_cache.get_many.return_value = {cache_key: participant_dict}
-
-    result = lobby_service.list_waiting_participants(room.id)
-
-    assert len(result) == 1
-    assert result[0]["status"] == "waiting"
-    assert result[0]["username"] == "test-username"
-    pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.keys.assert_called_once_with(pattern)
-    mock_cache.get_many.assert_called_once_with([cache_key])
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants_multiple(mock_cache, lobby_service):
-    """Test listing multiple waiting participants with valid data."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key1 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    cache_key2 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant2"
-
-    participant1 = {
-        "status": "waiting",
-        "username": "user1",
-        "id": "participant1",
-        "color": "#123456",
-    }
-
-    participant2 = {
-        "status": "waiting",
-        "username": "user2",
-        "id": "participant2",
-        "color": "#654321",
-    }
-
-    mock_cache.keys.return_value = [cache_key1, cache_key2]
-    mock_cache.get_many.return_value = {
-        cache_key1: participant1,
-        cache_key2: participant2,
-    }
-
-    result = lobby_service.list_waiting_participants(room.id)
-
-    assert len(result) == 2
-
-    # Verify both participants are in the result
-    assert any(p["id"] == "participant1" and p["username"] == "user1" for p in result)
-    assert any(p["id"] == "participant2" and p["username"] == "user2" for p in result)
-
-    # Verify all participants have waiting status
-    assert all(p["status"] == "waiting" for p in result)
-
-    pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.keys.assert_called_once_with(pattern)
-    mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants_corrupted_data(mock_cache, lobby_service):
-    """Test listing waiting participants with corrupted data."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    mock_cache.keys.return_value = [cache_key]
-    mock_cache.get_many.return_value = {cache_key: {"invalid": "data"}}
-
-    result = lobby_service.list_waiting_participants(room.id)
-
-    assert result == []
-    mock_cache.delete.assert_called_once_with(cache_key)
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants_partially_corrupted(mock_cache, lobby_service):
-    """Test listing waiting participants with one valid and one corrupted entry."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key1 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    cache_key2 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant2"
-
-    valid_participant = {
-        "status": "waiting",
-        "username": "user2",
-        "id": "participant2",
-        "color": "#654321",
-    }
-
-    corrupted_participant = {"invalid": "data"}
-
-    mock_cache.keys.return_value = [cache_key1, cache_key2]
-    mock_cache.get_many.return_value = {
-        cache_key1: corrupted_participant,
-        cache_key2: valid_participant,
-    }
-
-    result = lobby_service.list_waiting_participants(room.id)
-
-    # Check that only the valid participant is returned
-    assert len(result) == 1
-    assert result[0]["id"] == "participant2"
-    assert result[0]["status"] == "waiting"
-    assert result[0]["username"] == "user2"
-
-    # Verify corrupted entry was deleted
-    mock_cache.delete.assert_called_once_with(cache_key1)
-
-    # Verify both cache keys were queried
-    pattern = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_*"
-    mock_cache.keys.assert_called_once_with(pattern)
-    mock_cache.get_many.assert_called_once_with([cache_key1, cache_key2])
-
-
-@mock.patch("core.services.lobby.cache")
-def test_list_waiting_participants_non_waiting(mock_cache, lobby_service):
-    """Test listing only waiting participants (not accepted/denied)."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    cache_key1 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant1"
-    cache_key2 = f"{settings.LOBBY_KEY_PREFIX}_{room.id!s}_participant2"
-
-    participant1 = {
-        "status": "waiting",
-        "username": "user1",
-        "id": "participant1",
-        "color": "#123456",
-    }
-    participant2 = {
-        "status": "accepted",
-        "username": "user2",
-        "id": "participant2",
-        "color": "#654321",
-    }
-
-    mock_cache.keys.return_value = [cache_key1, cache_key2]
-    mock_cache.get_many.return_value = {
-        cache_key1: participant1,
-        cache_key2: participant2,
-    }
-
-    result = lobby_service.list_waiting_participants(room.id)
-
-    assert len(result) == 1
-    assert result[0]["id"] == "participant1"
-    assert result[0]["status"] == "waiting"
-
-
-@mock.patch("core.services.lobby.LobbyService._update_participant_status")
-def test_handle_participant_entry_allow(mock_update, lobby_service, participant_id):
-    """Test handling allowed participant entry."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    lobby_service.handle_participant_entry(room.id, participant_id, allow_entry=True)
-
-    mock_update.assert_called_once_with(
-        room.id,
-        participant_id,
-        status=LobbyParticipantStatus.ACCEPTED,
-        timeout=settings.LOBBY_ACCEPTED_TIMEOUT,
-    )
-
-
-@mock.patch("core.services.lobby.LobbyService._update_participant_status")
-def test_handle_participant_entry_deny(mock_update, lobby_service, participant_id):
-    """Test handling denied participant entry."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    lobby_service.handle_participant_entry(room.id, participant_id, allow_entry=False)
-
-    mock_update.assert_called_once_with(
-        room.id,
-        participant_id,
-        status=LobbyParticipantStatus.DENIED,
-        timeout=settings.LOBBY_DENIED_TIMEOUT,
-    )
-
-
-@mock.patch("core.services.lobby.cache")
-def test_update_participant_status_not_found(mock_cache, lobby_service, participant_id):
-    """Test updating status for non-existent participant."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    mock_cache.get.return_value = None
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    with pytest.raises(LobbyParticipantNotFound, match="Participant not found"):
-        lobby_service._update_participant_status(
-            room.id,
-            participant_id,
-            status=LobbyParticipantStatus.ACCEPTED,
-            timeout=60,
-        )
-
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-    mock_cache.get.assert_called_once_with("mocked_cache_key")
-
-
-@mock.patch("core.services.lobby.cache")
-@mock.patch("core.services.lobby.LobbyParticipant.from_dict")
-def test_update_participant_status_corrupted_data(
-    mock_from_dict, mock_cache, lobby_service, participant_id
-):
-    """Test updating status with corrupted participant data."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    mock_cache.get.return_value = {"some": "data"}
-    mock_from_dict.side_effect = LobbyParticipantParsingError("Invalid data")
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    with pytest.raises(LobbyParticipantParsingError):
-        lobby_service._update_participant_status(
-            room.id,
-            participant_id,
-            status=LobbyParticipantStatus.ACCEPTED,
-            timeout=60,
-        )
-
-    mock_cache.delete.assert_called_once_with("mocked_cache_key")
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.services.lobby.cache")
-def test_update_participant_status_success(mock_cache, lobby_service, participant_id):
-    """Test successful participant status update."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    participant_dict = {
-        "status": "waiting",
-        "username": "test-username",
-        "id": participant_id,
-        "color": "#123456",
-    }
-
-    mock_cache.get.return_value = participant_dict
-    lobby_service._get_cache_key = mock.Mock(return_value="mocked_cache_key")
-
-    lobby_service._update_participant_status(
-        room.id,
-        participant_id,
-        status=LobbyParticipantStatus.ACCEPTED,
-        timeout=60,
-    )
-
-    expected_data = {
-        "status": "accepted",
-        "username": "test-username",
-        "id": participant_id,
-        "color": "#123456",
-    }
-    mock_cache.set.assert_called_once_with(
-        "mocked_cache_key", expected_data, timeout=60
-    )
-    lobby_service._get_cache_key.assert_called_once_with(room.id, participant_id)
-
-
-@mock.patch("core.services.lobby.LiveKitAPI")
-def test_notify_participants_success(mock_livekit_api, lobby_service):
-    """Test successful participant notification."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    # Set up the mock LiveKitAPI and its behavior
-    mock_api_instance = mock.Mock()
-    mock_api_instance.room = mock.Mock()
-    mock_api_instance.room.send_data = mock.AsyncMock()
-    mock_api_instance.aclose = mock.AsyncMock()
-    mock_livekit_api.return_value = mock_api_instance
-
-    # Call the function
-    lobby_service.notify_participants(room.id)
-
-    # Verify the API was called correctly
-    mock_livekit_api.assert_called_once_with(**settings.LIVEKIT_CONFIGURATION)
-
-    # Verify the send_data method was called
-    mock_api_instance.room.send_data.assert_called_once()
-    send_data_request = mock_api_instance.room.send_data.call_args[0][0]
-    assert send_data_request.room == str(room.id)
-    assert (
-        json.loads(send_data_request.data.decode("utf-8"))["type"]
-        == settings.LOBBY_NOTIFICATION_TYPE
-    )
-    assert send_data_request.kind == 0  # RELIABLE mode in Livekit protocol
-
-    # Verify aclose was called
-    mock_api_instance.aclose.assert_called_once()
-
-
-@mock.patch("core.services.lobby.LiveKitAPI")
-def test_notify_participants_error(mock_livekit_api, lobby_service):
-    """Test participant notification with API error."""
-    room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    # Set up the mock LiveKitAPI and its behavior
-    mock_api_instance = mock.Mock()
-    mock_api_instance.room = mock.Mock()
-    mock_api_instance.room.send_data = mock.AsyncMock(
-        side_effect=TwirpError(msg="test error", code=123)
-    )
-    mock_api_instance.aclose = mock.AsyncMock()
-    mock_livekit_api.return_value = mock_api_instance
-
-    # Call the function and expect an exception
-    with pytest.raises(
-        LobbyNotificationError, match="Failed to notify room participants"
-    ):
-        lobby_service.notify_participants(room.id)
-
-    # Verify the API was called correctly
-    mock_livekit_api.assert_called_once_with(**settings.LIVEKIT_CONFIGURATION)
-
-    # Verify send_data was called
-    mock_api_instance.room.send_data.assert_called_once()
-
-    # Verify aclose was still called after the exception
-    mock_api_instance.aclose.assert_called_once()
-
-
-def test_clear_room_cache(settings, lobby_service):
-    """Test clearing room cache actually removes entries from cache."""
-
-    settings.LOBBY_KEY_PREFIX = "test-lobby"
-    settings.LOBBY_WAITING_TIMEOUT = 10000
-    settings.LOBBY_ACCEPTED_TIMEOUT = 10000
-    settings.LOBBY_DENIED_TIMEOUT = 10000
-
-    room_id = uuid.uuid4()
-
-    cache.set(
-        f"test-lobby_{room_id!s}_participant1",
-        LobbyParticipant(
-            status=LobbyParticipantStatus.WAITING,
-            username="participant1",
-            id="participant1",
-            color="#123456",
-        ),
-        timeout=settings.LOBBY_WAITING_TIMEOUT,
-    )
-    cache.set(
-        f"test-lobby_{room_id!s}_participant2",
-        LobbyParticipant(
-            status=LobbyParticipantStatus.ACCEPTED,
-            username="participant2",
-            id="participant2",
-            color="#123456",
-        ),
-        timeout=settings.LOBBY_ACCEPTED_TIMEOUT,
-    )
-    cache.set(
-        f"test-lobby_{room_id!s}_participant3",
-        LobbyParticipant(
-            status=LobbyParticipantStatus.DENIED,
-            username="participant3",
-            id="participant3",
-            color="#123456",
-        ),
-        timeout=settings.LOBBY_DENIED_TIMEOUT,
-    )
-
-    lobby_service.clear_room_cache(room_id)
-
-    assert cache.keys(f"test-lobby_{room_id!s}_*") == []
-
-
-def test_clear_room_empty(settings, lobby_service):
-    """Test clearing room cache when it's already empty."""
-
-    settings.LOBBY_KEY_PREFIX = "test-lobby"
-    room_id = uuid.uuid4()
-
-    assert cache.keys(f"test-lobby_{room_id!s}_*") == []
-    lobby_service.clear_room_cache(room_id)
-    assert cache.keys(f"test-lobby_{room_id!s}_*") == []

src/backend/core/tests/services/test_marketing_service.py

@@ -12,7 +12,7 @@ from django.core.exceptions import ImproperlyConfigured
 import brevo_python
 import pytest
 
-from core.services.marketing import (
+from core.services.marketing_service import (
     BrevoMarketingService,
     ContactCreationError,
     ContactData,
@@ -144,7 +144,9 @@ def clear_marketing_cache():
 def test_get_marketing_service_caching(clear_marketing_cache):
     """Test marketing service caching behavior."""
     settings.BREVO_API_KEY = "test-api-key"
-    settings.MARKETING_SERVICE_CLASS = "core.services.marketing.BrevoMarketingService"
+    settings.MARKETING_SERVICE_CLASS = (
+        "core.services.marketing_service.BrevoMarketingService"
+    )
 
     service1 = get_marketing_service()
     service2 = get_marketing_service()
@@ -161,12 +163,14 @@ def test_get_marketing_service_invalid_class(clear_marketing_cache):
         get_marketing_service()
 
 
-@mock.patch("core.services.marketing.import_string")
+@mock.patch("core.services.marketing_service.import_string")
 def test_service_instantiation_called_once(mock_import_string, clear_marketing_cache):
     """Test service class is instantiated only once."""
 
     settings.BREVO_API_KEY = "test-api-key"
-    settings.MARKETING_SERVICE_CLASS = "core.services.marketing.BrevoMarketingService"
+    settings.MARKETING_SERVICE_CLASS = (
+        "core.services.marketing_service.BrevoMarketingService"
+    )
     get_marketing_service.cache_clear()
 
     mock_service_cls = mock.Mock()

src/backend/core/tests/test_api_resource_accesses.py

@@ -16,7 +16,7 @@ from ..factories import (
     UserFactory,
     UserResourceAccessFactory,
 )
-from ..models import ResourceAccess, RoleChoices, RoomAccessLevel
+from ..models import ResourceAccess, RoleChoices
 
 pytestmark = pytest.mark.django_db
 
@@ -44,13 +44,13 @@ def test_api_room_user_accesses_list_authenticated_not_related():
     client = APIClient()
     client.force_login(user)
 
-    public_room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
+    public_room = RoomFactory(is_public=True)
     UserResourceAccessFactory(resource=public_room)
     UserResourceAccessFactory(resource=public_room, role="member")
     UserResourceAccessFactory(resource=public_room, role="administrator")
     UserResourceAccessFactory(resource=public_room, role="owner")
 
-    private_room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    private_room = RoomFactory(is_public=False)
     UserResourceAccessFactory(resource=private_room)
     UserResourceAccessFactory(resource=private_room, role="member")
     UserResourceAccessFactory(resource=private_room, role="administrator")
@@ -73,17 +73,13 @@ def test_api_room_user_accesses_list_authenticated_member():
     client = APIClient()
     client.force_login(user)
 
-    public_room = RoomFactory(
-        access_level=RoomAccessLevel.PUBLIC, users=[(user, "member")]
-    )
+    public_room = RoomFactory(is_public=True, users=[(user, "member")])
     UserResourceAccessFactory(resource=public_room)
     UserResourceAccessFactory(resource=public_room, role="member")
     UserResourceAccessFactory(resource=public_room, role="administrator")
     UserResourceAccessFactory(resource=public_room, role="owner")
 
-    private_room = RoomFactory(
-        access_level=RoomAccessLevel.RESTRICTED, users=[(user, "member")]
-    )
+    private_room = RoomFactory(is_public=False, users=[(user, "member")])
     UserResourceAccessFactory(resource=private_room)
     UserResourceAccessFactory(resource=private_room, role="member")
     UserResourceAccessFactory(resource=private_room, role="administrator")
@@ -106,7 +102,7 @@ def test_api_room_user_accesses_list_authenticated_administrator():
     client = APIClient()
     client.force_login(user)
 
-    public_room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
+    public_room = RoomFactory(is_public=True)
     public_room_accesses = (
         # Access for the logged-in user
         UserResourceAccessFactory(
@@ -119,7 +115,7 @@ def test_api_room_user_accesses_list_authenticated_administrator():
         UserResourceAccessFactory(resource=public_room, role="owner"),
     )
 
-    private_room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    private_room = RoomFactory(is_public=False)
     private_room_accesses = (
         # Access for the logged-in user
         UserResourceAccessFactory(
@@ -152,7 +148,7 @@ def test_api_room_user_accesses_list_authenticated_owner():
     client = APIClient()
     client.force_login(user)
 
-    public_room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
+    public_room = RoomFactory(is_public=True)
     public_room_accesses = (
         # Access for the logged-in user
         UserResourceAccessFactory(resource=public_room, user=user, role="owner"),
@@ -162,7 +158,7 @@ def test_api_room_user_accesses_list_authenticated_owner():
         UserResourceAccessFactory(resource=public_room, role="administrator"),
         UserResourceAccessFactory(resource=public_room, role="owner"),
     )
-    private_room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
+    private_room = RoomFactory(is_public=False)
     private_room_accesses = (
         # Access for the logged-in user
         UserResourceAccessFactory(resource=private_room, user=user, role="owner"),
@@ -256,8 +252,8 @@ def test_api_room_user_accesses_retrieve_authenticated_not_related():
     client = APIClient()
     client.force_login(user)
 
-    for access_level in [RoomAccessLevel.PUBLIC, RoomAccessLevel.RESTRICTED]:
-        room = RoomFactory(access_level=access_level)
+    for is_public in [True, False]:
+        room = RoomFactory(is_public=is_public)
         assert len(RoleChoices.choices) == 3
 
         for role, _name in RoleChoices.choices:
@@ -281,9 +277,9 @@ def test_api_room_user_accesses_retrieve_authenticated_member():
     client = APIClient()
     client.force_login(user)
 
-    for access_level in [RoomAccessLevel.PUBLIC, RoomAccessLevel.RESTRICTED]:
+    for is_public in [True, False]:
         room = RoomFactory(
-            access_level=access_level,
+            is_public=is_public,
             users=[(user, "member")],
         )
         assert len(RoleChoices.choices) == 3
@@ -309,8 +305,8 @@ def test_api_room_user_accesses_retrieve_authenticated_administrator():
     client = APIClient()
     client.force_login(user)
 
-    for access_level in [RoomAccessLevel.PUBLIC, RoomAccessLevel.RESTRICTED]:
-        room = RoomFactory(access_level=access_level, users=[(user, "administrator")])
+    for is_public in [True, False]:
+        room = RoomFactory(is_public=is_public, users=[(user, "administrator")])
         assert len(RoleChoices.choices) == 3
 
         for role, _name in RoleChoices.choices:
@@ -338,8 +334,8 @@ def test_api_room_user_accesses_retrieve_authenticated_owner():
     client = APIClient()
     client.force_login(user)
 
-    for access_level in [RoomAccessLevel.PUBLIC, RoomAccessLevel.RESTRICTED]:
-        room = RoomFactory(access_level=access_level, users=[(user, "owner")])
+    for is_public in [True, False]:
+        room = RoomFactory(is_public=is_public, users=[(user, "owner")])
         assert len(RoleChoices.choices) == 3
 
         for role, _name in RoleChoices.choices:

src/backend/core/tests/test_api_users.py

@@ -22,32 +22,10 @@ def test_api_users_list_anonymous():
     }
 
 
-def test_api_users_list_authenticated_secure(settings):
+def test_api_users_list_authenticated():
     """
-    Authenticated users should not be able to list any user
-    when ALLOW_UNSECURE_USER_LISTING is False.
+    Authenticated users should be able to list users.
     """
-    settings.ALLOW_UNSECURE_USER_LISTING = False
-    user = factories.UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    factories.UserFactory.create_batch(2)
-    response = client.get(
-        "/api/v1.0/users/",
-    )
-    assert response.status_code == 200
-    content = response.json()
-    assert len(content["results"]) == 0
-
-
-def test_api_users_list_authenticated_unsecure(settings):
-    """
-    Authenticated users should be able to list all users
-    when ALLOW_UNSECURE_USER_LISTING is True.
-    """
-    settings.ALLOW_UNSECURE_USER_LISTING = True
     user = factories.UserFactory()
 
     client = APIClient()
@@ -62,12 +40,11 @@ def test_api_users_list_authenticated_unsecure(settings):
     assert len(content["results"]) == 3
 
 
-def test_api_users_list_query_email(settings):
+def test_api_users_list_query_email():
     """
     Authenticated users should be able to list users
     and filter by email.
     """
-    settings.ALLOW_UNSECURE_USER_LISTING = True
     user = factories.UserFactory()
 
     client = APIClient()

src/backend/core/tests/test_models_rooms.py

@@ -8,7 +8,7 @@ from django.core.exceptions import ValidationError
 import pytest
 
 from core.factories import RoomFactory, UserFactory
-from core.models import Room, RoomAccessLevel
+from core.models import Room
 
 pytestmark = pytest.mark.django_db
 
@@ -80,10 +80,10 @@ def test_models_rooms_users():
     assert list(room.users.all()) == [user]
 
 
-def test_models_rooms_access_level_default():
+def test_models_rooms_is_public_default():
     """A room should be public by default."""
     room = Room.objects.create(name="room")
-    assert room.access_level == RoomAccessLevel.PUBLIC
+    assert room.is_public is True
 
 
 # Access rights methods
@@ -164,14 +164,3 @@ def test_models_rooms_access_rights_owner_direct(django_assert_num_queries):
         assert room.is_administrator(user) is True
     with django_assert_num_queries(1):
         assert room.is_owner(user) is True
-
-
-def test_models_rooms_is_public_property():
-    """Test the is_public property returns correctly based on access_level."""
-    # Test public room
-    public_room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)
-    assert public_room.is_public is True
-
-    # Test non-public room
-    private_room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)
-    assert private_room.is_public is False

src/backend/core/utils.py

@@ -14,6 +14,47 @@ from django.conf import settings
 
 from livekit.api import AccessToken, VideoGrants
 
+import secrets
+import string
+
+from django.core.cache import cache
+from cryptography.fernet import Fernet
+
+import base64
+
+
+def generate_random_passphrase(length=26):
+    """Generate a random passphrase using letters and digits"""
+    alphabet = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+
+def build_room_passphrase_key(room_id: str) -> str:
+    """Build cache key for room passphrase."""
+    return f"room_passphrase:{room_id}"
+
+def get_cached_passphrase(room_id: str) -> str:
+    """Get or generate encrypted passphrase for a room.
+
+    Retrieves existing passphrase from cache or generates,
+    encrypts and caches a new one if not found.
+    """
+    cypher = Fernet(settings.PASSPHRASE_ENCRYPTION_KEY.encode())
+    cache_key = build_room_passphrase_key(room_id)
+    encrypted_passphrase = cache.get(cache_key)
+
+    if encrypted_passphrase is None:
+        passphrase = generate_random_passphrase()
+        encrypted_passphrase = cypher.encrypt(passphrase.encode()).decode()
+        cache.set(cache_key, encrypted_passphrase, timeout=86400)  # 24 hours
+        return passphrase
+
+    return cypher.decrypt(encrypted_passphrase.encode()).decode()
+
+def clear_room_passphrase(room_id: str) -> None:
+    """Remove room passphrase from cache."""
+    cache.delete(build_room_passphrase_key(room_id))
+
 
 def generate_color(identity: str) -> str:
     """Generates a consistent HSL color based on a given identity string.
@@ -37,9 +78,7 @@ def generate_color(identity: str) -> str:
     return f"hsl({hue}, {saturation}%, {lightness}%)"
 
 
-def generate_token(
-    room: str, user, username: Optional[str] = None, color: Optional[str] = None
-) -> str:
+def generate_token(room: str, user, username: Optional[str] = None) -> str:
     """Generate a LiveKit access token for a user in a specific room.
 
     Args:
@@ -47,8 +86,6 @@ def generate_token(
         user (User): The user which request the access token.
         username (Optional[str]): The username to be displayed in the room.
                          If none, a default value will be used.
-        color (Optional[str]): The color to be displayed in the room.
-                         If none, a value will be generated
 
     Returns:
         str: The LiveKit JWT access token.
@@ -73,9 +110,6 @@ def generate_token(
         identity = str(user.sub)
         default_username = str(user)
 
-    if color is None:
-        color = generate_color(identity)
-
     token = (
         AccessToken(
             api_key=settings.LIVEKIT_CONFIGURATION["api_key"],
@@ -84,29 +118,7 @@ def generate_token(
         .with_grants(video_grants)
         .with_identity(identity)
         .with_name(username or default_username)
-        .with_metadata(json.dumps({"color": color}))
+        .with_metadata(json.dumps({"color": generate_color(identity)}))
     )
 
     return token.to_jwt()
-
-
-def generate_livekit_config(
-    room_id: str, user, username: str, color: Optional[str] = None
-) -> dict:
-    """Generate LiveKit configuration for room access.
-
-    Args:
-        room_id: Room identifier
-        user: User instance requesting access
-        username: Display name in room
-
-    Returns:
-        dict: LiveKit configuration with URL, room and access token
-    """
-    return {
-        "url": settings.LIVEKIT_CONFIGURATION["url"],
-        "room": room_id,
-        "token": generate_token(
-            room=room_id, user=user, username=username, color=color
-        ),
-    }

src/backend/meet/settings.py

@@ -73,9 +73,6 @@ class Base(Configuration):
     ALLOWED_HOSTS = values.ListValue([])
     SECRET_KEY = values.Value(None)
     SILENCED_SYSTEM_CHECKS = values.ListValue([])
-    ALLOW_UNSECURE_USER_LISTING = values.BooleanValue(
-        False, environ_name="ALLOW_UNSECURE_USER_LISTING", environ_prefix=None
-    )
 
     # Application definition
     ROOT_URLCONF = "meet.urls"
@@ -238,17 +235,7 @@ class Base(Configuration):
 
     # Cache
     CACHES = {
-        "default": {
-            "BACKEND": "django_redis.cache.RedisCache",
-            "LOCATION": values.Value(
-                "redis://redis:6379/1",
-                environ_name="REDIS_URL",
-                environ_prefix=None,
-            ),
-            "OPTIONS": {
-                "CLIENT_CLASS": "django_redis.client.DefaultClient",
-            },
-        },
+        "default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"},
     }
 
     REST_FRAMEWORK = {
@@ -265,13 +252,6 @@ class Base(Configuration):
         "PAGE_SIZE": 20,
         "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",
         "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
-        "DEFAULT_THROTTLE_RATES": {
-            "request_entry": values.Value(
-                default="150/minute",
-                environ_name="REQUEST_ENTRY_THROTTLE_RATES",
-                environ_prefix=None,
-            ),
-        },
     }
 
     SPECTACULAR_SETTINGS = {
@@ -431,8 +411,8 @@ class Base(Configuration):
         ),
         "url": values.Value(environ_name="LIVEKIT_API_URL", environ_prefix=None),
     }
-    RESOURCE_DEFAULT_ACCESS_LEVEL = values.Value(
-        "public", environ_name="RESOURCE_DEFAULT_ACCESS_LEVEL", environ_prefix=None
+    RESOURCE_DEFAULT_IS_PUBLIC = values.BooleanValue(
+        True, environ_name="RESOURCE_DEFAULT_IS_PUBLIC", environ_prefix=None
     )
     ALLOW_UNREGISTERED_ROOMS = values.BooleanValue(
         True, environ_name="ALLOW_UNREGISTERED_ROOMS", environ_prefix=None
@@ -479,12 +459,16 @@ class Base(Configuration):
 
     # Marketing and communication settings
     SIGNUP_NEW_USER_TO_MARKETING_EMAIL = values.BooleanValue(
-        False,  # When enabled, new users are automatically added to mailing list.
-        environ_name="SIGNUP_NEW_USER_TO_MARKETING_EMAIL",
+        False,
+        environ_name="SIGNUP_NEW_USERS_TO_NEWSLETTER",
         environ_prefix=None,
+        help_text=(
+            "When enabled, new users are automatically added to mailing list "
+            "for product updates, marketing communications, and customized emails. "
+        ),
     )
     MARKETING_SERVICE_CLASS = values.Value(
-        "core.services.marketing.BrevoMarketingService",
+        "core.services.marketing_service.BrevoMarketingService",
         environ_name="MARKETING_SERVICE_CLASS",
         environ_prefix=None,
     )
@@ -499,31 +483,7 @@ class Base(Configuration):
     )
     BREVO_API_CONTACT_ATTRIBUTES = values.DictValue({"VISIO_USER": True})
 
-    # Lobby configurations
-    LOBBY_KEY_PREFIX = values.Value(
-        "room_lobby", environ_name="LOBBY_KEY_PREFIX", environ_prefix=None
-    )
-    LOBBY_WAITING_TIMEOUT = values.PositiveIntegerValue(
-        3, environ_name="LOBBY_WAITING_TIMEOUT", environ_prefix=None
-    )
-    LOBBY_DENIED_TIMEOUT = values.PositiveIntegerValue(
-        5, environ_name="LOBBY_DENIED_TIMEOUT", environ_prefix=None
-    )
-    LOBBY_ACCEPTED_TIMEOUT = values.PositiveIntegerValue(
-        21600,  # 6hrs
-        environ_name="LOBBY_ACCEPTED_TIMEOUT",
-        environ_prefix=None,
-    )
-    LOBBY_NOTIFICATION_TYPE = values.Value(
-        "participantWaiting",
-        environ_name="LOBBY_NOTIFICATION_TYPE",
-        environ_prefix=None,
-    )
-    LOBBY_COOKIE_NAME = values.Value(
-        "lobbyParticipantId",
-        environ_name="LOBBY_COOKIE_NAME",
-        environ_prefix=None,
-    )
+    PASSPHRASE_ENCRYPTION_KEY = values.Value(environ_name="PASSPHRASE_ENCRYPTION_KEY", environ_prefix=None)
 
     # pylint: disable=invalid-name
     @property

src/backend/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meet"
-version = "0.1.15"
+version = "0.1.12"
 authors = [{ "name" = "DINUM", "email" = "dev@mail.numerique.gouv.fr" }]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -25,40 +25,40 @@ license = { file = "LICENSE" }
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "boto3==1.37.4",
+    "boto3==1.35.90",
     "Brotli==1.1.0",
     "brevo-python==1.1.2",
     "celery[redis]==5.4.0",
     "django-configurations==2.5.1",
-    "django-cors-headers==4.7.0",
+    "django-cors-headers==4.6.0",
     "django-countries==7.6.1",
     "django-parler==2.3",
     "redis==5.2.1",
     "django-redis==5.4.0",
-    "django-storages[s3]==1.14.5",
+    "django-storages[s3]==1.14.4",
     "django-timezone-field>=5.1",
-    "django==5.1.7",
+    "django==5.1.4",
     "djangorestframework==3.15.2",
     "drf_spectacular==0.28.0",
     "dockerflow==2024.4.2",
     "easy_thumbnails==2.10",
-    "factory_boy==3.3.3",
+    "factory_boy==3.3.1",
     "gunicorn==23.0.0",
     "jsonschema==4.23.0",
     "june-analytics-python==2.3.0",
     "markdown==3.7",
     "nested-multipart-parser==1.5.0",
-    "psycopg[binary]==3.2.5",
+    "psycopg[binary]==3.2.3",
     "PyJWT==2.10.1",
     "python-frontmatter==1.1.0",
     "requests==2.32.3",
-    "sentry-sdk==2.22.0",
+    "sentry-sdk==2.19.2",
     "url-normalize==1.4.3",
     "WeasyPrint>=60.2",
-    "whitenoise==6.9.0",
+    "whitenoise==6.8.2",
     "mozilla-django-oidc==4.0.1",
-    "livekit-api==0.8.2",
-    "aiohttp==3.11.13",
+    "livekit-api==0.8.1",
+    "aiohttp==3.11.11",
 ]
 
 [project.urls]
@@ -70,21 +70,21 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "django-extensions==3.2.3",
-    "drf-spectacular-sidecar==2025.3.1",
+    "drf-spectacular-sidecar==2024.12.1",
     "freezegun==1.5.1",
     "ipdb==0.13.13",
-    "ipython==9.0.1",
-    "pyfakefs==5.7.4",
+    "ipython==8.31.0",
+    "pyfakefs==5.7.3",
     "pylint-django==2.6.1",
-    "pylint==3.3.4",
+    "pylint==3.3.3",
     "pytest-cov==6.0.0",
-    "pytest-django==4.10.0",
-    "pytest==8.3.5",
+    "pytest-django==4.9.0",
+    "pytest==8.3.4",
     "pytest-icdiff==0.9",
     "pytest-xdist==3.6.1",
-    "responses==0.25.6",
-    "ruff==0.9.9",
-    "types-requests==2.32.0.20250301",
+    "responses==0.25.3",
+    "ruff==0.8.4",
+    "types-requests==2.32.0.20241016",
 ]
 
 [tool.setuptools]

src/frontend/Dockerfile

@@ -34,11 +34,6 @@ RUN npm run build
 # ---- Front-end image ----
 FROM nginxinc/nginx-unprivileged:1.26-alpine AS frontend-production
 
-USER root
-RUN apk update && apk upgrade libssl3 libcrypto3
-
-USER nginx
-
 # Un-privileged user running the application
 ARG DOCKER_USER
 USER ${DOCKER_USER}

src/frontend/i18next-parser.config.json

@@ -3,6 +3,6 @@
   "input": ["src/**/*.{ts,tsx}", "!src/styled-system/**/*", "!src/**/*.d.ts"],
   "output": "src/locales/$LOCALE/$NAMESPACE.json",
   "createOldCatalogs": false,
-  "locales": ["en", "fr", "de", "nl"],
+  "locales": ["en", "fr", "de"],
   "sort": true
 }

src/frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meet",
   "private": true,
-  "version": "0.1.15",
+  "version": "0.1.12",
   "type": "module",
   "scripts": {
     "dev": "panda codegen && vite",
@@ -13,48 +13,48 @@
     "check": "prettier --check ./src"
   },
   "dependencies": {
-    "@livekit/components-react": "2.8.1",
+    "@livekit/components-react": "2.6.9",
     "@livekit/components-styles": "1.1.4",
-    "@livekit/track-processors": "0.3.3",
-    "@pandacss/preset-panda": "0.53.0",
-    "@react-aria/toast": "3.0.0-beta.19",
-    "@remixicon/react": "4.6.0",
-    "@tanstack/react-query": "5.67.1",
+    "@livekit/track-processors": "0.3.2",
+    "@pandacss/preset-panda": "0.48.0",
+    "@react-aria/toast": "3.0.0-beta.18",
+    "@remixicon/react": "4.5.0",
+    "@tanstack/react-query": "5.61.3",
     "crisp-sdk-web": "1.0.25",
-    "hoofd": "1.7.3",
-    "i18next": "24.2.2",
-    "i18next-browser-languagedetector": "8.0.4",
-    "i18next-parser": "9.3.0",
+    "hoofd": "1.7.1",
+    "i18next": "24.0.2",
+    "i18next-browser-languagedetector": "8.0.0",
+    "i18next-parser": "9.0.2",
     "i18next-resources-to-backend": "1.2.1",
-    "livekit-client": "2.9.5",
-    "posthog-js": "1.225.1",
+    "livekit-client": "2.6.3",
+    "posthog-js": "1.188.0",
     "react": "18.3.1",
-    "react-aria-components": "1.6.0",
+    "react-aria-components": "1.5.0",
     "react-dom": "18.3.1",
     "react-i18next": "15.1.1",
-    "use-sound": "5.0.0",
-    "valtio": "2.1.3",
-    "wouter": "3.6.0"
+    "use-sound": "4.0.3",
+    "valtio": "2.1.2",
+    "wouter": "3.3.5"
   },
   "devDependencies": {
-    "@pandacss/dev": "0.53.0",
-    "@tanstack/eslint-plugin-query": "5.66.1",
-    "@tanstack/react-query-devtools": "5.67.1",
-    "@types/node": "22.13.9",
+    "@pandacss/dev": "0.48.0",
+    "@tanstack/eslint-plugin-query": "5.61.3",
+    "@tanstack/react-query-devtools": "5.61.3",
+    "@types/node": "22.9.3",
     "@types/react": "18.3.12",
     "@types/react-dom": "18.3.1",
-    "@typescript-eslint/eslint-plugin": "8.26.0",
-    "@typescript-eslint/parser": "8.26.0",
-    "@vitejs/plugin-react": "4.3.4",
+    "@typescript-eslint/eslint-plugin": "8.15.0",
+    "@typescript-eslint/parser": "8.15.0",
+    "@vitejs/plugin-react": "4.3.3",
     "eslint": "8.57.0",
-    "eslint-config-prettier": "10.0.2",
+    "eslint-config-prettier": "9.1.0",
     "eslint-plugin-jsx-a11y": "6.10.2",
-    "eslint-plugin-react-hooks": "5.2.0",
-    "eslint-plugin-react-refresh": "0.4.19",
-    "postcss": "8.5.3",
-    "prettier": "3.5.3",
-    "typescript": "5.8.2",
-    "vite": "6.2.0",
-    "vite-tsconfig-paths": "5.1.4"
+    "eslint-plugin-react-hooks": "5.0.0",
+    "eslint-plugin-react-refresh": "0.4.14",
+    "postcss": "8.4.49",
+    "prettier": "3.3.3",
+    "typescript": "5.7.2",
+    "vite": "5.4.11",
+    "vite-tsconfig-paths": "5.1.3"
   }
 }

src/frontend/panda.config.ts

@@ -121,32 +121,6 @@ const config: Config = {
         '50%': { opacity: '0.65' },
         '100%': { opacity: '1' },
       },
-      rotate: {
-        '0%': {
-          transform: 'rotate(0deg)',
-        },
-        '100%': {
-          transform: 'rotate(360deg)',
-        },
-      },
-      prixClipFix: {
-        '0%': {
-          clipPath: 'polygon(50% 50%, 0 0, 0 0, 0 0, 0 0, 0 0)',
-        },
-        '25%': {
-          clipPath: 'polygon(50% 50%, 0 0, 100% 0, 100% 0, 100% 0, 100% 0)',
-        },
-        '50%': {
-          clipPath:
-            'polygon(50% 50%, 0 0, 100% 0, 100% 100%, 100% 100%, 100% 100%)',
-        },
-        '75%': {
-          clipPath: 'polygon(50% 50%, 0 0, 100% 0, 100% 100%, 0 100%, 0 100%)',
-        },
-        '100%': {
-          clipPath: 'polygon(50% 50%, 0 0, 100% 0, 100% 100%, 0 100%, 0 0)',
-        },
-      },
     },
     tokens: defineTokens({
       /* we take a few things from the panda preset but for now we clear out some stuff.

src/frontend/src/App.tsx

@@ -5,7 +5,7 @@ import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
 import { QueryClientProvider } from '@tanstack/react-query'
 import { useTranslation } from 'react-i18next'
 import { useLang } from 'hoofd'
-import { Switch, Route, useLocation } from 'wouter'
+import { Switch, Route } from 'wouter'
 import { I18nProvider } from 'react-aria-components'
 import { Layout } from './layout/Layout'
 import { NotFoundScreen } from './components/NotFoundScreen'
@@ -13,35 +13,10 @@ import { routes } from './routes'
 import './i18n/init'
 import { queryClient } from '@/api/queryClient'
 import { AppInitialization } from '@/components/AppInitialization'
-import { SdkCreateButton } from './features/sdk/routes/CreateButton'
-
-const SDK_BASE_ROUTE = '/sdk'
 
 function App() {
   const { i18n } = useTranslation()
   useLang(i18n.language)
-
-  const [location] = useLocation()
-  const isSDKRoute = location.startsWith(SDK_BASE_ROUTE)
-
-  if (isSDKRoute) {
-    return (
-      <QueryClientProvider client={queryClient}>
-        <Suspense fallback={null}>
-          <I18nProvider locale={i18n.language}>
-            <Switch>
-              <Route path={SDK_BASE_ROUTE} nest>
-                <Route path="/create-button">
-                  <SdkCreateButton />
-                </Route>
-              </Route>
-            </Switch>
-          </I18nProvider>
-        </Suspense>
-      </QueryClientProvider>
-    )
-  }
-
   return (
     <QueryClientProvider client={queryClient}>
       <AppInitialization />

src/frontend/src/api/queryKeys.ts

@@ -2,6 +2,4 @@ export const keys = {
   user: 'user',
   room: 'room',
   config: 'config',
-  requestEntry: 'requestEntry',
-  waitingParticipants: 'waitingParticipants',
 }

src/frontend/src/assets/VisioIcon.tsx

@@ -1,24 +0,0 @@
-export const VisioIcon = () => {
-  return (
-    <svg
-      width="24"
-      height="24"
-      viewBox="0 0 24 24"
-      fill="none"
-      xmlns="http://www.w3.org/2000/svg"
-    >
-      <path
-        d="M0.841702 8.95427C0.75 9.42479 0.75 10.0042 0.75 10.9748V13.3096C0.75 14.5138 0.75 15.1159 0.925134 15.6549C1.08009 16.1319 1.33356 16.5709 1.6691 16.9435C2.04833 17.3647 2.56977 17.6658 3.61264 18.2679L5.6346 19.4353C6.55753 19.9681 7.07208 20.2652 7.56247 20.4081V13.2043C7.56247 12.8442 7.36578 12.5129 7.04965 12.3404L0.841702 8.95427Z"
-        fill="currentColor"
-      />
-      <path
-        d="M17.747 10.0123V13.7685C17.747 14.2878 17.9727 14.7815 18.3654 15.1214L21.0688 17.4609C21.227 17.5947 21.3912 17.7042 21.5616 17.7894C21.738 17.8685 21.9084 17.9081 22.0726 17.9081C22.4255 17.9081 22.7084 17.7925 22.9213 17.5613C23.1404 17.324 23.2499 17.0168 23.2499 16.6396V7.14866C23.2499 6.77146 23.1404 6.46726 22.9213 6.23607C22.7084 5.9988 22.4255 5.88017 22.0726 5.88017C21.9084 5.88017 21.738 5.91971 21.5616 5.9988C21.3912 6.07789 21.227 6.1874 21.0688 6.32733L18.3675 8.65759C17.9735 8.99746 17.747 9.49201 17.747 10.0123Z"
-        fill="currentColor"
-      />
-      <path
-        d="M1.74517 7.61282C1.67 7.57182 1.59117 7.54405 1.51135 7.52872C1.56171 7.46443 1.61433 7.40178 1.66914 7.34091C2.04837 6.91973 2.56981 6.61868 3.61268 6.01657L5.63464 4.84919C6.67751 4.24708 7.19894 3.94603 7.7533 3.82819C8.2438 3.72394 8.75074 3.72394 9.24124 3.82819C9.7956 3.94603 10.317 4.24708 11.3599 4.84919L13.358 6.0028C13.366 6.00738 13.374 6.01197 13.3819 6.01658C14.4248 6.61868 14.9462 6.91973 15.3255 7.34091C15.661 7.71357 15.9145 8.15259 16.0694 8.62951C16.2446 9.16852 16.2446 9.77063 16.2446 10.9748V13.3096C16.2446 14.5138 16.2446 15.1159 16.0694 15.6549C15.9145 16.1319 15.661 16.5709 15.3255 16.9435C14.9462 17.3647 14.4248 17.6657 13.382 18.2678C13.373 18.273 13.364 18.2782 13.3551 18.2833L11.3599 19.4353C10.317 20.0374 9.7956 20.3384 9.24124 20.4562C9.21846 20.4611 9.19564 20.4657 9.17279 20.4701L9.17278 13.2043C9.17278 12.255 8.65422 11.3814 7.82079 10.9268L1.74517 7.61282Z"
-        fill="currentColor"
-      />
-    </svg>
-  )
-}

src/frontend/src/components/Avatar.tsx

@@ -26,11 +26,6 @@ const avatar = cva({
         height: '100%',
       },
     },
-    notification: {
-      true: {
-        border: '2px solid white',
-      },
-    },
   },
   defaultVariants: {
     context: 'list',
@@ -42,22 +37,14 @@ export type AvatarProps = React.HTMLAttributes<HTMLDivElement> & {
   bgColor?: string
 } & RecipeVariantProps<typeof avatar>
 
-export const Avatar = ({
-  name,
-  bgColor,
-  context,
-  notification,
-  style,
-  ...props
-}: AvatarProps) => {
+export const Avatar = ({ name, bgColor, context, ...props }: AvatarProps) => {
   const initial = name?.trim()?.charAt(0) || ''
   return (
     <div
       style={{
         backgroundColor: bgColor,
-        ...style,
       }}
-      className={avatar({ context, notification })}
+      className={avatar({ context })}
       {...props}
     >
       {initial}

src/frontend/src/components/FeedbackBanner.tsx

@@ -24,7 +24,7 @@ export const FeedbackBanner = () => {
           alignItems: 'center',
         })}
       >
-        <RiErrorWarningLine size={20} aria-hidden="true" />
+        <RiErrorWarningLine size={20} />
         <Text as="p">{t('feedback.context')}</Text>
         <div
           className={css({

src/frontend/src/components/NotFoundScreen.tsx

@@ -1,19 +1,12 @@
 import { CenteredContent } from '@/layout/CenteredContent'
 import { Screen } from '@/layout/Screen'
-import { Text } from '@/primitives/Text'
 import { useTranslation } from 'react-i18next'
-import { Bold } from '@/primitives'
 
 export const NotFoundScreen = () => {
   const { t } = useTranslation()
   return (
     <Screen layout="centered">
-      <CenteredContent title={t('notFound.heading')} withBackButton>
-        <Text centered>
-          {t('notFound.body')}{' '}
-          <Bold>https://visio.numerique.gouv.fr/xxx-yyyy-zzz.</Bold>
-        </Text>
-      </CenteredContent>
+      <CenteredContent title={t('notFound.heading')} withBackButton />
     </Screen>
   )
 }

src/frontend/src/features/auth/api/fetchUser.ts

@@ -10,13 +10,7 @@ import { attemptSilentLogin, canAttemptSilentLogin } from '../utils/silentLogin'
  * Here our wrapper just returns false in that case, without triggering an error:
  * this is done to prevent unnecessary query retries with react query
  */
-export const fetchUser = (
-  opts: {
-    attemptSilent?: boolean
-  } = {
-    attemptSilent: true,
-  }
-): Promise<ApiUser | false> => {
+export const fetchUser = (): Promise<ApiUser | false> => {
   return new Promise((resolve, reject) => {
     fetchApi<ApiUser>('/users/me')
       .then(resolve)
@@ -25,7 +19,7 @@ export const fetchUser = (
         if (error instanceof ApiError && error.statusCode === 401) {
           // make sure to not resolve the promise while trying to silent login
           // so that consumers of fetchUser don't think the work already ended
-          if (opts.attemptSilent && canAttemptSilentLogin()) {
+          if (canAttemptSilentLogin()) {
             attemptSilentLogin(300)
           } else {
             resolve(false)

src/frontend/src/features/auth/api/useUser.tsx

@@ -3,30 +3,18 @@ import { keys } from '@/api/queryKeys'
 import { fetchUser } from './fetchUser'
 import { type ApiUser } from './ApiUser'
 import { useEffect } from 'react'
-import {
-  startAnalyticsSession,
-  terminateAnalyticsSession,
-} from '@/features/analytics/hooks/useAnalytics'
-import {
-  initializeSupportSession,
-  terminateSupportSession,
-} from '@/features/support/hooks/useSupport'
-import { logoutUrl } from '../utils/logoutUrl'
+import { startAnalyticsSession } from '@/features/analytics/hooks/useAnalytics'
+import { initializeSupportSession } from '@/features/support/hooks/useSupport'
 
 /**
  * returns info about currently logged-in user
  *
  * `isLoggedIn` is undefined while query is loading and true/false when it's done
  */
-export const useUser = (
-  opts: {
-    fetchUserOptions?: Parameters<typeof fetchUser>[0]
-  } = {}
-) => {
+export const useUser = () => {
   const query = useQuery({
-    // eslint-disable-next-line @tanstack/query/exhaustive-deps
     queryKey: [keys.user],
-    queryFn: () => fetchUser(opts.fetchUserOptions),
+    queryFn: fetchUser,
     staleTime: Infinity,
   })
 
@@ -37,12 +25,6 @@ export const useUser = (
     }
   }, [query.data])
 
-  const logout = () => {
-    terminateAnalyticsSession()
-    terminateSupportSession()
-    window.location.href = logoutUrl()
-  }
-
   const isLoggedIn =
     query.status === 'success' ? query.data !== false : undefined
   const isLoggedOut = isLoggedIn === false
@@ -51,6 +33,5 @@ export const useUser = (
     ...query,
     user: isLoggedOut ? undefined : (query.data as ApiUser | undefined),
     isLoggedIn,
-    logout,
   }
 }

src/frontend/src/features/auth/index.ts

@@ -1,3 +1,4 @@
 export { useUser } from './api/useUser'
 export { authUrl } from './utils/authUrl'
+export { logoutUrl } from './utils/logoutUrl'
 export { UserAware } from './components/UserAware'

src/frontend/src/features/home/routes/Home.tsx

@@ -9,16 +9,15 @@ import { useUser, UserAware } from '@/features/auth'
 import { JoinMeetingDialog } from '../components/JoinMeetingDialog'
 import { ProConnectButton } from '@/components/ProConnectButton'
 import { useCreateRoom } from '@/features/rooms'
+import { usePersistentUserChoices } from '@livekit/components-react'
 import { RiAddLine, RiLink } from '@remixicon/react'
 import { LaterMeetingDialog } from '@/features/home/components/LaterMeetingDialog'
 import { IntroSlider } from '@/features/home/components/IntroSlider'
 import { MoreLink } from '@/features/home/components/MoreLink'
-import { ReactNode, useEffect, useState } from 'react'
+import { ReactNode, useState } from 'react'
 
 import { css } from '@/styled-system/css'
 import { menuRecipe } from '@/primitives/menuRecipe.ts'
-import { usePersistentUserChoices } from '@/features/rooms/livekit/hooks/usePersistentUserChoices'
-import { SdkReverseClient } from '@/features/sdk/SdkReverseClient'
 
 const Columns = ({ children }: { children?: ReactNode }) => {
   return (
@@ -33,10 +32,10 @@ const Columns = ({ children }: { children?: ReactNode }) => {
         justifyContent: 'normal',
         padding: '0 1rem',
         width: 'calc(100% - 2rem)',
-        _motionReduce: {
+        '@media(prefers-reduced-motion: reduce)': {
           opacity: 1,
         },
-        _motionSafe: {
+        '@media(prefers-reduced-motion: no-preference)': {
           opacity: 0,
           animation: '.5s ease-in fade 0s forwards',
         },
@@ -157,18 +156,6 @@ export const Home = () => {
   const { mutateAsync: createRoom } = useCreateRoom()
   const [laterRoomId, setLaterRoomId] = useState<null | string>(null)
 
-  const { user } = useUser()
-
-  /**
-   * Used for SDK popup to close automatically.
-   */
-  useEffect(() => {
-    if (!user) {
-      return
-    }
-    SdkReverseClient.broadcastAuthentication()
-  }, [user])
-
   return (
     <UserAware>
       <Screen>

src/frontend/src/features/legalsTerms/Accessibility.tsx

@@ -1,80 +0,0 @@
-import { Screen } from '@/layout/Screen'
-import { Bold, H, P, A, Italic, Ul } from '@/primitives'
-import { css } from '@/styled-system/css'
-import { HStack } from '@/styled-system/jsx'
-import { useTranslation } from 'react-i18next'
-
-export const AccessibilityRoute = () => {
-  const { t } = useTranslation('accessibility', { keyPrefix: 'accessibility' })
-
-  const indentedStyle = css({
-    paddingLeft: '1.5rem',
-    marginLeft: '1rem',
-    borderLeft: '1px solid black',
-    marginTop: '1.5rem',
-  })
-
-  return (
-    <Screen layout="centered" headerTitle={t('title')}>
-      <HStack display={'block'} padding={'2rem'}>
-        <P dangerouslySetInnerHTML={{ __html: t('introduction') }}></P>
-
-        <H lvl={2} bold>
-          {t('declaration.title')}
-        </H>
-        <Italic>{t('declaration.date')}</Italic>
-        <P>{t('scope')}</P>
-
-        <H lvl={2} bold>
-          {t('complianceStatus.title')}
-        </H>
-        <P>{t('complianceStatus.body')}</P>
-        <H lvl={2} bold>
-          {t('improvement.title')}
-        </H>
-        <P>{t('improvement.body')}</P>
-        <Ul
-          style={{
-            marginBottom: '1rem',
-          }}
-        >
-          <li>
-            {t('improvement.contact.email').replace(
-              'visio@numerique.gouv.fr',
-              ''
-            )}
-            <A href="mailto:visio@numerique.gouv.fr" color="primary">
-              visio@numerique.gouv.fr
-            </A>
-          </li>
-          <li>{t('improvement.contact.address')}</li>
-        </Ul>
-        <P>{t('improvement.response')}</P>
-
-        <H lvl={2} bold>
-          {t('recourse.title')}
-        </H>
-        <P>{t('recourse.introduction')}</P>
-
-        <P>{t('recourse.options.intro')}</P>
-
-        <Ul>
-          <li>{t('recourse.options.option1')}</li>
-          <li>{t('recourse.options.option2')}</li>
-          <li>
-            {t('recourse.options.option3')}
-            <P className={indentedStyle}>
-              <Bold>{t('dataProtection.line1')}</Bold>
-              <br />
-              {t('dataProtection.line2')}
-              <br />
-              {t('dataProtection.line3')}
-              <br />
-              {t('dataProtection.line4')}
-            </P>
-          </li>
-        </Ul>
-      </HStack>
-    </Screen>
-  )
-}

src/frontend/src/features/legalsTerms/LegalTermsRoute.tsx

@@ -1,140 +0,0 @@
-import { Screen } from '@/layout/Screen'
-import { Bold, H, P, A } from '@/primitives'
-import { css } from '@/styled-system/css'
-import { HStack } from '@/styled-system/jsx'
-import { useTranslation } from 'react-i18next'
-
-export const LegalTermsRoute = () => {
-  const { t } = useTranslation('legals')
-
-  const indentedStyle = css({
-    paddingLeft: '1.5rem',
-    marginLeft: '1rem',
-    borderLeft: '1px solid black',
-    marginTop: '1.5rem',
-  })
-
-  return (
-    <Screen layout="centered" headerTitle={t('title')}>
-      <HStack display={'block'} padding={'2rem'}>
-        <H lvl={2}>{t('creator.title')}</H>
-        <P>{t('creator.body')}</P>
-        <H lvl={3} bold>
-          {t('creator.contact.title')}
-        </H>
-        <P>
-          {t('creator.contact.address', {
-            address: 'DINUM, 20 avenue de Ségur, 75007 Paris',
-          })}
-          <br />
-          {t('creator.contact.phone', {
-            phone: '01.71.21.01.70',
-          })}
-          <br />
-          {t('creator.contact.siret', {
-            siret: '12000101100010 (secrétariat général du gouvernement)',
-          })}
-          <br />
-          {t('creator.contact.siren', {
-            siren: '120 001 011',
-          })}
-        </P>
-
-        <H lvl={2}>{t('director.title')}</H>
-        <P>{t('director.body')}</P>
-
-        <H lvl={2}>{t('hosting.title')}</H>
-        <P>{t('hosting.body')}</P>
-        <P className={indentedStyle}>
-          <Bold>{t('hosting.address.line1')}</Bold>
-          <br />
-          {t('hosting.address.line2')}
-          <br />
-          {t('hosting.address.line3')}
-          <br />
-          {t('hosting.address.line4')}
-        </P>
-
-        <H lvl={2}>{t('accessibility.title')}</H>
-        <P>{t('accessibility.body')}</P>
-        <P>
-          <Bold>{t('accessibility.status')}</Bold>
-        </P>
-
-        <H lvl={3} bold>
-          {t('accessibility.reporting.title')}
-        </H>
-        <P>
-          {t('accessibility.reporting.body1').replace(
-            'visio@numerique.gouv.fr.',
-            ''
-          )}
-          <A href="mailto:visio@numerique.gouv.fr" color="primary">
-            visio@numerique.gouv.fr
-          </A>
-          .
-        </P>
-        <P>
-          {t('accessibility.reporting.body2').replace(
-            'https://formulaire.defenseurdesdroits.fr',
-            ''
-          )}{' '}
-          <A href="https://formulaire.defenseurdesdroits.fr" color="primary">
-            https://formulaire.defenseurdesdroits.fr
-          </A>{' '}
-          {
-            t('accessibility.reporting.body2').split(
-              'https://formulaire.defenseurdesdroits.fr'
-            )[1]
-          }
-        </P>
-        <P className={indentedStyle}>
-          <Bold>{t('accessibility.reporting.address.line1')}</Bold>
-          <br />
-          {t('accessibility.reporting.address.line2')}
-          <br />
-          {t('accessibility.reporting.address.line3')}
-        </P>
-
-        {/* Content reuse section */}
-        <H lvl={2}>{t('reuse.title')}</H>
-        <P>{t('reuse.body1')}</P>
-        <P>{t('reuse.body2')}</P>
-
-        {/* Media subsection */}
-        <H lvl={3} bold>
-          {t('reuse.media.title')}
-        </H>
-        <P>
-          {t('reuse.media.body').replace('visio@numerique.gouv.fr.', '')}
-          <A href="mailto:visio@numerique.gouv.fr" color="primary">
-            visio@numerique.gouv.fr
-          </A>
-          .
-        </P>
-        <H lvl={2}>{t('liability.title')}</H>
-        <P>{t('liability.body1')}</P>
-        <P>{t('liability.body2')}</P>
-        <P>{t('liability.body3')}</P>
-        <P>{t('liability.body4')}</P>
-        <H lvl={2}>{t('dataProtection.title')}</H>
-        <P>
-          {t('dataProtection.body').replace('dpd@pm.gouv.fr', '')}{' '}
-          <A href="mailto:dpd@pm.gouv.fr" color="primary">
-            dpd@pm.gouv.fr
-          </A>{' '}
-          {t('dataProtection.body').split('dpd@pm.gouv.fr')[1]}
-        </P>
-        <P className={indentedStyle}>
-          <Bold>{t('dataProtection.address.line1')}</Bold>
-          <br />
-          {t('dataProtection.address.line2')}
-          <br />
-          {t('dataProtection.address.line3')}
-          <br />
-          {t('dataProtection.address.line4')}
-        </P>
-      </HStack>
-    </Screen>
-  )
-}

src/frontend/src/features/legalsTerms/TermsOfService.tsx

@@ -1,371 +0,0 @@
-import { Screen } from '@/layout/Screen'
-import { Bold, H, P, A, Ul } from '@/primitives'
-import { css } from '@/styled-system/css'
-import { HStack } from '@/styled-system/jsx'
-import { useTranslation } from 'react-i18next'
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const ensureArray = (value: any) => {
-  if (Array.isArray(value)) {
-    return value
-  }
-  return []
-}
-/* eslint-enable @typescript-eslint/no-explicit-any */
-
-export const TermsOfServiceRoute = () => {
-  const { t } = useTranslation('termsOfService')
-
-  return (
-    <Screen layout="centered" headerTitle={t('terms.title')}>
-      <HStack display={'block'} padding={'2rem'}>
-        <P>{t('terms.introduction')}</P>
-
-        {/* Article 1 */}
-        <H lvl={2}>{t('terms.articles.article1.title')}</H>
-        <P>{t('terms.articles.article1.content')}</P>
-
-        {/* Article 2 */}
-        <H lvl={2}>{t('terms.articles.article2.title')}</H>
-        <P>{t('terms.articles.article2.content')}</P>
-        <Ul>
-          {ensureArray(
-            t('terms.articles.article2.purposes', { returnObjects: true })
-          ).map((purpose, index) => (
-            <li key={index}>{purpose}</li>
-          ))}
-        </Ul>
-
-        {/* Article 3 */}
-        <H lvl={2}>{t('terms.articles.article3.title')}</H>
-        {ensureArray(
-          t('terms.articles.article3.definitions', { returnObjects: true })
-        ).map((def, index) => (
-          <P key={index}>
-            <Bold>{`"${def.term}"`}</Bold> {def.definition}
-          </P>
-        ))}
-
-        {/* Article 4 */}
-        <H lvl={2}>{t('terms.articles.article4.title')}</H>
-        <P>{t('terms.articles.article4.content')}</P>
-
-        {/* Article 5 */}
-        <H lvl={2}>{t('terms.articles.article5.title')}</H>
-
-        {/* Section 5.1 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article5.sections.section1.title')}
-        </H>
-        <P>{t('terms.articles.article5.sections.section1.content')}</P>
-        <P>{t('terms.articles.article5.sections.section1.paragraph1')}</P>
-        <P>{t('terms.articles.article5.sections.section1.paragraph2')}</P>
-        <Ul>
-          {ensureArray(
-            t('terms.articles.article5.sections.section1.capabilities', {
-              returnObjects: true,
-            })
-          ).map((capability, index) => (
-            <li key={index}>{capability}</li>
-          ))}
-        </Ul>
-        <P
-          style={{
-            marginTop: '1.5rem',
-          }}
-        >
-          {t('terms.articles.article5.sections.section1.paragraph3')}
-        </P>
-
-        {/* Section 5.2 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article5.sections.section2.title')}
-        </H>
-        <P>{t('terms.articles.article5.sections.section2.content')}</P>
-        <P>{t('terms.articles.article5.sections.section2.paragraph')}</P>
-        <Ul>
-          {ensureArray(
-            t('terms.articles.article5.sections.section2.capabilities', {
-              returnObjects: true,
-            })
-          ).map((capability, index) => (
-            <li key={index}>{capability}</li>
-          ))}
-        </Ul>
-
-        {/* Article 6 */}
-        <H lvl={2}>{t('terms.articles.article6.title')}</H>
-
-        {/* Section 6.1 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article6.sections.section1.title')}
-        </H>
-        {ensureArray(
-          t('terms.articles.article6.sections.section1.paragraphs', {
-            returnObjects: true,
-          })
-        ).map((paragraph, index) => (
-          <P key={index}>{paragraph}</P>
-        ))}
-
-        {/* Section 6.2 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article6.sections.section2.title')}
-        </H>
-        {ensureArray(
-          t('terms.articles.article6.sections.section2.paragraphs', {
-            returnObjects: true,
-          })
-        ).map((paragraph, index) => (
-          <P key={index}>{paragraph}</P>
-        ))}
-
-        {/* Article 7 */}
-        <H lvl={2}>{t('terms.articles.article7.title')}</H>
-
-        {/* Section 7.1 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section1.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section1.content')}</P>
-
-        {/* Section 7.2 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section2.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section2.content')}</P>
-
-        {ensureArray(
-          t('terms.articles.article7.sections.section2.dataCategories', {
-            returnObjects: true,
-          })
-        ).map((category, catIndex) => (
-          <div key={catIndex}>
-            <P>
-              <Bold>{category.category}</Bold>
-            </P>
-            {category.items && (
-              <Ul>
-                {ensureArray(category.items).map((item, itemIndex) => (
-                  <li key={itemIndex}>{item}</li>
-                ))}
-              </Ul>
-            )}
-          </div>
-        ))}
-
-        {/* Section 7.3 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section3.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section3.content')}</P>
-        <Ul>
-          {ensureArray(
-            t('terms.articles.article7.sections.section3.purposes', {
-              returnObjects: true,
-            })
-          ).map((purpose, index) => (
-            <li key={index}>{purpose}</li>
-          ))}
-        </Ul>
-
-        {/* Section 7.4 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section4.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section4.content')}</P>
-        <Ul>
-          {ensureArray(
-            t('terms.articles.article7.sections.section4.bases', {
-              returnObjects: true,
-            })
-          ).map((basis, index) => (
-            <li key={index}>{basis}</li>
-          ))}
-        </Ul>
-
-        {ensureArray(
-          t('terms.articles.article7.sections.section4.details', {
-            returnObjects: true,
-          })
-        ).map((detail, detailIndex) => (
-          <div key={detailIndex}>
-            <P>
-              <Bold>{detail.title}</Bold>
-            </P>
-            <P>{detail.content}</P>
-            <P>{detail.legalReference}</P>
-            {detail.legalReferences && (
-              <Ul>
-                {ensureArray(detail.legalReferences).map((ref, refIndex) => (
-                  <li key={refIndex}>{ref}</li>
-                ))}
-              </Ul>
-            )}
-          </div>
-        ))}
-
-        {/* Section 7.5 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section5.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section5.content')}</P>
-
-        <table
-          className={css({
-            width: '100%',
-            borderCollapse: 'collapse',
-            border: '1px solid #ddd',
-            marginBottom: '1rem',
-          })}
-        >
-          <thead>
-            <tr>
-              <th
-                className={css({
-                  padding: '0.5rem',
-                  border: '1px solid #ddd',
-                  textAlign: 'left',
-                })}
-              >
-                {t('terms.articles.article7.sections.section5.dataType')}
-              </th>
-              <th
-                className={css({
-                  padding: '0.5rem',
-                  border: '1px solid #ddd',
-                  textAlign: 'left',
-                })}
-              >
-                {t('terms.articles.article7.sections.section5.retentionPeriod')}
-              </th>
-            </tr>
-          </thead>
-          <tbody>
-            {ensureArray(
-              t('terms.articles.article7.sections.section5.retentionTable', {
-                returnObjects: true,
-              })
-            ).map((row, rowIndex) => (
-              <tr key={rowIndex}>
-                <td
-                  className={css({
-                    padding: '0.5rem',
-                    border: '1px solid #ddd',
-                  })}
-                >
-                  {row.dataType}
-                </td>
-                <td
-                  className={css({
-                    padding: '0.5rem',
-                    border: '1px solid #ddd',
-                  })}
-                >
-                  {row.retention}
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
-
-        <P>{t('terms.articles.article7.sections.section5.additionalInfo')}</P>
-
-        {/* Section 7.6 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section6.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section6.content')}</P>
-
-        {/* Section 7.7 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section7.title')}
-        </H>
-        <P>{t('terms.articles.article7.sections.section7.content')}</P>
-        <Ul
-          style={{
-            marginBottom: '1rem',
-          }}
-        >
-          {ensureArray(
-            t('terms.articles.article7.sections.section7.rights', {
-              returnObjects: true,
-            })
-          ).map((right, index) => (
-            <li key={index}>{right}</li>
-          ))}
-        </Ul>
-
-        <P>
-          {t(
-            'terms.articles.article7.sections.section7.exerciseRights.content'
-          )}
-        </P>
-        <Ul
-          style={{
-            marginBottom: '1rem',
-          }}
-        >
-          {ensureArray(
-            t(
-              'terms.articles.article7.sections.section7.exerciseRights.methods',
-              { returnObjects: true }
-            )
-          ).map((method, index) => {
-            if (
-              typeof method === 'string' &&
-              method.includes('visio@numerique.gouv.fr')
-            ) {
-              const parts = method.split('visio@numerique.gouv.fr')
-              return (
-                <li key={index}>
-                  {parts[0]}
-                  <A href="mailto:visio@numerique.gouv.fr" color="primary">
-                    visio@numerique.gouv.fr
-                  </A>
-                  {parts[1]}
-                </li>
-              )
-            }
-            return <li key={index}>{method}</li>
-          })}
-        </Ul>
-
-        {ensureArray(
-          t('terms.articles.article7.sections.section7.additionalInfo', {
-            returnObjects: true,
-          })
-        ).map((info, index) => {
-          if (typeof info === 'string' && info.includes('Cnil')) {
-            const parts = info.split('Cnil')
-            return (
-              <P key={index}>
-                {parts[0]}
-                <A
-                  href="https://www.cnil.fr/fr/modele/courrier/sopposer-au-traitement-de-donnees"
-                  color="primary"
-                >
-                  Cnil
-                </A>
-                {parts[1]}
-              </P>
-            )
-          }
-          return <P key={index}>{info}</P>
-        })}
-
-        {/* Section 7.8 */}
-        <H lvl={3} bold>
-          {t('terms.articles.article7.sections.section8.title')}
-        </H>
-        {ensureArray(
-          t('terms.articles.article7.sections.section8.paragraphs', {
-            returnObjects: true,
-          })
-        ).map((paragraph, index) => (
-          <P key={index}>{paragraph}</P>
-        ))}
-      </HStack>
-    </Screen>
-  )
-}

src/frontend/src/features/notifications/MainNotificationToast.tsx

@@ -1,103 +1,16 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect } from 'react'
 import { useRoomContext } from '@livekit/components-react'
-import { Participant, RemoteParticipant, RoomEvent } from 'livekit-client'
-import { ChatMessage, isMobileBrowser } from '@livekit/components-core'
-import { useTranslation } from 'react-i18next'
-import { Div } from '@/primitives'
-import { NotificationType } from './NotificationType'
-import { NotificationDuration } from './NotificationDuration'
-import { decodeNotificationDataReceived } from './utils'
-import { useNotificationSound } from '@/features/notifications/hooks/useSoundNotification'
+import { Participant, RoomEvent } from 'livekit-client'
 import { ToastProvider, toastQueue } from './components/ToastProvider'
-import { WaitingParticipantNotification } from './components/WaitingParticipantNotification'
-import {
-  EMOJIS,
-  Reaction,
-} from '@/features/rooms/livekit/components/controls/ReactionsToggle'
-import {
-  ANIMATION_DURATION,
-  ReactionPortals,
-} from '@/features/rooms/livekit/components/ReactionPortal'
-import { safeParseMetadata } from '@/features/rooms/utils/safeParseMetadata'
+import { NotificationType } from './NotificationType'
+import { Div } from '@/primitives'
+import { isMobileBrowser } from '@livekit/components-core'
+import { useNotificationSound } from '@/features/notifications/hooks/useSoundNotification'
 
 export const MainNotificationToast = () => {
   const room = useRoomContext()
   const { triggerNotificationSound } = useNotificationSound()
 
-  const [reactions, setReactions] = useState<Reaction[]>([])
-  const instanceIdRef = useRef(0)
-
-  useEffect(() => {
-    const handleChatMessage = (
-      chatMessage: ChatMessage,
-      participant?: Participant | undefined
-    ) => {
-      if (!participant || participant.isLocal) return
-      triggerNotificationSound(NotificationType.MessageReceived)
-      toastQueue.add(
-        {
-          participant: participant,
-          message: chatMessage.message,
-          type: NotificationType.MessageReceived,
-        },
-        { timeout: NotificationDuration.MESSAGE }
-      )
-    }
-    room.on(RoomEvent.ChatMessage, handleChatMessage)
-    return () => {
-      room.off(RoomEvent.ChatMessage, handleChatMessage)
-    }
-  }, [room, triggerNotificationSound])
-
-  const handleEmoji = (emoji: string, participant: Participant) => {
-    if (!emoji || !EMOJIS.includes(emoji)) return
-    const id = instanceIdRef.current++
-    setReactions((prev) => [
-      ...prev,
-      {
-        id,
-        emoji,
-        participant,
-      },
-    ])
-    setTimeout(() => {
-      setReactions((prev) => prev.filter((instance) => instance.id !== id))
-    }, ANIMATION_DURATION)
-  }
-
-  useEffect(() => {
-    const handleDataReceived = (
-      payload: Uint8Array,
-      participant?: RemoteParticipant
-    ) => {
-      const notification = decodeNotificationDataReceived(payload)
-
-      if (!participant || !notification) return
-
-      switch (notification.type) {
-        case NotificationType.ParticipantMuted:
-          toastQueue.add(
-            {
-              participant,
-              type: NotificationType.ParticipantMuted,
-            },
-            { timeout: NotificationDuration.ALERT }
-          )
-          break
-        case NotificationType.ReactionReceived:
-          if (notification.data?.emoji)
-            handleEmoji(notification.data.emoji, participant)
-          break
-        default:
-          return
-      }
-    }
-    room.on(RoomEvent.DataReceived, handleDataReceived)
-    return () => {
-      room.off(RoomEvent.DataReceived, handleDataReceived)
-    }
-  }, [room])
-
   useEffect(() => {
     const showJoinNotification = (participant: Participant) => {
       if (isMobileBrowser()) {
@@ -110,7 +23,7 @@ export const MainNotificationToast = () => {
           type: NotificationType.ParticipantJoined,
         },
         {
-          timeout: NotificationDuration.PARTICIPANT_JOINED,
+          timeout: 5000,
         }
       )
     }
@@ -146,10 +59,10 @@ export const MainNotificationToast = () => {
       if (isMobileBrowser()) return
       if (participant.isLocal) return
 
-      const prevMetadata = safeParseMetadata(prevMetadataStr)
-      const metadata = safeParseMetadata(participant.metadata)
+      const prevMetadata = JSON.parse(prevMetadataStr || '{}')
+      const metadata = JSON.parse(participant.metadata || '{}')
 
-      if (prevMetadata?.raised == metadata?.raised) return
+      if (prevMetadata.raised == metadata.raised) return
 
       const existingToast = toastQueue.visibleToasts.find(
         (toast) =>
@@ -169,7 +82,7 @@ export const MainNotificationToast = () => {
             participant,
             type: NotificationType.HandRaised,
           },
-          { timeout: NotificationDuration.HAND_RAISED }
+          { timeout: 5000 }
         )
       }
     }
@@ -191,15 +104,9 @@ export const MainNotificationToast = () => {
     }
   }, [room])
 
-  // Without this line, when the component first renders,
-  // the 'notifications' namespace might not be loaded yet
-  useTranslation(['notifications'])
-
   return (
     <Div position="absolute" bottom={0} right={5} zIndex={1000}>
       <ToastProvider />
-      <WaitingParticipantNotification />
-      <ReactionPortals reactions={reactions} />
     </Div>
   )
 }

src/frontend/src/features/notifications/NotificationDuration.ts

@@ -1,15 +0,0 @@
-export enum ToastDuration {
-  SHORT = 3000,
-  MEDIUM = 4000,
-  LONG = 5000,
-  EXTRA_LONG = 7000,
-}
-
-export const NotificationDuration = {
-  ALERT: ToastDuration.SHORT,
-  MESSAGE: ToastDuration.LONG,
-  PARTICIPANT_JOINED: ToastDuration.LONG,
-  HAND_RAISED: ToastDuration.LONG,
-  LOWER_HAND: ToastDuration.EXTRA_LONG,
-  REACTION_RECEIVED: ToastDuration.SHORT,
-} as const

src/frontend/src/features/notifications/NotificationPayload.ts

@@ -1,8 +0,0 @@
-import { NotificationType } from './NotificationType'
-
-export interface NotificationPayload {
-  type: NotificationType
-  data?: {
-    emoji?: string
-  }
-}

src/frontend/src/features/notifications/NotificationType.ts

@@ -1,9 +1,5 @@
 export enum NotificationType {
   ParticipantJoined = 'participantJoined',
   HandRaised = 'handRaised',
-  ParticipantMuted = 'participantMuted',
-  MessageReceived = 'messageReceived',
-  LowerHand = 'lowerHand',
-  ReactionReceived = 'reactionReceived',
-  ParticipantWaiting = 'participantWaiting',
+  // todo - implement message received notification
 }

src/frontend/src/features/notifications/components/Toast.tsx

@@ -22,7 +22,7 @@ export const StyledToastContainer = styled('div', {
   },
 })
 
-export const StyledToast = styled('div', {
+const StyledToast = styled('div', {
   base: {
     display: 'flex',
     justifyContent: 'space-between',

src/frontend/src/features/notifications/components/ToastLowerHand.tsx

@@ -1,45 +0,0 @@
-import { useToast } from '@react-aria/toast'
-import { useRef } from 'react'
-
-import { StyledToastContainer, ToastProps } from './Toast'
-import { HStack } from '@/styled-system/jsx'
-import { useTranslation } from 'react-i18next'
-import { Button } from '@/primitives'
-
-export function ToastLowerHand({ state, ...props }: ToastProps) {
-  const { t } = useTranslation('notifications', { keyPrefix: 'lowerHand' })
-  const ref = useRef(null)
-  const { toastProps, contentProps } = useToast(props, state, ref)
-  const toast = props.toast
-
-  const handleDismiss = () => {
-    // Clear onClose handler to prevent lowering the hand when user dismisses
-    toast.onClose = undefined
-    state.close(toast.key)
-  }
-
-  return (
-    <StyledToastContainer {...toastProps} ref={ref}>
-      <HStack
-        justify="center"
-        alignItems="center"
-        {...contentProps}
-        padding={14}
-        gap={0}
-      >
-        <p>{t('auto')}</p>
-        <Button
-          size="sm"
-          variant="text"
-          style={{
-            color: '#60a5fa',
-            marginLeft: '0.5rem',
-          }}
-          onPress={() => handleDismiss()}
-        >
-          {t('dismiss')}
-        </Button>
-      </HStack>
-    </StyledToastContainer>
-  )
-}

src/frontend/src/features/notifications/components/ToastMessageReceived.tsx

@@ -1,74 +0,0 @@
-import { useToast } from '@react-aria/toast'
-import { useEffect, useRef } from 'react'
-
-import { StyledToastContainer, ToastProps } from './Toast'
-import { Text } from '@/primitives'
-import { RiMessage2Line } from '@remixicon/react'
-import { useSidePanel } from '@/features/rooms/livekit/hooks/useSidePanel'
-import { Button as RACButton } from 'react-aria-components'
-import { css } from '@/styled-system/css'
-import { useTranslation } from 'react-i18next'
-
-export function ToastMessageReceived({ state, ...props }: ToastProps) {
-  const { t } = useTranslation('notifications')
-  const ref = useRef(null)
-  const { toastProps } = useToast(props, state, ref)
-
-  const toast = props.toast
-
-  const participant = toast.content.participant
-  const message = toast.content.message
-
-  const { isChatOpen, toggleChat } = useSidePanel()
-
-  useEffect(() => {
-    if (isChatOpen) {
-      state.close(toast.key)
-    }
-  }, [isChatOpen, toast, state])
-
-  if (isChatOpen) return null
-
-  return (
-    <StyledToastContainer {...toastProps} ref={ref}>
-      <RACButton onPress={() => toggleChat()} aria-label={t('openChat')}>
-        <div
-          className={css({
-            display: 'flex',
-            flexDirection: 'column',
-            alignItems: 'start',
-            padding: '14px',
-            gap: '0.75rem',
-            textAlign: 'start',
-            width: '250px',
-            md: {
-              width: '350px',
-            },
-          })}
-        >
-          <div
-            className={css({
-              display: 'flex',
-              flexDirection: 'row',
-              justifyContent: 'start',
-              gap: '0.5rem',
-            })}
-          >
-            <RiMessage2Line
-              size={20}
-              className={css({
-                color: 'primary.300',
-                marginTop: '3px',
-              })}
-              aria-hidden="true"
-            />
-            <span>{participant.name}</span>
-          </div>
-          <Text margin={false} centered={false} wrap={'pretty'} fullWidth>
-            {message}
-          </Text>
-        </div>
-      </RACButton>
-    </StyledToastContainer>
-  )
-}

src/frontend/src/features/notifications/components/ToastMuted.tsx

@@ -1,26 +0,0 @@
-import { useToast } from '@react-aria/toast'
-import { useRef } from 'react'
-
-import { StyledToastContainer, ToastProps } from './Toast'
-import { HStack } from '@/styled-system/jsx'
-import { useTranslation } from 'react-i18next'
-
-export function ToastMuted({ state, ...props }: ToastProps) {
-  const { t } = useTranslation('notifications')
-  const ref = useRef(null)
-  const { toastProps, contentProps } = useToast(props, state, ref)
-  const participant = props.toast.content.participant
-  return (
-    <StyledToastContainer {...toastProps} ref={ref}>
-      <HStack
-        justify="center"
-        alignItems="center"
-        {...contentProps}
-        padding={14}
-        gap={0}
-      >
-        {t('muted', { name: participant.name })}
-      </HStack>
-    </StyledToastContainer>
-  )
-}

src/frontend/src/features/notifications/components/ToastRegion.tsx

@@ -1,52 +1,30 @@
 import { AriaToastRegionProps, useToastRegion } from '@react-aria/toast'
-import type { QueuedToast, ToastState } from '@react-stately/toast'
+import type { ToastState } from '@react-stately/toast'
 import { Toast } from './Toast'
 import { useRef } from 'react'
 import { NotificationType } from '../NotificationType'
 import { ToastJoined } from './ToastJoined'
 import { ToastData } from './ToastProvider'
-import { ToastRaised } from './ToastRaised'
-import { ToastMuted } from './ToastMuted'
-import { ToastMessageReceived } from './ToastMessageReceived'
-import { ToastLowerHand } from './ToastLowerHand'
+import { ToastRaised } from '@/features/notifications/components/ToastRaised.tsx'
 
 interface ToastRegionProps extends AriaToastRegionProps {
   state: ToastState<ToastData>
 }
 
-const renderToast = (
-  toast: QueuedToast<ToastData>,
-  state: ToastState<ToastData>
-) => {
-  switch (toast.content?.type) {
-    case NotificationType.ParticipantJoined:
-      return <ToastJoined key={toast.key} toast={toast} state={state} />
-
-    case NotificationType.HandRaised:
-      return <ToastRaised key={toast.key} toast={toast} state={state} />
-
-    case NotificationType.ParticipantMuted:
-      return <ToastMuted key={toast.key} toast={toast} state={state} />
-
-    case NotificationType.MessageReceived:
-      return (
-        <ToastMessageReceived key={toast.key} toast={toast} state={state} />
-      )
-
-    case NotificationType.LowerHand:
-      return <ToastLowerHand key={toast.key} toast={toast} state={state} />
-
-    default:
-      return <Toast key={toast.key} toast={toast} state={state} />
-  }
-}
-
 export function ToastRegion({ state, ...props }: ToastRegionProps) {
   const ref = useRef(null)
   const { regionProps } = useToastRegion(props, state, ref)
   return (
     <div {...regionProps} ref={ref} className="toast-region">
-      {state.visibleToasts.map((toast) => renderToast(toast, state))}
+      {state.visibleToasts.map((toast) => {
+        if (toast.content?.type === NotificationType.ParticipantJoined) {
+          return <ToastJoined key={toast.key} toast={toast} state={state} />
+        }
+        if (toast.content?.type === NotificationType.HandRaised) {
+          return <ToastRaised key={toast.key} toast={toast} state={state} />
+        }
+        return <Toast key={toast.key} toast={toast} state={state} />
+      })}
     </div>
   )
 }

src/frontend/src/features/notifications/components/WaitingParticipantNotification.tsx

@@ -1,213 +0,0 @@
-import { StyledToastContainer } from './Toast'
-import { HStack, VStack } from '@/styled-system/jsx'
-import { Avatar } from '@/components/Avatar'
-import { Button, Text } from '@/primitives'
-import { css } from '@/styled-system/css'
-import { RiInfinityLine } from '@remixicon/react'
-import { useTranslation } from 'react-i18next'
-import { useEffect, useRef, useState } from 'react'
-import { usePrevious } from '@/hooks/usePrevious'
-import { WaitingParticipant } from '@/features/rooms/api/listWaitingParticipants'
-import { useWaitingParticipants } from '@/features/rooms/hooks/useWaitingParticipants'
-import { useSidePanel } from '@/features/rooms/livekit/hooks/useSidePanel'
-
-export const NOTIFICATION_DISPLAY_DURATION = 10000
-
-export const WaitingParticipantNotification = () => {
-  const { t } = useTranslation('notifications', {
-    keyPrefix: 'waitingParticipants',
-  })
-
-  const timerRef = useRef<NodeJS.Timeout | null>(null)
-  const { isParticipantsOpen, toggleParticipants } = useSidePanel()
-  const [showQuickActionsMessage, setShowQuickActionsMessage] = useState(false)
-  const { waitingParticipants, handleParticipantEntry } =
-    useWaitingParticipants()
-  const prevWaitingParticipant = usePrevious<WaitingParticipant[] | undefined>(
-    waitingParticipants
-  )
-
-  const isParticipantListEmpty = (p?: WaitingParticipant[]) => p?.length == 0
-
-  useEffect(() => {
-    // Show notification when the first participant enters the waiting room
-    if (
-      !isParticipantListEmpty(waitingParticipants) &&
-      isParticipantListEmpty(prevWaitingParticipant) &&
-      !isParticipantsOpen
-    ) {
-      setShowQuickActionsMessage(true)
-      if (timerRef.current !== null) {
-        clearTimeout(timerRef.current)
-      }
-      timerRef.current = setTimeout(() => {
-        setShowQuickActionsMessage(false)
-        timerRef.current = null // Clear the ref when timeout completes
-      }, NOTIFICATION_DISPLAY_DURATION)
-    } else if (waitingParticipants.length !== prevWaitingParticipant?.length) {
-      // Hide notification when the participant count changes
-      setShowQuickActionsMessage(false)
-    }
-  }, [waitingParticipants, prevWaitingParticipant, isParticipantsOpen])
-
-  useEffect(() => {
-    // This cleanup function will only run when the component unmounts
-    return () => {
-      if (timerRef.current !== null) {
-        clearTimeout(timerRef.current)
-      }
-    }
-  }, [])
-
-  useEffect(() => {
-    // Hide notification when participants panel is opened
-    if (isParticipantsOpen) {
-      setShowQuickActionsMessage(false)
-    }
-  }, [isParticipantsOpen])
-
-  if (!waitingParticipants.length) return null
-
-  return (
-    <StyledToastContainer role="alert">
-      <HStack
-        padding={'1rem'}
-        gap={'1rem'}
-        role={'alertdialog'}
-        aria-label={waitingParticipants.length > 1 ? t('several') : t('one')}
-        aria-modal={false}
-      >
-        {showQuickActionsMessage ? (
-          <VStack gap={'1rem'} alignItems={'start'}>
-            <Text
-              variant="paragraph"
-              margin={false}
-              style={{
-                minWidth: '15rem',
-              }}
-            >
-              {t('one')}
-            </Text>
-            <HStack gap="1rem">
-              <Avatar
-                name={waitingParticipants[0].username}
-                bgColor={waitingParticipants[0].color}
-                context="list"
-                notification
-              />
-              <Text
-                variant="sm"
-                margin={false}
-                className={css({
-                  maxWidth: '10rem',
-                  wordBreak: 'break-word',
-                  overflowWrap: 'break-word',
-                  whiteSpace: 'normal',
-                })}
-              >
-                {waitingParticipants[0].username}
-              </Text>
-            </HStack>
-            <HStack gap="0.25rem" marginLeft="auto">
-              <Button
-                size="sm"
-                variant="text"
-                style={{
-                  color: '#60a5fa',
-                }}
-                onPress={async () => {
-                  await handleParticipantEntry(waitingParticipants[0], true)
-                  setShowQuickActionsMessage(false)
-                }}
-              >
-                {t('accept')}
-              </Button>
-              <Button
-                size="sm"
-                variant="text"
-                style={{
-                  color: '#60a5fa',
-                }}
-                onPress={() => {
-                  toggleParticipants()
-                  setShowQuickActionsMessage(false)
-                }}
-              >
-                {t('open')}
-              </Button>
-            </HStack>
-          </VStack>
-        ) : (
-          <>
-            <HStack gap={0}>
-              <Avatar
-                name={waitingParticipants[0].username}
-                bgColor={waitingParticipants[0].color}
-                context="list"
-                notification
-              />
-              {waitingParticipants.length > 1 && (
-                <Avatar
-                  name={waitingParticipants[1].username}
-                  bgColor={waitingParticipants[1].color}
-                  context="list"
-                  notification
-                  style={{
-                    marginLeft: '-10px',
-                  }}
-                />
-              )}
-              {waitingParticipants.length > 2 && (
-                <span
-                  className={css({
-                    width: '32px',
-                    height: '32px',
-                    fontSize: '1rem',
-                    color: 'white',
-                    display: 'flex',
-                    borderRadius: '50%',
-                    justifyContent: 'center',
-                    alignItems: 'center',
-                    background: 'primaryDark.100',
-                    border: '2px solid white',
-                    marginLeft: '-10px',
-                  })}
-                >
-                  {waitingParticipants.length < 102 ? (
-                    <p>+{waitingParticipants.length - 2}</p>
-                  ) : (
-                    <RiInfinityLine size={20} />
-                  )}
-                </span>
-              )}
-            </HStack>
-            <Text
-              variant="paragraph"
-              margin={false}
-              wrap={'balance'}
-              style={{
-                maxWidth: waitingParticipants.length == 1 ? '10rem' : '15rem',
-              }}
-            >
-              {waitingParticipants.length > 1 ? t('several') : t('one')}
-            </Text>
-            {!isParticipantsOpen && (
-              <Button
-                size="sm"
-                variant="text"
-                style={{
-                  color: '#60a5fa',
-                }}
-                onPress={() => {
-                  toggleParticipants()
-                }}
-              >
-                {t('open')}
-              </Button>
-            )}
-          </>
-        )}
-      </HStack>
-    </StyledToastContainer>
-  )
-}

src/frontend/src/features/notifications/utils.ts

@@ -1,51 +0,0 @@
-import { toastQueue } from './components/ToastProvider'
-import { NotificationType } from './NotificationType'
-import { NotificationDuration } from './NotificationDuration'
-import { Participant } from 'livekit-client'
-import { NotificationPayload } from './NotificationPayload'
-
-export const showLowerHandToast = (
-  participant: Participant,
-  onClose: () => void
-) => {
-  toastQueue.add(
-    {
-      participant,
-      type: NotificationType.LowerHand,
-    },
-    {
-      timeout: NotificationDuration.LOWER_HAND,
-      onClose,
-    }
-  )
-}
-
-export const closeLowerHandToasts = () => {
-  toastQueue.visibleToasts.forEach((toast) => {
-    if (toast.content.type === NotificationType.LowerHand) {
-      toastQueue.close(toast.key)
-    }
-  })
-}
-
-export const decodeNotificationDataReceived = (
-  payload: Uint8Array
-): NotificationPayload | undefined => {
-  if (!payload || !(payload instanceof Uint8Array)) {
-    throw new Error('Invalid payload: expected Uint8Array')
-  }
-  try {
-    const decoder = new TextDecoder()
-    const jsonString = decoder.decode(payload)
-    if (!jsonString || typeof jsonString !== 'string') {
-      throw new Error('Invalid decoded content')
-    }
-    // Parse with additional validation if needed
-    const parsed = JSON.parse(jsonString)
-    return parsed as NotificationPayload
-  } catch (error) {
-    // Handle errors appropriately for your application
-    console.error('Failed to decode notification payload:', error)
-    return
-  }
-}

src/frontend/src/features/rooms/api/ApiRoom.ts

@@ -1,22 +1,15 @@
-export type ApiLiveKit = {
-  url: string
-  room: string
-  token: string
-}
-
-export enum ApiAccessLevel {
-  PUBLIC = 'public',
-  TRUSTED = 'trusted',
-  RESTRICTED = 'restricted',
-}
-
 export type ApiRoom = {
   id: string
   name: string
   slug: string
+  is_public: boolean
   is_administrable: boolean
-  access_level: ApiAccessLevel
-  livekit?: ApiLiveKit
+  livekit?: {
+    url: string
+    room: string
+    token: string
+    passphrase: string
+  }
   configuration?: {
     [key: string]: string | number | boolean
   }

src/frontend/src/features/rooms/api/enterRoom.ts

@@ -1,37 +0,0 @@
-import { ApiError } from '@/api/ApiError'
-import { fetchApi } from '@/api/fetchApi'
-import { useMutation, UseMutationOptions } from '@tanstack/react-query'
-
-export interface EnterRoomParams {
-  roomId: string
-  allowEntry: boolean
-  participantId: string
-}
-
-export interface EnterRoomResponse {
-  message?: string
-}
-
-export const enterRoom = async ({
-  roomId,
-  allowEntry,
-  participantId,
-}: EnterRoomParams): Promise<EnterRoomResponse> => {
-  return await fetchApi<EnterRoomResponse>(`/rooms/${roomId}/enter/`, {
-    method: 'POST',
-    body: JSON.stringify({
-      participant_id: participantId,
-      allow_entry: allowEntry,
-    }),
-  })
-}
-
-export function useEnterRoom(
-  options?: UseMutationOptions<EnterRoomResponse, ApiError, EnterRoomParams>
-) {
-  return useMutation<EnterRoomResponse, ApiError, EnterRoomParams>({
-    mutationFn: enterRoom,
-    onSuccess: options?.onSuccess,
-    ...options,
-  })
-}

src/frontend/src/features/rooms/api/fetchRoom.ts

@@ -1,3 +1,4 @@
+import { ApiError } from '@/api/ApiError'
 import { type ApiRoom } from './ApiRoom'
 import { fetchApi } from '@/api/fetchApi'
 
@@ -10,5 +11,10 @@ export const fetchRoom = ({
 }) => {
   return fetchApi<ApiRoom>(
     `/rooms/${roomId}?username=${encodeURIComponent(username)}`
-  )
+  ).then((room) => {
+    if (!room.livekit?.token || !room.livekit?.url) {
+      throw new ApiError(500, 'LiveKit info not found')
+    }
+    return room
+  })
 }