wip unit test parser classes

sorry for this absurd commit, mybad quentin … I'll rework my commits' history before merging.

.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
@@ -83,48 +117,37 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
-  build-and-push-summary:
-    runs-on: ubuntu-latest
-    steps:
-      -
-        name: Checkout repository
-        uses: actions/checkout@v4
-      -
-        name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: lasuite/meet-summary
-      -
-        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
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: ./src/summary
-          file: ./src/summary/Dockerfile
-          target: production
-          build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
-          push: ${{ github.event_name != 'pull_request' }}
-          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

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "secrets"]
+	path = secrets
+	url = ../secrets

CHANGELOG.md

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

CODE_OF_CONDUCT.md

@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at visio@numerique.gouv.fr. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [PostHog Code of Conduct](https://github.com/PostHog/posthog/blob/master/CODE_OF_CONDUCT.md), inspired from Contributor Covenant version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -1,77 +0,0 @@
-# Contributing to the Project
-
-Thank you for taking the time to contribute! Please follow these guidelines to ensure a smooth and productive workflow. 🚀🚀🚀
-
-To get started with the project, please refer to the [README.md](https://github.com/suitenumerique/meet/blob/main/README.md) for detailed instructions.
-
-Please also check out our [dev handbook](https://suitenumerique.gitbook.io/handbook) to learn our best practices.
-
-
-## Creating an Issue
-
-When creating an issue, please provide the following details:
-
-1.  **Title**: A concise and descriptive title for the issue.
-2.  **Description**: A detailed explanation of the issue, including relevant context or screenshots if applicable.
-3.  **Steps to Reproduce**: If the issue is a bug, include the steps needed to reproduce the problem.
-4.  **Expected vs. Actual Behavior**: Describe what you expected to happen and what actually happened.
-5.  **Labels**: Add appropriate labels to categorize the issue (e.g., bug, feature request, documentation).
-
-
-## Commit Message Format
-
-All commit messages must adhere to the following format:
-
-`<gitmoji>(type) title description`
-
-*   <**gitmoji**>: Use a gitmoji to represent the purpose of the commit. For example, ✨ for adding a new feature or 🔥 for removing something, see the list here: <https://gitmoji.dev/>.
-*   **(type)**: Describe the type of change. Common types include `backend`, `frontend`, `CI`, `docker` etc...
-*   **title**: A short, descriptive title for the change, starting with a lowercase character.
-*   **description**: Include additional details about what was changed and why.
-
-### Example Commit Message
-
-```
-✨(frontend) add user authentication logic 
-
-Implemented login and signup features, and integrated OAuth2 for social login.
-```
-
-## Changelog Update
-
-Please add a line to the changelog describing your development. The changelog entry should include a brief summary of the changes, this helps in tracking changes effectively and keeping everyone informed. We usually include the title of the pull request, followed by the pull request ID to finish the log entry. The changelog line should be less than 80 characters in total.
-
-### Example Changelog Message
-```
-## [Unreleased]
-
-## Added
-
-- ✨(frontend) add AI to the project #321
-```
-
-## Pull Requests
-
-It is nice to add information about the purpose of the pull request to help reviewers understand the context and intent of the changes. If you can, add some pictures or a small video to show the changes.
-
-### Don't forget to:
-- check your commits
-- check the linting: `make lint && make frontend-lint`
-- check the tests: `make test`
-- add a changelog entry
-
-Once all the required tests have passed, you can request a review from the project maintainers.
-
-## Code Style
-
-Please maintain consistency in code style. Run any linting tools available to make sure the code is clean and follows the project's conventions.
-
-## Tests
-
-Make sure that all new features or fixes have corresponding tests. Run the test suite before pushing your changes to ensure that nothing is broken.
-
-## Asking for Help
-
-If you need any help while contributing, feel free to open a discussion or ask for guidance in the issue tracker. We are more than happy to assist!
-
-Thank you for your contributions! 👍

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-2023 DINUM/Etalab
+Copyright (c) 2023 Direction Interministérielle du Numérique - Gouvernement Français
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021-2023 DINUM/Etalab
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

LICENSES/LICENSE.Etalab-2.0.md

@@ -1,79 +0,0 @@
-# LICENCE OUVERTE 2.0/OPEN LICENCE 2.0
-
-## Réutilisation de l’« Information » sous  cette licence
-
-Le « Concédant » concède au « Réutilisateur » un droit non exclusif et gratuit de libre  « Réutilisation » de l’« Information » objet de la présente licence, à des fins commerciales ou non, dans le monde entier et pour une durée illimitée, dans les conditions exprimées ci-dessous.
-
-**Le « Réutilisateur » est libre de réutiliser l’« Information » :**
-
--   de la communiquer, la reproduire, la copier ;
--   de l’adapter, la modifier, l’extraire et la transformer, notamment pour créer des « Informations dérivées » ;
--   de la diffuser, la redistribuer, la publier et la transmettre, de l’exploiter à titre commercial, par exemple en la combinant avec d’autres informations, ou en l’incluant dans votre propre produit ou application.
-
-**Sous réserve de :**
-
--   mentionner la paternité de l’«Information» : sa source (a minima le nom du  « Concédant ») et la date de la dernière mise à jour de l’« Information » réutilisée.
-
-Le « Réutilisateur » peut notamment s’ acquitter de cette condition en indiquant l’adresse (URL) renvoyant vers « l’Information » et assurant une mention effective de sa paternité.
-
-**Par exemple :**
-
-Dans le cas d’une réutilisation de la base SIRENE de l’INSEE, mentionner l’URL du « Concédant » : www.insee.fr + la date de dernière mise à jour de l’Information réutilisée.
-
-Cette mention de paternité ne doit ni conférer un caractère officiel à la « Réutilisation » de l’« Information », ni suggérer une quelconque reconnaissance ou caution par le « Concédant », ou par toute autre entité publique, du « Réutilisateur » ou de sa « Réutilisation ».
-
-## Données à caractère personnel
-
-L’« Information » mise à disposition peut contenir des « Données à caractère personnel » pouvant faire l’objet d’une « Réutilisation ». Alors, le « Concédant » informe le « Réutilisateur » (par tous moyens) de leur présence, l’ « Information » peut être librement réutilisée, sans faire obstacle aux libertés accordées par la présente licence, à condition de respecter le cadre légal relatif à la protection des données à caractère personnel.
-
-## Droits de propriété intellectuelle
-
-Il est garanti au « Réutilisateur » que l’ « Information » ne contient pas de « Droits de propriété intellectuelle »  appartenant à des tiers qui pourraient faire obstacle aux libertés qui lui sont accordées par la présente licence.
-
-Les éventuels « Droits de propriété intellectuelle » détenus par le « Concédant » sur l’ « Information » ne font pas obstacle aux libertés qui sont accordées par la présente licence. Lorsque le « Concédant » détient des « Droits de propriété intellectuelle » » sur l’ « Information », il les cède au « Réutilisateur » de façon non exclusive, à titre gracieux, pour le monde entier, pour toute la durée des « Droits de propriété intellectuelle », et le « Réutilisateur »  peut en faire tout usage conformément aux libertés et aux conditions définies par la présente licence.
-
-## Responsabilité
-
-L’ «Information» est mise à disposition telle que produite ou reçue, sans autre garantie expresse ou tacite qui n’est pas prévue par la présente licence. L’absence de défauts ou d’erreurs éventuellement contenues dans l’ «Information», comme la fourniture continue de l’ « Information » n’est pas garantie par le «Concédant». Il ne peut être tenu pour responsable de toute perte, préjudice ou dommage de quelque sorte causé à des tiers du fait de la « Réutilisation ».
-
-Le « Réutilisateur » est seul responsable de la « Réutilisation » de l’« Information ».
-
-La « Réutilisation » ne doit pas induire en erreur des tiers quant au contenu de l’« Information », sa source et sa date de mise à jour.
-
-## Droit applicable
-
-La présente licence est régie par le droit français.
-
-### Compatibilité de la présente licence
-
-Elle a été conçue pour être compatible avec toute licence libre qui exige _a minima_ la mention de paternité. Elle est notamment compatible avec la version antérieure de la présente licence ainsi qu’avec les licences « Open Government Licence » (OGL) du Royaume-Uni, « Creative Commons Attribution » (CC-BY) de Creative Commons et « Open Data Commons Attribution » (ODC-BY) de l’Open Knowledge Foundation.
-
-## Définitions
-
-Sont considérés, au sens de la présente licence comme :
-
--   Le « **Concédant** » : toute personne concédant un droit de « Réutilisation » sur l’« Information » dans les libertés et les conditions prévues par la présente licence.
--   L’« **Information** » :
-    -   toute information publique figurant dans des documents communiqués ou publiés par une administration mentionnée au premier alinéa de l’article L.300-2 du CRPA ;
-    -   toute information mise à disposition par toute personne selon les termes et conditions de la présente licence.
--   La « **Réutilisation** » : l’utilisation de l’« Information » à d’autres fins que celles pour lesquelles elle a été produite ou reçue.
--   Le « **Réutilisateur** » : toute personne qui réutilise les « Informations »  conformément aux conditions de la présente licence.
--   Des « **Données à caractère personnel** » : toute information se rapportant à une personne physique identifiée ou identifiable, pouvant être identifiée directement ou indirectement. Leur « Réutilisation » est subordonnée au respect du cadre juridique en vigueur.
--   Une « **Information dérivée** » : toute nouvelle donnée ou information créées directement à partir de l’« Information » ou à partir d’une combinaison  de l’ « Information » et d’autres données ou informations non  soumises à cette licence.
--   Les « **Droits de propriété intellectuelle** » : tous droits identifiés comme tels par le Code de la propriété intellectuelle (droit d’auteur, droits voisins au droit d’auteur, droit sui generis des producteurs de bases de données).
-
-## À propos de cette licence
-
-La présente licence a vocation à être utilisée par les administrations pour la réutilisation de leurs informations publiques. Elle peut également être utilisée par toute personne souhaitant mettre à disposition de l’« Information » dans les conditions définies par la présente licence
-
-La France est dotée d’un cadre juridique global visant à une diffusion spontanée par les administrations de leurs informations publiques afin d’en permettre la plus large réutilisation.
-
-Le droit de la « Réutilisation » de l’« Information » des administrations est régi par le code des relations entre le public et l’administration (CRPA) et, le cas échéant, le code du patrimoine (livre II relatif aux archives).
-
-Cette licence facilite la réutilisation libre et gratuite des informations publiques et figure parmi les licences qui peuvent être utilisées par l’administration en vertu du décret pris en application de l’article L.323-2 du CRPA.
-
-Etalab est la mission chargée, sous l’autorité du Premier ministre, d’ouvrir le plus grand nombre de données publiques des administrations de l’État et de ses établissements publics. Elle a réalisé la Licence Ouverte pour faciliter la réutilisation libre et gratuite de ces informations publiques, telles que définies par l’article L321-1 du CRPA.
-
-Cette licence est une version 2.0 de la Licence Ouverte.
-
-Etalab se réserve la faculté de proposer de nouvelles versions de la Licence Ouverte. Cependant, les « Réutilisateurs » pourront continuer à réutiliser les informations disponibles sous cette licence s’ils le souhaitent.

Makefile

@@ -88,20 +88,10 @@ bootstrap: \
 .PHONY: bootstrap
 
 # -- Docker/compose
-build: ## build the project containers
-	@$(MAKE) build-backend
-	@$(MAKE) build-frontend
+build: ## build the app-dev container
+	@$(COMPOSE) build app-dev --no-cache
 .PHONY: build
 
-build-backend: ## build the app-dev container
-	@$(COMPOSE) build app-dev
-.PHONY: build-backend
-
-
-build-frontend: ## build the frontend container
-	@$(COMPOSE) build frontend
-.PHONY: build-frontend
-
 down: ## stop and remove containers, networks, images, and volumes
 	@$(COMPOSE) down
 .PHONY: down
@@ -110,16 +100,10 @@ logs: ## display app-dev logs (follow mode)
 	@$(COMPOSE) logs -f app-dev
 .PHONY: logs
 
-run-backend: ## start only the backend application and all needed services
+run: ## start the wsgi (production) and development server
 	@$(COMPOSE) up --force-recreate -d celery-dev
 	@echo "Wait for postgresql to be up..."
 	@$(WAIT_DB)
-.PHONY: run-backend
-
-run:
-run: ## start the wsgi (production) and development server
-	@$(MAKE) run-backend
-	@$(COMPOSE) up --force-recreate -d frontend
 .PHONY: run
 
 status: ## an alias for "docker compose ps"
@@ -130,25 +114,6 @@ stop: ## stop the development server using Docker
 	@$(COMPOSE) stop
 .PHONY: stop
 
-# -- Front
-
-frontend-development-install: ## install the frontend locally
-	cd $(PATH_FRONT) && npm i
-.PHONY: frontend-development-install
-
-frontend-lint: ## run the frontend linter
-	cd $(PATH_FRONT) && npm run lint
-.PHONY: frontend-lint
-
-frontend-format: ## run the frontend format
-	cd $(PATH_FRONT) && npm run format
-.PHONY: frontend-format
-
-run-frontend-development: ## run the frontend in development mode
-	@$(COMPOSE) stop frontend
-	cd $(PATH_FRONT) && npm run dev
-.PHONY: run-frontend-development
-
 # -- Backend
 
 demo: ## flush db then create a demo for load testing purpose
@@ -336,14 +301,8 @@ 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
+	kubectl config set-context --current --namespace=meet
 	tilt up -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster
 
-start-tilt-keycloak: ## start the kubernetes cluster using kind, without Pro Connect for authentication, use keycloak
-	DEV_ENV=dev-keycloak tilt up -f ./bin/Tiltfile
-.PHONY: build-k8s-cluster

README.md

@@ -1,119 +1,155 @@
-<p align="center">
-  <img alt="posthoglogo" src="./docs/assets/visio-logo.png" maxWidth="100%">
-</p>
+# Meet
+
+Meet is a simple video and phone conferencing tool, powered by [LiveKit](https://livekit.io/).
+
+Meet is built on top of [Django Rest
+Framework](https://www.django-rest-framework.org/) and [Vite.js](https://vitejs.dev/).
+
+## Getting started
+
+### Prerequisite
+
+#### Docker
+
+Make sure you have a recent version of Docker and [Docker
+Compose](https://docs.docker.com/compose/install) installed on your laptop:
+
+```bash
+$ docker -v
+  Docker version 20.10.2, build 2291f61
+
+$ docker compose -v
+  docker compose version 1.27.4, build 40524192
+```
+
+> ⚠️ You may need to run the following commands with `sudo` but this can be
+> avoided by assigning your user to the `docker` group.
+
+#### LiveKit CLI
+
+Install LiveKit CLI, which provides utilities for interacting with the LiveKit ecosystem (including the server, egress, and more), please follow the instructions available in the [official repository](https://github.com/livekit/livekit-cli).
+
+### Project bootstrap
+
+The easiest way to start working on the project is to use GNU Make:
+
+```bash
+$ make bootstrap FLUSH_ARGS='--no-input'
+```
+
+Then you can access to the project in development mode by going to http://localhost:3000.
+You will be prompted to log in, the default credentials are:
+```bash
+username: meet
+password: meet
+```
+---
+
+This command builds the `app` container, installs dependencies, performs
+database migrations and compile translations. It's a good idea to use this
+command each time you are pulling code from the project repository to avoid
+dependency-related or migration-related issues.
+
+Your Docker services should now be up and running 🎉
+
+[FIXME] Explain how to run the frontend project.
+
+### Configure LiveKit CLI
+
+For the optimal DX, create a default project named `meet` to use with `livekit-cli` commands:
+```bash
+$ livekit-cli project add
+URL: http://localhost:7880
+API Key: devkey
+API Secret: secret
+Give it a name for later reference: meet
+? Make this project default?? [y/N] y
+```
+
+Thus, you won't need to pass the project API Key and API Secret for each command.
 
 
-<p align="center">
-  <a href="https://github.com/suitenumerique/meet/stargazers/">
-    <img src="https://img.shields.io/github/stars/suitenumerique/meet" alt="">
-  </a>
-  <a href='http://makeapullrequest.com'><img alt='PRs Welcome' src='https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=shields'/></a>
-  <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/suitenumerique/meet"/>
-  <img alt="GitHub closed issues" src="https://img.shields.io/github/issues-closed/suitenumerique/meet"/>
-  <a href="https://github.com/suitenumerique/meet/blob/main/LICENSE">
-    <img alt="GitHub closed issues" src="https://img.shields.io/github/license/suitenumerique/meet"/>
-  </a>    
-</p>
+### Adding content
 
-<p align="center">
-  <a href="https://livekit.io/">LiveKit</a> - <a href="https://go.crisp.chat/chat/embed/?website_id=58ea6697-8eba-4492-bc59-ad6562585041">Chat with us</a> - <a href="https://github.com/orgs/suitenumerique/projects/3/views/2">Roadmap</a> - <a href="https://github.com/suitenumerique/meet/blob/main/CHANGELOG.md">Changelog</a> - <a href="https://github.com/suitenumerique/meet/issues/new?assignees=&labels=bug&template=Bug_report.md">Bug reports</a> 
-</p>
+You can create a basic demo site by running:
 
-<p align="center">
-  <a href="https://visio.numerique.gouv.fr/">
-    <img src="https://github.com/user-attachments/assets/09c1faa1-de88-4848-af3a-6fbe793999bf" alt="Visio Demonstration">
-  </a>
-</p>
+```bash
+$ make demo
+```
 
-## Visio: Simple Video Conferencing
+Finally, you can check all available Make rules using:
 
-Powered by [LiveKit](https://livekit.io/), Visio offers Zoom-level performance with high-quality video and audio. No installation required—simply join calls directly from your browser. Check out LiveKit's impressive optimizations in their [blog post](https://blog.livekit.io/livekit-one-dot-zero/).
-### Features
-- Optimized for stability in large meetings (+100 p.)
-- Support for multiple screen sharing streams
-- Non-persistent, secure chat
-- End-to-end encryption (coming soon)
-- Meeting recording (coming soon)
-- Meeting transcription (currently in beta)
-- Telephony integration (in development)
-- Secure participation with robust authentication and access control
-- LiveKit Advances features including :
-  - speaker detection 
-  - simulcast 
-  - end-to-end optimizations 
-  - selective subscription
-  - SVC codecs (VP9, AV1)
+```bash
+$ make help
+```
+
+### Django admin
+
+You can access the Django admin site at
+[http://localhost:8071/admin](http://localhost:8071/admin).
+
+You first need to create a superuser account:
+
+```bash
+$ make superuser
+```
+
+### Run application on local Kubernetes
+
+The application is deployed across staging, preprod, and production environments using Kubernetes (K8s).
+Reproducing environment conditions locally is crucial for developing new features or debugging issues.
+
+This is facilitated by [Tilt](https://tilt.dev/) ("Kubernetes for Prod, Tilt for Dev").  Tilt enables smart rebuilds and live updates for services running locally in Kubernetes.  We defined our services in a Tiltfile located at `bin/Tiltfile`.
 
 
-Visio is fully self-hostable and released under the MIT License, ensuring complete control and flexibility. It's simple to [get started](https://visio.numerique.gouv.fr/) or [request a demo](mailto:visio@numerique.gouv.fr). 
+#### Getting Started
 
-We’re continuously adding new features to enhance your experience, with the latest updates coming soon!
+Make sure you have installed:
+- kubectl
+- helm
+- helmfile
+- tilt
 
+To build and start the Kubernetes cluster using Kind:
+```shell
+$ make build-k8s-cluster 
+```
 
-## Table of Contents
+Once the Kubernetes cluster is ready, start the application stack locally:
+```shell
+$ make start-tilt
+```
+These commands set up and run your application environment using Tilt for local Kubernetes development.
 
-- [Get started](#get-started)
-- [Docs](#docs)
-- [Contributing](#contributing)
-- [Philosophy](#philosophy)
-- [Open source](#open-source)
+You can monitor Tilt's at `http://localhost:10350/`. After Tilt actions finish, you can access the app at `https://meet.127.0.0.1.nip.io/`.
 
+#### Debugging frontend
 
-## Get started
+Tilt deploys the `meet-dev` for the frontend by default, to benefit from Vite.js hot reloading while developing. 
+To troubleshoot production issues, please modify the Tiltfile, switch frontend's target to `frontend-production`:
 
-### Visio Cloud (Recommended)
-Sign up for Visio Cloud, designed for European public servants. Hosted on SecNumCloud-compliant providers and accessible via government SSO, [ProConnect](https://www.proconnect.gouv.fr/). The easiest way to try our product. Reach out if your entity isn't connected yet to our sso.
+```yaml
+...
 
-### Open-source deployment (Advanced)
-
-Deploy Visio on your own infrastructure using [our self-hosting guide](https://github.com/suitenumerique/meet/blob/main/docs/installation.md). Our open-source deployment is optimized for Kubernetes, and we're working on supporting additional deployment options. Keycloak integration and any SSO are supported. We offer customer support for open-source setups—just reach out for assistance.  
-
-## Docs
-
-We're currently working on both technical and user documentation for Visio. In the meantime, many of the essential aspects are already well covered by the [LiveKit documentation](https://docs.livekit.io/home/) and their [self-hosting guide](https://docs.livekit.io/home/self-hosting/deployment/). Stay tuned for more updates!
+docker_build(
+    'localhost:5001/meet-frontend:latest',
+    context='..',
+    dockerfile='../src/frontend/Dockerfile',
+    only=['./src/frontend', './docker', './.dockerignore'],
+    target='frontend-production',  # Update this line when needed
+    live_update=[
+        sync('../src/frontend', '/home/frontend'),
+    ]
+)
+...
+```
 
 ## Contributing
 
-We <3 contributions of any kind, big and small:
-
-- Vote on features or get early access to beta functionality in our [roadmap](https://github.com/orgs/suitenumerique/projects/3/views/2)
-- Open a PR (see our instructions on [developing Visio locally](https://github.com/suitenumerique/meet/blob/main/docs/developping_locally.md))
-- Submit a [feature request](https://github.com/suitenumerique/meet/issues/new?assignees=&labels=enhancement&template=Feature_request.md) or [bug report](https://github.com/suitenumerique/meet/issues/new?assignees=&labels=bug&template=Bug_report.md)
-
-
-## Philosophy
-
-We’re relentlessly focused on building the best open-source video conferencing product—Visio. Growth comes from creating something people truly need, not just from chasing metrics.
-
-Our users come first. We’re committed to making Visio as accessible and easy to use as proprietary solutions, ensuring it meets the highest standards.
-
-Most of the heavy engineering is handled by the incredible LiveKit team, allowing us to focus on delivering a top-tier product. We follow extreme programming practices, favoring pair programming and quick, iterative releases. Challenge our tech and architecture—simplicity is always our top priority.
-
-
-## Open-source
-
-Gov 🇫🇷 supports open source! This project is available under [MIT license](https://github.com/suitenumerique/meet/blob/0cc2a7b7b4f4821e2c4d9d790efa739622bb6601/LICENSE).
-
-All features we develop will always remain open-source, and we are committed to contributing back to the LiveKit community whenever feasible.
-To learn more, don't hesitate to [reach out](mailto:visio@numerique.gouv.fr).
-
-### Help us!
-
-Come help us make Visio even better. We're growing fast and [would love some help](mailto:visio@numerique.gouv.fr).
-
-
-## Contributors 🧞
-
-<a href="https://github.com/suitenumerique/meet/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=suitenumerique/meet" />
-</a>
-
-## Credits 
-
-We're using the awesome [LiveKit](https://livekit.io/) implementation. We're also thankful to the teams behind [Django Rest Framework](https://www.django-rest-framework.org/), [Vite.js](https://vite.dev/), and [React Aria](https://github.com/adobe/react-spectrum) — Thanks for your amazing work!
+This project is intended to be community-driven, so please, do not hesitate to
+get in touch if you have any question related to our implementation or design
+decisions.
 
 ## License
 
-Code in this repository is published under the MIT license by DINUM (Direction interministériel du numérique).
-Documentation (in the docs/) directory is released under the [Etalab-2.0 license](https://spdx.org/licenses/etalab-2.0.html).
-
+This work is released under the MIT License (see [LICENSE](./LICENSE)).

SECURITY.md

@@ -1,23 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Security is very important to us.
-
-If you have any issue regarding security, please disclose the information responsibly submiting [this form](https://vdp.numerique.gouv.fr/p/Send-a-report?lang=en) and not by creating an issue on the repository. You can also email us at visio@numerique.gouv.fr
-
-We appreciate your effort to make Visio more secure.
-
-## Vulnerability disclosure policy
-
-Working with security issues in an open source project can be challenging, as we are required to disclose potential problems that could be exploited by attackers. With this in mind, our security fix policy is as follows:
-
-1. The Maintainers team will handle the fix as usual (Pull Request,
-   release).
-2. In the release notes, we will include the identification numbers from the
-   GitHub Advisory Database (GHSA) and, if applicable, the Common Vulnerabilities
-   and Exposures (CVE) identifier for the vulnerability.
-3. Once this grace period has passed, we will publish the vulnerability.
-
-By adhering to this security policy, we aim to address security concerns
-effectively and responsibly in our open source software project.

bin/Tiltfile

@@ -2,9 +2,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 +16,6 @@ docker_build(
         )
     ]
 )
-clean_old_images('localhost:5001/meet-backend')
 
 docker_build(
     'localhost:5001/meet-frontend:latest',
@@ -31,38 +27,8 @@ docker_build(
         sync('../src/frontend', '/home/frontend'),
     ]
 )
-clean_old_images('localhost:5001/meet-frontend')
 
-docker_build(
-    'localhost:5001/meet-summary:latest',
-    context='../src/summary',
-    dockerfile='../src/summary/Dockerfile',
-    only=['.', '../../docker', '../../.dockerignore'],
-    target = 'production',
-    live_update=[
-        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 .'))
+k8s_yaml(local('cd ../src/helm && helmfile -n meet -e dev template .'))
 
 migration = '''
 set -eu

bin/_config.sh

@@ -5,7 +5,7 @@ set -eo pipefail
 REPO_DIR="$(cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd)"
 UNSET_USER=0
 
-COMPOSE_FILE="${REPO_DIR}/compose.yml"
+COMPOSE_FILE="${REPO_DIR}/docker-compose.yml"
 COMPOSE_PROJECT="meet"
 
 

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,138 @@
-#!/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 --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
+- role: worker
+  image: kindest/node:v1.27.3
+- role: worker
+  image: kindest/node:v1.27.3
+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); 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"}]'

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-compose.yml

@@ -1,3 +1,4 @@
+version: '3.8'
 
 services:
   postgresql:
@@ -95,21 +96,8 @@ services:
     depends_on:
       - keycloak
 
-  frontend:
-    user: "${DOCKER_USER:-1000}"
-    build:
-      context: .
-      dockerfile: ./src/frontend/Dockerfile
-      target: frontend-production
-      args:
-        VITE_API_BASE_URL: "http://localhost:8071"
-    image: meet:frontend-development
-    ports:
-      - "3000:8080"
-
   dockerize:
     image: jwilder/dockerize
-    platform: linux/x86_64
 
   crowdin:
     image: crowdin/cli:4.0.0

docker/livekit/Dockerfile

@@ -1,6 +0,0 @@
-FROM livekit/livekit-server:v1.8.0
-
-# 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/developping_locally.md

@@ -1,145 +0,0 @@
-# Getting Started
-
-Before setting up, let's review Visio's architecture.
-
-Visio consists of four main components that run simultaneously:
-
-- React frontend, built with Vite.js
-- Django server
-- LiveKit server
-- FastAPI server (optional, required for AI beta features)
-
-These components rely on a few key services:
-
-- PostgreSQL for storing data (users, rooms, recordings)
-- Redis for caching and inter-service communication
-- MinIO for storing files (room recordings)
-- Celery workers for meeting transcript (optional, required for AI beta features)
-
-We provide two stack options for getting Visio up and running for development:
-
-- Docker Compose stack (recommended for most users)
-- Kubernetes stack powered by Tilt (Advanced)
-
-We recommend starting with the **Docker Compose** option for simplicity. However, if you're comfortable with running Kubernetes locally, the advanced option mirrors the production environment and provides most of the tools required for development (e.g., hot reloading).
-
-These instructions are for macOS or Ubuntu. For other distros, adjust as needed.
-
-If any steps are outdated, please let us know!
-
----
-
-We also provide **GNU make utilities**. To view all available Make rules, run:
-```shellscript
-$ make help
-```
-
----
-
-## Need Help?
-If you need any assistance or have questions while getting started, feel free to reach out to @lebaudantoine anytime! Antoine is available to help you onboard and guide you through the process. Chat with him @antoine.lebaud:matrix.org, or from the [support hotline](https://go.crisp.chat/chat/embed/?website_id=58ea6697-8eba-4492-bc59-ad6562585041).
-
----
-
-## Option 1: Developing with Docker
-
-### Prerequisites
-
-1. Ensure you have a recent version of **Docker** and **Docker Compose** installed:
-```shellscript
-$ docker -v
-Docker version 20.10.2, build 2291f61
-
-$ docker compose version
-Docker Compose version v2.32.4
-```
-
-2. Install **LiveKit CLI** by following the instructions available in the [official repository](https://github.com/livekit/livekit-cli). After installation, verify that it's working:
-```shellscript
-$ lk --version
-lk version 2.3.1
-```
-
----
-
-### Project Bootstrap
-
-1. Bootstrap the project using the **Make** command. This will build the `app` container, install dependencies, run database migrations, and compile translations:
-```shellscript
-$ make bootstrap FLUSH_ARGS='--no-input'
-```
-
-2. Access the project:
-- The frontend is available at [http://localhost:3000](http://localhost:3000) with the default credentials:
-    - username: meet
-    - password: meet
-- The Django backend is available at [http://localhost:8071](http://localhost:8071)
-
----
-
-## Developing
-
-- To **stop** the application:
-```shellscript
-$ make stop
-```
-
-- To **restart** the application:
-```shellscript
-$ make run
-```
-
-- For **frontend development**, start all backend services without the frontend container:
-```shellscript
-$ make run-backend
-```
-
-Then:
-```shellscript
-$ make frontend-development-install
-$ make run-frontend-development
-```
-
-Which is equivalent to these direct npm commands:
-```shellscript
-$ cd src/frontend
-$ npm i
-$ npm run dev
-```
-
----
-
-## Adding Content
-
-You can bootstrap demo data with a single command:
-```shellscript
-$ make demo
-```
-
----
-
-## Option 2: Developing with Kubernetes
-
-Visio is deployed across staging, preprod, and production environments using **Kubernetes (K8s)**. Reproducing the environment locally is crucial for developing new features or debugging.
-
-This is facilitated by [Tilt](https://tilt.dev/), which provides Kubernetes-like development for local environments, enabling smart rebuilds and live updates.
-
-### Getting Started
-
-Make sure you have the following installed:
-- kubectl
-- helm
-- helmfile
-- tilt
-
-To build and start the Kubernetes cluster using **Kind**:
-```shellscript
-$ make build-k8s-cluster 
-```
-
-Once the Kubernetes cluster is ready, start the application stack locally:
-```shellscript
-$ make start-tilt-keycloak
-```
-
-Monitor Tilt’s progress at [http://localhost:10350/](http://localhost:10350/). After Tilt actions finish, you can access the app at [https://visio.127.0.0.1.nip.io/](https://visio.127.0.0.1.nip.io/).

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://suitenumerique.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/admin.py

@@ -22,19 +22,7 @@ class UserAdmin(auth_admin.UserAdmin):
                 )
             },
         ),
-        (
-            _("Personal info"),
-            {
-                "fields": (
-                    "sub",
-                    "email",
-                    "full_name",
-                    "short_name",
-                    "language",
-                    "timezone",
-                )
-            },
-        ),
+        (_("Personal info"), {"fields": ("sub", "email", "language", "timezone")}),
         (
             _("Permissions"),
             {
@@ -64,8 +52,6 @@ class UserAdmin(auth_admin.UserAdmin):
         "sub",
         "admin_email",
         "email",
-        "full_name",
-        "short_name",
         "is_active",
         "is_staff",
         "is_superuser",
@@ -74,24 +60,9 @@ class UserAdmin(auth_admin.UserAdmin):
         "updated_at",
     )
     list_filter = ("is_staff", "is_superuser", "is_device", "is_active")
-    ordering = (
-        "is_active",
-        "-is_superuser",
-        "-is_staff",
-        "-is_device",
-        "-updated_at",
-        "full_name",
-    )
-    readonly_fields = (
-        "id",
-        "sub",
-        "email",
-        "full_name",
-        "short_name",
-        "created_at",
-        "updated_at",
-    )
-    search_fields = ("id", "sub", "admin_email", "email", "full_name")
+    ordering = ("is_active", "-is_superuser", "-is_staff", "-is_device", "-updated_at")
+    readonly_fields = ("id", "sub", "email", "created_at", "updated_at")
+    search_fields = ("id", "sub", "admin_email", "email")
 
 
 class ResourceAccessInline(admin.TabularInline):
@@ -108,16 +79,23 @@ class RoomAdmin(admin.ModelAdmin):
     inlines = (ResourceAccessInline,)
 
 
-class RecordingAccessInline(admin.TabularInline):
-    """Inline admin class for recording accesses."""
-
-    model = models.RecordingAccess
-    extra = 0
-
-
 @admin.register(models.Recording)
 class RecordingAdmin(admin.ModelAdmin):
     """Recording admin interface declaration."""
 
-    inlines = (RecordingAccessInline,)
     list_display = ("id", "status", "room", "created_at", "worker_id")
+    list_select_related = ("creator",)
+    readonly_fields = (
+        "id",
+        "created_at",
+        "updated_at",
+        "worker_id",
+        "room",
+        "creator",
+        "mode",
+    )
+
+    fieldsets = (
+        (None, {"fields": ("status", "room", "creator", "worker_id", "mode")}),
+        ("Timestamps", {"fields": ("created_at", "updated_at")}),
+    )

src/backend/core/analytics.py

@@ -0,0 +1,58 @@
+"""
+Meet analytics class.
+"""
+
+import uuid
+
+from django.conf import settings
+
+from june import analytics as jAnalytics
+
+
+class Analytics:
+    """Analytics integration
+
+    This class wraps the June analytics code to avoid coupling our code directly
+    with this third-party library. By doing so, we create a generic interface
+    for analytics that can be easily modified or replaced in the future.
+    """
+
+    def __init__(self):
+        key = getattr(settings, "ANALYTICS_KEY", None)
+
+        if key is not None:
+            jAnalytics.write_key = key
+
+        self._enabled = key is not None
+
+    def _is_anonymous_user(self, user):
+        """Check if the user is anonymous."""
+        return user is None or user.is_anonymous
+
+    def identify(self, user, **kwargs):
+        """Identify a user"""
+
+        if self._is_anonymous_user(user) or not self._enabled:
+            return
+
+        traits = kwargs.pop("traits", {})
+        traits.update({"email": user.email_anonymized})
+
+        jAnalytics.identify(user_id=user.sub, traits=traits, **kwargs)
+
+    def track(self, user, **kwargs):
+        """Track an event"""
+
+        if not self._enabled:
+            return
+
+        event_data = {}
+        if self._is_anonymous_user(user):
+            event_data["anonymous_id"] = str(uuid.uuid4())
+        else:
+            event_data["user_id"] = user.sub
+
+        jAnalytics.track(**event_data, **kwargs)
+
+
+analytics = Analytics()

src/backend/core/api/__init__.py

@@ -37,10 +37,6 @@ def get_frontend_configuration(request):
     """Returns the frontend configuration dict as configured in settings."""
     frontend_configuration = {
         "LANGUAGE_CODE": settings.LANGUAGE_CODE,
-        "recording": {
-            "is_enabled": settings.RECORDING_ENABLE,
-            "available_modes": settings.RECORDING_WORKER_CLASSES.keys(),
-        },
     }
     frontend_configuration.update(settings.FRONTEND_CONFIGURATION)
     return Response(frontend_configuration)

src/backend/core/api/permissions.py

@@ -67,11 +67,30 @@ class RoomPermissions(permissions.BasePermission):
         return obj.is_administrator(user)
 
 
-class ResourceAccessPermission(IsAuthenticated):
+class IsRoomOwnerOrAdministrator(permissions.BasePermission):
+    """Temporary"""
+
+    message = "You must be an admin or owner to start a recording."
+
+    def has_permission(self, request, view):
+        # Get the room object
+        room = view.get_object()
+
+        if not room.is_owner(request.user) and not room.is_administrator(request.user):
+            return False
+
+        return True
+
+
+class ResourceAccessPermission(permissions.BasePermission):
     """
     Permissions for a room that can only be updated by room administrators.
     """
 
+    def has_permission(self, request, view):
+        """Only allow authenticated users."""
+        return request.user.is_authenticated
+
     def has_object_permission(self, request, view, obj):
         """
         Check that the logged-in user is administrator of the linked room.
@@ -83,24 +102,6 @@ class ResourceAccessPermission(IsAuthenticated):
         return obj.resource.is_administrator(user)
 
 
-class HasAbilityPermission(IsAuthenticated):
-    """Permission class for access objects."""
-
-    def has_object_permission(self, request, view, obj):
-        """Check permission for a given object."""
-        return obj.get_abilities(request.user).get(view.action, False)
-
-
-class HasPrivilegesOnRoom(IsAuthenticated):
-    """Check if user has privileges on a given room."""
-
-    message = "You must have privileges to start a recording."
-
-    def has_object_permission(self, request, view, obj):
-        """Determine if user has privileges on room."""
-        return obj.is_owner(request.user) or obj.is_administrator(request.user)
-
-
 class IsRecordingEnabled(permissions.BasePermission):
     """Check if the recording feature is enabled."""
 

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
@@ -13,8 +14,8 @@ class UserSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = models.User
-        fields = ["id", "email", "full_name", "short_name"]
-        read_only_fields = ["id", "email", "full_name", "short_name"]
+        fields = ["id", "email"]
+        read_only_fields = ["id", "email"]
 
 
 class ResourceAccessSerializerMixin:
@@ -86,21 +87,12 @@ class NestedResourceAccessSerializer(ResourceAccessSerializer):
     user = UserSerializer(read_only=True)
 
 
-class ListRoomSerializer(serializers.ModelSerializer):
-    """Serialize Room model for a list API endpoint."""
-
-    class Meta:
-        model = models.Room
-        fields = ["id", "name", "slug", "access_level"]
-        read_only_fields = ["id", "slug"]
-
-
 class RoomSerializer(serializers.ModelSerializer):
     """Serialize Room model for the API."""
 
     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,84 +120,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 role is not None or instance.is_public:
+            slug = f"{instance.id!s}".replace("-", "")
 
-        if should_access_room:
-            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": slug,
+                "token": utils.generate_token(
+                    room=slug, user=request.user, username=username
+                ),
+            }
 
         output["is_administrable"] = is_admin
 
         return output
-
-
-class RecordingSerializer(serializers.ModelSerializer):
-    """Serialize Recording for the API."""
-
-    room = ListRoomSerializer(read_only=True)
-
-    class Meta:
-        model = models.Recording
-        fields = ["id", "room", "created_at", "updated_at", "status"]
-        read_only_fields = fields
-
-
-class StartRecordingSerializer(serializers.Serializer):
-    """Validate start recording requests."""
-
-    mode = serializers.ChoiceField(
-        choices=models.RecordingModeChoices.choices,
-        required=True,
-        error_messages={
-            "required": "Recording mode is required.",
-            "invalid_choice": "Invalid recording mode. Choose between "
-            "screen_recording or transcript.",
-        },
-    )
-
-    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 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,
 )
@@ -21,33 +26,21 @@ from rest_framework import (
 )
 
 from core import models, utils
-from core.recording.event.authentication import StorageEventAuthentication
-from core.recording.event.exceptions import (
+from core.recording.event import (
     InvalidBucketError,
     InvalidFileTypeError,
     ParsingEventDataError,
+    StorageEventAuthentication,
+    get_parser,
 )
-from core.recording.event.notification import notification_service
-from core.recording.event.parsers import get_parser
-from core.recording.worker.exceptions import (
+from core.recording.worker import (
     RecordingStartError,
     RecordingStopError,
-)
-from core.recording.worker.factories import (
-    get_worker_service,
-)
-from core.recording.worker.mediator import (
     WorkerServiceMediator,
-)
-from core.services.livekit_events import (
-    LiveKitEventsService,
-    LiveKitWebhookError,
-)
-from core.services.lobby import (
-    LobbyParticipantNotFound,
-    LobbyService,
+    worker_service_provider,
 )
 
+from ..analytics import analytics
 from . import permissions, serializers
 
 # pylint: disable=too-many-ancestors
@@ -154,8 +147,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 +174,6 @@ class UserViewSet(
         )
 
 
-class RequestEntryAnonRateThrottle(throttling.AnonRateThrottle):
-    """Throttle Anonymous user requesting room entry"""
-
-    scope = "request_entry"
-
-
 class RoomViewSet(
     mixins.CreateModelMixin,
     mixins.DestroyModelMixin,
@@ -236,10 +224,96 @@ class RoomViewSet(
                 },
             }
         else:
+            analytics.track(
+                user=self.request.user,
+                event="Get Room",
+                properties={"slug": instance.slug},
+            )
             data = self.get_serializer(instance).data
 
         return drf_response.Response(data)
 
+    @decorators.action(
+        detail=True,
+        methods=["post"],
+        url_path="start-recording",
+        permission_classes=[
+            permissions.IsRoomOwnerOrAdministrator,
+            permissions.IsRecordingEnabled,
+        ],
+    )
+    def start_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
+        """Start recording a room."""
+
+        room = self.get_object()
+        mode = request.data.get("mode")
+
+        if mode is None:
+            return drf_response.Response(
+                {"error": "Recording mode is required."},
+                status=drf_status.HTTP_400_BAD_REQUEST,
+            )
+
+        # May raise exception if an active or initiated recording already exist for the room
+        recording = models.Recording.objects.create(
+            creator=request.user, room=room, mode=mode
+        )
+
+        worker_service = worker_service_provider.create(mode=recording.mode)
+        worker_manager = WorkerServiceMediator(worker_service=worker_service)
+
+        try:
+            worker_manager.start(recording)
+        except RecordingStartError:
+            return drf_response.Response(
+                {"error": f"Recording failed to start for room {room.slug}"},
+                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return drf_response.Response(
+            {"message": f"Recording successfully started for room {room.slug}"},
+            status=drf_status.HTTP_201_CREATED,
+        )
+
+    @decorators.action(
+        detail=True,
+        methods=["post"],
+        url_path="stop-recording",
+        permission_classes=[
+            permissions.IsRoomOwnerOrAdministrator,
+            permissions.IsRecordingEnabled,
+        ],
+    )
+    def stop_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
+        """Stop room recording."""
+
+        room = self.get_object()
+
+        # fixme - do I need to be the creator of the recording to stop it?
+        try:
+            recording = models.Recording.objects.get(
+                room=room, status=models.RecordingStatusChoices.ACTIVE
+            )
+        except models.Recording.DoesNotExist as e:
+            raise drf_exceptions.NotFound(
+                "No active recording found for this room."
+            ) from e
+
+        worker_service = worker_service_provider.create(mode=recording.mode)
+        worker_manager = WorkerServiceMediator(worker_service=worker_service)
+
+        try:
+            worker_manager.stop(recording)
+        except RecordingStopError:
+            return drf_response.Response(
+                {"error": f"Recording failed to stop for room {room.slug}"},
+                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return drf_response.Response(
+            {"message": f"Recording stopped for room {room.slug}."}
+        )
+
     def list(self, request, *args, **kwargs):
         """Limit listed rooms to the ones related to the authenticated user."""
         user = self.request.user
@@ -268,198 +342,14 @@ class RoomViewSet(
             role=models.RoleChoices.OWNER,
         )
 
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="start-recording",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-            permissions.IsRecordingEnabled,
-        ],
-    )
-    def start_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
-        """Start recording a room."""
-
-        serializer = serializers.StartRecordingSerializer(data=request.data)
-
-        if not serializer.is_valid():
-            return drf_response.Response(
-                {"detail": "Invalid request."}, status=drf_status.HTTP_400_BAD_REQUEST
-            )
-
-        mode = serializer.validated_data["mode"]
-        room = self.get_object()
-
-        # May raise exception if an active or initiated recording already exist for the room
-        recording = models.Recording.objects.create(room=room, mode=mode)
-
-        models.RecordingAccess.objects.create(
-            user=self.request.user, role=models.RoleChoices.OWNER, recording=recording
+        analytics.track(
+            user=self.request.user,
+            event="Create Room",
+            properties={
+                "slug": room.slug,
+            },
         )
 
-        worker_service = get_worker_service(mode=recording.mode)
-        worker_manager = WorkerServiceMediator(worker_service=worker_service)
-
-        try:
-            worker_manager.start(recording)
-        except RecordingStartError:
-            return drf_response.Response(
-                {"error": f"Recording failed to start for room {room.slug}"},
-                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-        return drf_response.Response(
-            {"message": f"Recording successfully started for room {room.slug}"},
-            status=drf_status.HTTP_201_CREATED,
-        )
-
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="stop-recording",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-            permissions.IsRecordingEnabled,
-        ],
-    )
-    def stop_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
-        """Stop room recording."""
-
-        room = self.get_object()
-
-        try:
-            recording = models.Recording.objects.get(
-                room=room, status=models.RecordingStatusChoices.ACTIVE
-            )
-        except models.Recording.DoesNotExist as e:
-            raise drf_exceptions.NotFound(
-                "No active recording found for this room."
-            ) from e
-
-        worker_service = get_worker_service(mode=recording.mode)
-        worker_manager = WorkerServiceMediator(worker_service=worker_service)
-
-        try:
-            worker_manager.stop(recording)
-        except RecordingStopError:
-            return drf_response.Response(
-                {"error": f"Recording failed to stop for room {room.slug}"},
-                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-        return drf_response.Response(
-            {"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",
-        permission_classes=[],
-    )
-    def webhooks_livekit(self, request):
-        """Process webhooks from LiveKit."""
-
-        livekit_events_service = LiveKitEventsService()
-
-        try:
-            livekit_events_service.receive(request)
-            return drf_response.Response(
-                {"status": "success"}, status=drf_status.HTTP_200_OK
-            )
-        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
-
-            return drf_response.Response(
-                {"status": "error", "message": str(e)}, status=status_code
-            )
-
 
 class ResourceAccessListModelMixin:
     """List mixin for resource access API."""
@@ -506,29 +396,11 @@ class ResourceAccessViewSet(
     serializer_class = serializers.ResourceAccessSerializer
 
 
-class RecordingViewSet(
-    mixins.DestroyModelMixin,
-    mixins.ListModelMixin,
-    viewsets.GenericViewSet,
-):
+class RecordingViewSet(viewsets.GenericViewSet, mixins.ListModelMixin):
     """
-    API endpoints to access and perform actions on recordings.
+    API endpoints to access and perform actions on recording.
     """
 
-    pagination_class = Pagination
-    permission_classes = [permissions.HasAbilityPermission]
-    queryset = models.Recording.objects.all()
-    serializer_class = serializers.RecordingSerializer
-
-    def get_queryset(self):
-        """Restrict recordings to the user's ones."""
-        user = self.request.user
-        return (
-            super()
-            .get_queryset()
-            .filter(Q(accesses__user=user) | Q(accesses__team__in=user.get_teams()))
-        )
-
     @decorators.action(
         detail=False,
         methods=["post"],
@@ -563,22 +435,14 @@ class RecordingViewSet(
         if not recording.is_savable():
             raise drf_exceptions.PermissionDenied(
                 f"Recording with ID {recording_id} cannot be saved because it is either,"
-                " in an error state or has already been saved."
+                f"in an error state or has already been saved."
             )
 
-        # Attempt to notify external services about the recording
-        # This is a non-blocking operation - failures are logged but don't interrupt the flow
-        notification_succeeded = notification_service.notify_external_services(
-            recording
-        )
-
-        recording.status = (
-            models.RecordingStatusChoices.NOTIFICATION_SUCCEEDED
-            if notification_succeeded
-            else models.RecordingStatusChoices.SAVED
-        )
+        recording.status = models.RecordingStatusChoices.SAVED
         recording.save()
 
+        # todo - trigger post-processing
+
         return drf_response.Response(
             {"message": "Event processed."},
         )

src/backend/core/authentication/backends.py

@@ -1,7 +1,6 @@
 """Authentication Backends for the Meet core app."""
 
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
+from django.core.exceptions import SuspiciousOperation
 from django.utils.translation import gettext_lazy as _
 
 import requests
@@ -10,11 +9,8 @@ from mozilla_django_oidc.auth import (
 )
 
 from core.models import User
-from core.services.marketing import (
-    ContactCreationError,
-    ContactData,
-    get_marketing_service,
-)
+
+from ..analytics import analytics
 
 
 class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
@@ -72,100 +68,36 @@ class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
         user_info = self.get_userinfo(access_token, id_token, payload)
         sub = user_info.get("sub")
 
-        if not sub:
+        if sub is None:
             raise SuspiciousOperation(
                 _("User info contained no recognizable user identification")
             )
 
-        email = user_info.get("email")
-        user = self.get_existing_user(sub, email)
-
-        claims = {
-            "email": email,
-            "full_name": self.compute_full_name(user_info),
-            "short_name": user_info.get(settings.OIDC_USERINFO_SHORTNAME_FIELD),
-        }
-        if not user and self.get_settings("OIDC_CREATE_USER", True):
-            user = User.objects.create(
-                sub=sub,
-                password="!",  # noqa: S106
-                **claims,
-            )
-
-            if settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL:
-                self.signup_to_marketing_email(email)
-
-        elif not user:
-            return None
-
-        if not user.is_active:
-            raise SuspiciousOperation(_("User account is disabled"))
-
-        self.update_user_if_needed(user, claims)
+        try:
+            user = User.objects.get(sub=sub)
+        except User.DoesNotExist:
+            if self.get_settings("OIDC_CREATE_USER", True):
+                user = self.create_user(user_info)
+            else:
+                user = None
 
+        analytics.identify(user=user)
         return user
 
-    @staticmethod
-    def signup_to_marketing_email(email):
-        """Pragmatic approach to newsletter signup during authentication flow.
+    def create_user(self, claims):
+        """Return a newly created User instance."""
 
-        Details:
-        1. Uses a very short timeout (1s) to prevent blocking the auth process
-        2. Silently fails if the marketing service is down/slow to prioritize user experience
-        3. Trade-off: May miss some signups but ensures auth flow remains fast
+        sub = claims.get("sub")
 
-        Note: For a more robust solution, consider using Async task processing (Celery/Django-Q)
-        """
-        try:
-            marketing_service = get_marketing_service()
-            contact_data = ContactData(
-                email=email, attributes={"VISIO_SOURCE": ["SIGNIN"]}
+        if sub is None:
+            raise SuspiciousOperation(
+                _("Claims contained no recognizable user identification")
             )
-            marketing_service.create_contact(contact_data, timeout=1)
-        except (ContactCreationError, ImproperlyConfigured, ImportError):
-            pass
 
-    def get_existing_user(self, sub, email):
-        """Fetch existing user by sub or email."""
-        try:
-            return User.objects.get(sub=sub)
-        except User.DoesNotExist:
-            if email and settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION:
-                try:
-                    return User.objects.get(email__iexact=email)
-                except User.DoesNotExist:
-                    pass
-                except User.MultipleObjectsReturned as e:
-                    raise SuspiciousOperation(
-                        _("Multiple user accounts share a common email.")
-                    ) from e
-        return None
-
-    @staticmethod
-    def compute_full_name(user_info):
-        """Compute user's full name based on OIDC fields in settings."""
-        full_name = " ".join(
-            filter(
-                None,
-                (
-                    user_info.get(field)
-                    for field in settings.OIDC_USERINFO_FULLNAME_FIELDS
-                ),
-            )
+        user = User.objects.create(
+            sub=sub,
+            email=claims.get("email"),
+            password="!",  # noqa: S106
         )
-        return full_name or None
 
-    @staticmethod
-    def update_user_if_needed(user, claims):
-        """Update user claims if they have changed."""
-        user_fields = vars(user.__class__)  # Get available model fields
-        updated_claims = {
-            key: value
-            for key, value in claims.items()
-            if value and key in user_fields and value != getattr(user, key)
-        }
-
-        if not updated_claims:
-            return
-
-        User.objects.filter(sub=user.sub).update(**updated_claims)
+        return user

src/backend/core/authentication/views.py

@@ -22,6 +22,8 @@ from mozilla_django_oidc.views import (
     OIDCLogoutView as MozillaOIDCOIDCLogoutView,
 )
 
+from ..analytics import analytics
+
 
 class OIDCLogoutView(MozillaOIDCOIDCLogoutView):
     """Custom logout view for handling OpenID Connect (OIDC) logout flow.
@@ -98,6 +100,10 @@ class OIDCLogoutView(MozillaOIDCOIDCLogoutView):
 
         logout_url = self.redirect_url
 
+        analytics.track(
+            user=request.user,
+            event="Signed Out",
+        )
         if request.user.is_authenticated:
             logout_url = self.construct_oidc_logout_url(request)
 
@@ -145,7 +151,7 @@ class OIDCLogoutCallbackView(MozillaOIDCOIDCLogoutView):
 
 
 class OIDCAuthenticationCallbackView(MozillaOIDCAuthenticationCallbackView):
-    """Custom callback view for handling the silent login flow."""
+    """Custom callback view for handling the silent loging flow."""
 
     @property
     def failure_url(self):
@@ -162,7 +168,7 @@ class OIDCAuthenticationCallbackView(MozillaOIDCAuthenticationCallbackView):
 
 
 class OIDCAuthenticationRequestView(MozillaOIDCAuthenticationRequestView):
-    """Custom authentication view for handling the silent login flow."""
+    """Custom authentication view for handling the silent loging flow."""
 
     def get_extra_params(self, request):
         """Handle 'prompt' extra parameter for the silent login flow

src/backend/core/factories.py

@@ -23,8 +23,6 @@ class UserFactory(factory.django.DjangoModelFactory):
 
     sub = factory.Sequence(lambda n: f"user{n!s}")
     email = factory.Faker("email")
-    full_name = factory.Faker("name")
-    short_name = factory.Faker("first_name")
     language = factory.fuzzy.FuzzyChoice([lang[0] for lang in settings.LANGUAGES])
     password = make_password("password")
 
@@ -34,7 +32,8 @@ class ResourceFactory(factory.django.DjangoModelFactory):
 
     class Meta:
         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):
@@ -46,8 +45,6 @@ class ResourceFactory(factory.django.DjangoModelFactory):
                 else:
                     UserResourceAccessFactory(resource=self, user=item[0], role=item[1])
 
-        self.save()
-
 
 class UserResourceAccessFactory(factory.django.DjangoModelFactory):
     """Create fake resource user accesses for testing."""
@@ -68,7 +65,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):
@@ -76,45 +72,11 @@ class RecordingFactory(factory.django.DjangoModelFactory):
 
     class Meta:
         model = models.Recording
-        skip_postgeneration_save = True
 
+    creator = factory.SubFactory(UserFactory)
     room = factory.SubFactory(RoomFactory)
     status = models.RecordingStatusChoices.INITIATED
-    mode = models.RecordingModeChoices.SCREEN_RECORDING
+    mode = factory.fuzzy.FuzzyChoice(
+        [choice[0] for choice in models.RecordingModeChoices.choices]
+    )
     worker_id = None
-
-    @factory.post_generation
-    def users(self, create, extracted, **kwargs):
-        """Add users to recording from a given list of users with or without roles."""
-        if create and extracted:
-            for item in extracted:
-                if isinstance(item, models.User):
-                    UserRecordingAccessFactory(recording=self, user=item)
-                else:
-                    UserRecordingAccessFactory(
-                        recording=self, user=item[0], role=item[1]
-                    )
-
-            self.save()
-
-
-class UserRecordingAccessFactory(factory.django.DjangoModelFactory):
-    """Create fake recording user accesses for testing."""
-
-    class Meta:
-        model = models.RecordingAccess
-
-    recording = factory.SubFactory(RecordingFactory)
-    user = factory.SubFactory(UserFactory)
-    role = factory.fuzzy.FuzzyChoice(models.RoleChoices.values)
-
-
-class TeamRecordingAccessFactory(factory.django.DjangoModelFactory):
-    """Create fake recording team accesses for testing."""
-
-    class Meta:
-        model = models.RecordingAccess
-
-    recording = factory.SubFactory(RecordingFactory)
-    team = factory.Sequence(lambda n: f"team{n}")
-    role = factory.fuzzy.FuzzyChoice(models.RoleChoices.values)

src/backend/core/migrations/0005_alter_user_language_recording.py

@@ -0,0 +1,41 @@
+# Generated by Django 5.1.1 on 2024-10-24 18:51
+
+import django.db.models.deletion
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0004_alter_user_language'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='user',
+            name='language',
+            field=models.CharField(choices="(('en-us', 'English'), ('fr-fr', 'French'))", default='en-us', help_text='The language in which the user wants to see the interface.', max_length=10, verbose_name='language'),
+        ),
+        migrations.CreateModel(
+            name='Recording',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),
+                ('status', models.CharField(choices=[('active', 'Active'), ('stopped', 'Stopped'), ('aborted', 'Aborted'), ('saved', 'Saved'), ('failed_to_start', 'Failed to Start'), ('failed_to_stop', 'Failed to Stop')], default='active', max_length=20)),
+                ('mode', models.CharField(choices=[('screen_recording', 'SCREEN_RECORDING'), ('transcript', 'TRANSCRIPT')], default='screen_recording', help_text='Defines the type of recording being performed.', max_length=20, verbose_name='Recording mode')),
+                ('worker_id', models.CharField(blank=True, help_text='Enter an identifier for the worker recording. This ID is retained even whenthe worker stops, allowing for easy tracking and management of recorded data.', max_length=255, null=True, verbose_name='Worker ID')),
+                ('creator', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recordings', to=settings.AUTH_USER_MODEL, verbose_name='Creator')),
+                ('room', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recordings', to='core.room', verbose_name='Room')),
+            ],
+            options={
+                'verbose_name': 'Recording',
+                'verbose_name_plural': 'Recordings',
+                'db_table': 'meet_recording',
+                'ordering': ('-created_at',),
+                'constraints': [models.UniqueConstraint(condition=models.Q(('status', 'active')), fields=('room',), name='unique_active_recording_per_room')],
+            },
+        ),
+    ]

src/backend/core/migrations/0005_recording_recordingaccess_and_more.py

@@ -1,67 +0,0 @@
-# Generated by Django 5.1.1 on 2024-11-06 14:31
-
-import django.db.models.deletion
-import uuid
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0004_alter_user_language'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='Recording',
-            fields=[
-                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),
-                ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),
-                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),
-                ('status', models.CharField(choices=[('initiated', 'Initiated'), ('active', 'Active'), ('stopped', 'Stopped'), ('saved', 'Saved'), ('aborted', 'Aborted'), ('failed_to_start', 'Failed to Start'), ('failed_to_stop', 'Failed to Stop')], default='initiated', max_length=20)),
-                ('worker_id', models.CharField(blank=True, help_text='Enter an identifier for the worker recording.This ID is retained even when the worker stops, allowing for easy tracking.', max_length=255, null=True, verbose_name='Worker ID')),
-                ('room', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recordings', to='core.room', verbose_name='Room')),
-            ],
-            options={
-                'verbose_name': 'Recording',
-                'verbose_name_plural': 'Recordings',
-                'db_table': 'meet_recording',
-                'ordering': ('-created_at',),
-            },
-        ),
-        migrations.CreateModel(
-            name='RecordingAccess',
-            fields=[
-                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),
-                ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),
-                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),
-                ('team', models.CharField(blank=True, max_length=100)),
-                ('role', models.CharField(choices=[('member', 'Member'), ('administrator', 'Administrator'), ('owner', 'Owner')], default='member', max_length=20)),
-                ('recording', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='accesses', to='core.recording')),
-                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'verbose_name': 'Recording/user relation',
-                'verbose_name_plural': 'Recording/user relations',
-                'db_table': 'meet_recording_access',
-                'ordering': ('-created_at',),
-            },
-        ),
-        migrations.AddConstraint(
-            model_name='recording',
-            constraint=models.UniqueConstraint(condition=models.Q(('status__in', ['active', 'initiated'])), fields=('room',), name='unique_initiated_or_active_recording_per_room'),
-        ),
-        migrations.AddConstraint(
-            model_name='recordingaccess',
-            constraint=models.UniqueConstraint(condition=models.Q(('user__isnull', False)), fields=('user', 'recording'), name='unique_recording_user', violation_error_message='This user is already in this recording.'),
-        ),
-        migrations.AddConstraint(
-            model_name='recordingaccess',
-            constraint=models.UniqueConstraint(condition=models.Q(('team__gt', '')), fields=('team', 'recording'), name='unique_recording_team', violation_error_message='This team is already in this recording.'),
-        ),
-        migrations.AddConstraint(
-            model_name='recordingaccess',
-            constraint=models.CheckConstraint(condition=models.Q(models.Q(('team', ''), ('user__isnull', False)), models.Q(('team__gt', ''), ('user__isnull', True)), _connector='OR'), name='check_recording_access_either_user_or_team', violation_error_message='Either user or team must be set, not both.'),
-        ),
-    ]

src/backend/core/migrations/0006_merge_duplicate_users.py

@@ -1,89 +0,0 @@
-
-from django.db import migrations
-from django.db.models import Count
-from core.models import RoleChoices
-
-def merge_duplicate_user_accounts(apps, schema_editor):
-    """Merge user accounts that share the same email address.
-
-    Historical Context:
-    Previously, ProConnect authentication could return users with the same email
-    but different sub, leading to duplicate user accounts. While the application
-    now prevents this scenario, this migration is needed to clean up existing
-    duplicate accounts to ensure users can continue to connect without being blocked
-    by unique email constraints.
-
-    Performance of this migration is poor, this implementation prioritizes readability
-    and maintainability. Consider refactoring this code to avoid individual db queries
-    on each iteration.
-    """
-
-    User = apps.get_model('core', 'User')
-    ResourceAccess = apps.get_model('core', 'ResourceAccess')
-
-    emails_with_duplicates = (
-        User.objects.values('email')
-        .annotate(count=Count('id'))
-        .filter(count__gt=1)
-        .values_list('email', flat=True)
-    )
-
-    for email in emails_with_duplicates:
-        # Keep the oldest user
-        primary_user = User.objects.filter(email=email).order_by('created_at').first()
-        duplicate_user_accounts = User.objects.filter(email=email).exclude(id=primary_user.id)
-
-        # Get IDs of duplicate accounts to be merged
-        duplicate_account_ids = list(duplicate_user_accounts.values_list('id', flat=True))
-        resource_accesses_to_transfer = ResourceAccess.objects.filter(user_id__in=duplicate_account_ids)
-
-        # Transfer resource access permissions to primary user
-        # This process handles role hierarchy where:
-        # OWNER > ADMIN > MEMBER
-        for resource_access in resource_accesses_to_transfer:
-
-            # Determine if primary user already has access to this resource
-            existing_primary_access = ResourceAccess.objects.filter(
-                user_id=primary_user.id,
-                resource_id=resource_access.resource.id
-            ).first()
-
-            if existing_primary_access:
-                # Skip if primary user is already OWNER as it's the highest privilege level
-                # No need to modify or downgrade owner access
-                if existing_primary_access.role == RoleChoices.OWNER:
-                    continue
-
-                # Skip if primary user already has the exact same role
-                # No need to update when roles match
-                elif existing_primary_access.role == resource_access.role:
-                    continue
-
-                # Skip if new role is MEMBER since user already has base access
-                # All existing access includes at least MEMBER privileges
-                elif resource_access.role == RoleChoices.MEMBER:
-                    continue
-
-                # Update the role only if it represents a higher privilege level
-                # Preserves existing access record while updating the role
-                existing_primary_access.role = resource_access.role
-                existing_primary_access.save()
-            else:
-                # Transfer access to primary user
-                resource_access.user_id = primary_user.id
-                resource_access.save()
-
-        # Delete duplicate accounts - CASCADE will automatically remove any untransferred
-        # ResourceAccess records and other related data for these users
-        duplicate_user_accounts.delete()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0005_recording_recordingaccess_and_more'),
-    ]
-
-    operations = [
-        migrations.RunPython(merge_duplicate_user_accounts, reverse_code=migrations.RunPython.noop),
-    ]

src/backend/core/migrations/0006_remove_recording_unique_active_recording_per_room_and_more.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.1.1 on 2024-10-31 21:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0005_alter_user_language_recording'),
+    ]
+
+    operations = [
+        migrations.RemoveConstraint(
+            model_name='recording',
+            name='unique_active_recording_per_room',
+        ),
+        migrations.AlterField(
+            model_name='recording',
+            name='mode',
+            field=models.CharField(choices=[('screen_recording', 'SCREEN_RECORDING'), ('transcript', 'TRANSCRIPT')], help_text='Defines the kind of worker being called.', max_length=20, verbose_name='Worker kind'),
+        ),
+        migrations.AlterField(
+            model_name='recording',
+            name='status',
+            field=models.CharField(choices=[('active', 'Active'), ('initiated', 'Initiated'), ('stopped', 'Stopped'), ('aborted', 'Aborted'), ('saved', 'Saved'), ('failed_to_start', 'Failed to Start'), ('failed_to_stop', 'Failed to Stop')], default='initiated', max_length=20),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='language',
+            field=models.CharField(choices="(('en-us', 'English'), ('fr-fr', 'French'))", default='en-us', help_text='The language in which the user wants to see the interface.', max_length=10, verbose_name='language'),
+        ),
+        migrations.AddConstraint(
+            model_name='recording',
+            constraint=models.UniqueConstraint(condition=models.Q(('status', 'active'), ('status', 'initiated'), _connector='OR'), fields=('room',), name='unique_initiated_or_active_recording_per_room'),
+        ),
+    ]

src/backend/core/migrations/0007_recording_mode.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.1 on 2024-11-12 10:59
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0006_merge_duplicate_users'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='recording',
-            name='mode',
-            field=models.CharField(choices=[('screen_recording', 'SCREEN_RECORDING'), ('transcript', 'TRANSCRIPT')], default='screen_recording', help_text='Defines the mode of recording being called.', max_length=20, verbose_name='Recording mode'),
-        ),
-    ]

src/backend/core/migrations/0008_user_full_name_user_short_name.py

@@ -1,23 +0,0 @@
-# Generated by Django 5.1.1 on 2024-11-13 09:11
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0007_recording_mode'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='user',
-            name='full_name',
-            field=models.CharField(blank=True, max_length=100, null=True, verbose_name='full name'),
-        ),
-        migrations.AddField(
-            model_name='user',
-            name='short_name',
-            field=models.CharField(blank=True, max_length=100, null=True, verbose_name='short name'),
-        )
-    ]

src/backend/core/migrations/0009_alter_recording_status.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.3 on 2024-12-02 13:23
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0008_user_full_name_user_short_name'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='recording',
-            name='status',
-            field=models.CharField(choices=[('initiated', 'Initiated'), ('active', 'Active'), ('stopped', 'Stopped'), ('saved', 'Saved'), ('aborted', 'Aborted'), ('failed_to_start', 'Failed to Start'), ('failed_to_stop', 'Failed to Stop'), ('notification_succeeded', 'Notification succeeded')], default='initiated', max_length=50),
-        ),
-    ]

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

@@ -4,7 +4,6 @@ Declare and configure the models for the Meet core application
 
 import uuid
 from logging import getLogger
-from typing import List
 
 from django.conf import settings
 from django.contrib.auth import models as auth_models
@@ -40,7 +39,7 @@ class RoleChoices(models.TextChoices):
 
 
 class RecordingStatusChoices(models.TextChoices):
-    """Enumeration of possible states for a recording operation."""
+    """Recording status choices."""
 
     INITIATED = "initiated", _("Initiated")
     ACTIVE = "active", _("Active")
@@ -49,28 +48,22 @@ class RecordingStatusChoices(models.TextChoices):
     ABORTED = "aborted", _("Aborted")
     FAILED_TO_START = "failed_to_start", _("Failed to Start")
     FAILED_TO_STOP = "failed_to_stop", _("Failed to Stop")
-    NOTIFICATION_SUCCEEDED = "notification_succeeded", _("Notification succeeded")
 
     @classmethod
-    def is_final(cls, status):
-        """Determine if the recording status represents a final state.
-
-        A final status indicates the recording flow has completed, either
-        successfully or unsuccessfully.
-        """
-
-        return status in {
+    def is_final_status(cls, status):
+        """Check if the status is a final status."""
+        return status in [
             cls.STOPPED,
             cls.SAVED,
             cls.ABORTED,
             cls.FAILED_TO_START,
             cls.FAILED_TO_STOP,
-        }
+        ]
 
     @classmethod
-    def is_unsuccessful(cls, status):
-        """Determine if the recording status represents an unsuccessful state."""
-        return status in {cls.ABORTED, cls.FAILED_TO_START, cls.FAILED_TO_STOP}
+    def is_error_status(cls, status):
+        """Check if the status is an error status."""
+        return status in [cls.ABORTED, cls.FAILED_TO_START, cls.FAILED_TO_STOP]
 
 
 class RecordingModeChoices(models.TextChoices):
@@ -80,14 +73,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
@@ -150,14 +135,11 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
     email = models.EmailField(_("identity email address"), blank=True, null=True)
 
     # Unlike the "email" field which stores the email coming from the OIDC token, this field
-    # stores the email used by staff users to log in to the admin site
+    # stores the email used by staff users to login to the admin site
     admin_email = models.EmailField(
         _("admin email address"), unique=True, blank=True, null=True
     )
-    full_name = models.CharField(_("full name"), max_length=100, null=True, blank=True)
-    short_name = models.CharField(
-        _("short name"), max_length=100, null=True, blank=True
-    )
+
     language = models.CharField(
         max_length=10,
         choices=lazy(lambda: settings.LANGUAGES, tuple)(),
@@ -197,7 +179,6 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
 
     class Meta:
         db_table = "meet_user"
-        ordering = ("-created_at",)
         verbose_name = _("user")
         verbose_name_plural = _("users")
 
@@ -217,38 +198,18 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
         """
         return []
 
-
-def get_resource_roles(resource: models.Model, user: User) -> List[str]:
-    """
-    Get all roles assigned to a user for a specific resource, including team-based roles.
-
-    Args:
-        resource: The resource to check permissions for
-        user: The user to get roles for
-
-    Returns:
-        List of role strings assigned to the user
-    """
-    if not user.is_authenticated:
-        return []
-
-    # Use pre-annotated roles if available from viewset optimization
-    if hasattr(resource, "user_roles"):
-        return resource.user_roles or []
-
-    try:
-        return list(
-            resource.accesses.filter_user(user)
-            .values_list("role", flat=True)
-            .distinct()
-        )
-    except (IndexError, models.ObjectDoesNotExist):
-        return []
+    @property
+    def email_anonymized(self):
+        """Anonymize the email address by replacing the local part with asterisks."""
+        if not self.email:
+            return ""
+        return f"***@{self.email.split('@')[1]}"
 
 
 class Resource(BaseModel):
     """Model to define access control"""
 
+    is_public = models.BooleanField(default=settings.DEFAULT_ROOM_IS_PUBLIC)
     users = models.ManyToManyField(
         User,
         through="ResourceAccess",
@@ -312,7 +273,6 @@ class ResourceAccess(BaseModel):
 
     class Meta:
         db_table = "meet_resource_access"
-        ordering = ("-created_at",)
         verbose_name = _("Resource access")
         verbose_name_plural = _("Resource accesses")
         constraints = [
@@ -368,11 +328,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,100 +361,20 @@ 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
 
+# todo - discuss how the path could changed, and we could loose track of file
+# todo - discuss having constraint to avoid transitioning from a final status to another
+# todo - discuss persisting extra metadata on the event sent by the storage
+# todo - discuss inheriting from ResourceAccess model
+class Recording(BaseModel):
+    """Model for recordings that take place in a room"""
 
-class BaseAccessManager(models.Manager):
-    """Base manager for handling resource access control."""
-
-    def filter_user(self, user):
-        """Filter accesses for a given user, including both direct and team-based access."""
-        return self.filter(models.Q(user=user) | models.Q(team__in=user.get_teams()))
-
-
-class BaseAccess(BaseModel):
-    """Base model for accesses to handle resources."""
-
-    user = models.ForeignKey(
+    creator = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
-        null=True,
-        blank=True,
+        related_name="recordings",
+        verbose_name=_("Creator"),
     )
-    team = models.CharField(max_length=100, blank=True)
-    role = models.CharField(
-        max_length=20, choices=RoleChoices.choices, default=RoleChoices.MEMBER
-    )
-
-    objects = BaseAccessManager()
-
-    class Meta:
-        abstract = True
-
-    def _get_abilities(self, resource, user):
-        """
-        Compute and return abilities for a given user taking into account
-        the current state of the object.
-        """
-
-        roles = get_resource_roles(resource, user)
-
-        is_owner = RoleChoices.OWNER in roles
-        has_privileges = is_owner or RoleChoices.ADMIN in roles
-
-        # Default values for unprivileged users
-        set_role_to = set()
-        can_delete = False
-
-        # Special handling when modifying an owner's access
-        if self.role == RoleChoices.OWNER:
-            # Prevent orphaning the resource
-            can_delete = (
-                is_owner
-                and resource.accesses.filter(role=RoleChoices.OWNER).count() > 1
-            )
-            if can_delete:
-                set_role_to = {RoleChoices.ADMIN, RoleChoices.OWNER, RoleChoices.MEMBER}
-        elif has_privileges:
-            can_delete = True
-            set_role_to = {RoleChoices.ADMIN, RoleChoices.MEMBER}
-            if is_owner:
-                set_role_to.add(RoleChoices.OWNER)
-
-        # Remove the current role as we don't want to propose it as an option
-        set_role_to.discard(self.role)
-
-        return {
-            "destroy": can_delete,
-            "update": bool(set_role_to),
-            "partial_update": bool(set_role_to),
-            "retrieve": bool(roles),
-            "set_role_to": sorted(r.value for r in set_role_to),
-        }
-
-
-class Recording(BaseModel):
-    """Model for recordings that take place in a room.
-
-     Recording Status Flow:
-    1. INITIATED: Initial state when recording is requested
-    2. ACTIVE: Recording is currently in progress
-    3. STOPPED: Recording has been stopped by user/system
-    4. SAVED: Recording has been successfully processed and stored
-    4. NOTIFICATION_SUCCEEDED: External service has been notified of this recording
-
-    Error States:
-    - FAILED_TO_START: Worker failed to initialize recording
-    - FAILED_TO_STOP: Worker failed during stop operation
-    - ABORTED: Recording was terminated before completion
-
-    Warning: Worker failures may lead to database inconsistency between the actual
-    recording state and its status in the database.
-    """
-
     room = models.ForeignKey(
         Room,
         on_delete=models.CASCADE,
@@ -506,27 +382,26 @@ class Recording(BaseModel):
         verbose_name=_("Room"),
     )
     status = models.CharField(
-        max_length=50,
+        max_length=20,
         choices=RecordingStatusChoices.choices,
         default=RecordingStatusChoices.INITIATED,
     )
+    mode = models.CharField(
+        max_length=20,
+        choices=RecordingModeChoices.choices,
+        verbose_name=_("Worker kind"),
+        help_text=_("Defines the kind of worker being called."),
+    )
     worker_id = models.CharField(
         max_length=255,
         null=True,
         blank=True,
         verbose_name=_("Worker ID"),
         help_text=_(
-            "Enter an identifier for the worker recording."
-            "This ID is retained even when the worker stops, allowing for easy tracking."
+            "Enter an identifier for the worker recording. This ID is retained even when"
+            "the worker stops, allowing for easy tracking and management of recorded data."
         ),
     )
-    mode = models.CharField(
-        max_length=20,
-        choices=RecordingModeChoices.choices,
-        default=RecordingModeChoices.SCREEN_RECORDING,
-        verbose_name=_("Recording mode"),
-        help_text=_("Defines the mode of recording being called."),
-    )
 
     class Meta:
         db_table = "meet_recording"
@@ -536,87 +411,32 @@ class Recording(BaseModel):
         constraints = [
             models.UniqueConstraint(
                 fields=["room"],
-                condition=models.Q(
-                    status__in=[
-                        RecordingStatusChoices.ACTIVE,
-                        RecordingStatusChoices.INITIATED,
-                    ]
-                ),
+                condition=models.Q(status=RecordingStatusChoices.ACTIVE)
+                | models.Q(status=RecordingStatusChoices.INITIATED),
                 name="unique_initiated_or_active_recording_per_room",
             )
         ]
 
     def __str__(self):
-        return f"Recording {self.id} ({self.status})"
+        return str(self.id)
 
     def get_abilities(self, user):
         """Compute and return abilities for a given user on the recording."""
-
-        roles = set(get_resource_roles(self, user))
-
-        is_owner_or_admin = bool(
-            roles.intersection({RoleChoices.OWNER, RoleChoices.ADMIN})
-        )
-
-        is_final_status = RecordingStatusChoices.is_final(self.status)
+        is_creator = user == self.creator
+        is_final_status = RecordingStatusChoices.is_final_status(self.status)
 
         return {
-            "destroy": is_owner_or_admin and is_final_status,
+            "destroy": is_creator and is_final_status,
             "partial_update": False,
-            "retrieve": is_owner_or_admin,
-            "stop": is_owner_or_admin and not is_final_status,
+            "retrieve": is_creator,
+            "stop": is_creator and not is_final_status,
             "update": False,
         }
 
     def is_savable(self) -> bool:
         """Determine if the recording can be saved based on its current status."""
 
-        return self.status in {
-            RecordingStatusChoices.ACTIVE,
-            RecordingStatusChoices.STOPPED,
-        }
+        is_in_error = RecordingStatusChoices.is_error_status(self.status)
+        is_already_saved = self.status == RecordingStatusChoices.SAVED
 
-
-class RecordingAccess(BaseAccess):
-    """Relation model to give access to a recording for a user or a team with a role."""
-
-    recording = models.ForeignKey(
-        Recording,
-        on_delete=models.CASCADE,
-        related_name="accesses",
-    )
-
-    class Meta:
-        db_table = "meet_recording_access"
-        ordering = ("-created_at",)
-        verbose_name = _("Recording/user relation")
-        verbose_name_plural = _("Recording/user relations")
-        constraints = [
-            models.UniqueConstraint(
-                fields=["user", "recording"],
-                condition=models.Q(user__isnull=False),  # Exclude null users
-                name="unique_recording_user",
-                violation_error_message=_("This user is already in this recording."),
-            ),
-            models.UniqueConstraint(
-                fields=["team", "recording"],
-                condition=models.Q(team__gt=""),  # Exclude empty string teams
-                name="unique_recording_team",
-                violation_error_message=_("This team is already in this recording."),
-            ),
-            models.CheckConstraint(
-                condition=models.Q(user__isnull=False, team="")
-                | models.Q(user__isnull=True, team__gt=""),
-                name="check_recording_access_either_user_or_team",
-                violation_error_message=_("Either user or team must be set, not both."),
-            ),
-        ]
-
-    def __str__(self):
-        return f"{self.user!s} is {self.role:s} in {self.recording!s}"
-
-    def get_abilities(self, user):
-        """
-        Compute and return abilities for a given user on the recording access.
-        """
-        return self._get_abilities(self.recording, user)
+        return not is_in_error and not is_already_saved

src/backend/core/recording/event/__init__.py

@@ -1 +1,5 @@
-"""Meet event parser classes, authentication and exceptions."""
+"""Meet event parser classes and exceptions."""
+
+from .authentication import *
+from .exceptions import *
+from .parsers import *

src/backend/core/recording/event/authentication.py

@@ -12,33 +12,12 @@ from rest_framework.exceptions import AuthenticationFailed
 logger = logging.getLogger(__name__)
 
 
-class MachineUser:
-    """Represent a non-interactive system user for automated storage operations."""
-
-    def __init__(self) -> None:
-        self.pk = None
-        self.username = "storage_event_user"
-        self.is_active = True
-
-    @property
-    def is_authenticated(self):
-        """Indicate if this machine user is authenticated."""
-        return True
-
-    @property
-    def is_anonymous(self) -> bool:
-        """Indicate if this is an anonymous user."""
-        return False
-
-    def get_username(self) -> str:
-        """Return the machine user identifier."""
-        return self.username
-
-
 class StorageEventAuthentication(BaseAuthentication):
     """Authenticate requests using a Bearer token for storage event integration.
+
     This class validates Bearer tokens for storage events that don't map to database users.
     It's designed for S3-compatible storage integrations and similar use cases.
+
     Events are submitted when a webhook is configured on some bucket's events.
     """
 
@@ -48,17 +27,9 @@ class StorageEventAuthentication(BaseAuthentication):
     def authenticate(self, request):
         """Validate the Bearer token from the Authorization header."""
 
-        if not settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH:
-            return MachineUser(), None
-
         required_token = settings.RECORDING_STORAGE_EVENT_TOKEN
         if not required_token:
-            if settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH:
-                raise AuthenticationFailed(
-                    _("Authentication is enabled but token is not configured.")
-                )
-
-            return MachineUser(), None
+            return None
 
         auth_header = request.headers.get(self.AUTH_HEADER)
 
@@ -87,7 +58,7 @@ class StorageEventAuthentication(BaseAuthentication):
             )
             raise AuthenticationFailed(_("Invalid token"))
 
-        return MachineUser(), token
+        return None
 
     def authenticate_header(self, request):
         """Return the WWW-Authenticate header value."""

src/backend/core/recording/event/notification.py

@@ -1,93 +0,0 @@
-"""Service to notify external services when a new recording is ready."""
-
-import logging
-
-from django.conf import settings
-
-import requests
-
-from core import models
-
-logger = logging.getLogger(__name__)
-
-
-class NotificationService:
-    """Service for processing recordings and notifying external services."""
-
-    def notify_external_services(self, recording):
-        """Process a recording based on its mode."""
-
-        if recording.mode == models.RecordingModeChoices.TRANSCRIPT:
-            return self._notify_summary_service(recording)
-
-        if recording.mode == models.RecordingModeChoices.SCREEN_RECORDING:
-            logger.warning(
-                "Screen recording mode not implemented for recording %s", recording.id
-            )
-            return False
-
-        logger.error(
-            "Unknown recording mode %s for recording %s",
-            recording.mode,
-            recording.id,
-        )
-        return False
-
-    @staticmethod
-    def _notify_summary_service(recording):
-        """Notify summary service about a new recording."""
-
-        if (
-            not settings.SUMMARY_SERVICE_ENDPOINT
-            or not settings.SUMMARY_SERVICE_API_TOKEN
-        ):
-            logger.error("Summary service not configured")
-            return False
-
-        owner_access = (
-            models.RecordingAccess.objects.select_related("user")
-            .filter(
-                role=models.RoleChoices.OWNER,
-                recording_id=recording.id,
-            )
-            .first()
-        )
-
-        if not owner_access:
-            logger.error("No owner found for recording %s", recording.id)
-            return False
-
-        key = f"{settings.RECORDING_OUTPUT_FOLDER}/{recording.id}.ogg"
-
-        payload = {
-            "filename": key,
-            "email": owner_access.user.email,
-            "sub": owner_access.user.sub,
-        }
-
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {settings.SUMMARY_SERVICE_API_TOKEN}",
-        }
-
-        try:
-            response = requests.post(
-                settings.SUMMARY_SERVICE_ENDPOINT,
-                json=payload,
-                headers=headers,
-                timeout=30,
-            )
-            response.raise_for_status()
-        except requests.HTTPError as exc:
-            logger.exception(
-                "Summary service HTTP error for recording %s. URL: %s. Exception: %s",
-                recording.id,
-                settings.SUMMARY_SERVICE_ENDPOINT,
-                exc,
-            )
-            return False
-
-        return True
-
-
-notification_service = NotificationService()

src/backend/core/recording/event/parsers.py

@@ -22,6 +22,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class StorageEvent:
     """Represents a storage event with relevant metadata.
+
     Attributes:
         filepath: Identifier for the affected recording
         filetype: Type of storage event
@@ -62,6 +63,7 @@ class EventParser(Protocol):
 @lru_cache(maxsize=1)
 def get_parser() -> EventParser:
     """Return cached instance of configured event parser.
+
     Uses function memoization instead of a factory class since the only
     varying parameter is the parser class from settings. A factory class
     would add unnecessary complexity when a cached function provides the

src/backend/core/recording/worker/__init__.py

@@ -1 +1,13 @@
 """Meet worker services classes and exceptions."""
+
+from .exceptions import *
+from .factories import WorkerServiceFactory
+from .mediator import WorkerServiceMediator
+from .services import AudioCompositeEgressService, VideoCompositeEgressService
+
+# Expose the worker service factory instance at the module level.
+# This provides a centralized access point and abstracts away the service creation
+# details from the code using the services.
+worker_service_provider = WorkerServiceFactory()
+worker_service_provider.register("transcript", AudioCompositeEgressService)
+worker_service_provider.register("screen_recording", VideoCompositeEgressService)

src/backend/core/recording/worker/factories.py

@@ -3,10 +3,9 @@
 import logging
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, ClassVar, Dict, Optional, Protocol, Type
+from typing import Any, ClassVar, Dict, Optional, Protocol
 
 from django.conf import settings
-from django.utils.module_loading import import_string
 
 logger = logging.getLogger(__name__)
 
@@ -56,20 +55,36 @@ class WorkerService(Protocol):
         """Stop recording for a specified worker."""
 
 
-def get_worker_service(mode: str) -> WorkerService:
-    """Instantiate a worker service by its mode."""
+class WorkerServiceFactory:
+    """Factory to instantiate worker services based on a specified mode
 
-    worker_registry: Dict[str, str] = settings.RECORDING_WORKER_CLASSES
+    This factory currently uses a common configuration (`_default_config`) to initialize all
+    workers. In the future, if workers require different configurations, consider refactoring
+    to a builder pattern. With a builder pattern, specific builders could be registered per
+    WorkerService type, allowing each builder to handle instantiation of the worker with its
+    unique configuration requirements.
+    """
 
-    try:
-        worker_class_path = worker_registry[mode]
-    except KeyError as e:
-        raise ValueError(
-            f"Recording mode '{mode}' not found in RECORDING_WORKER_CLASSES. "
-            f"Available modes: {list(worker_registry.keys())}"
-        ) from e
+    def __init__(self):
+        """Initialize the WorkerServiceFactory with a default configuration and worker registry."""
 
-    worker_class: Type[WorkerService] = import_string(worker_class_path)
+        self._worker_service_registry = {}
+        self._default_config = WorkerServiceConfig.from_settings()
 
-    config = WorkerServiceConfig.from_settings()
-    return worker_class(config=config)
+    def register(self, mode, worker_service: WorkerService):
+        """Register a worker service for a specific mode."""
+
+        if mode in self._worker_service_registry:
+            raise KeyError(f"Worker service for mode '{mode}' is already registered.")
+
+        self._worker_service_registry[mode] = worker_service
+
+    def create(self, mode: str) -> WorkerService:
+        """Instantiate a worker service for the specified mode."""
+
+        worker_service_cls = self._worker_service_registry.get(mode)
+
+        if not worker_service_cls:
+            raise ValueError(f"Unknown worker service for mode: {mode}.")
+
+        return worker_service_cls(config=self._default_config)

src/backend/core/recording/worker/mediator.py

@@ -19,9 +19,14 @@ logger = logging.getLogger(__name__)
 class WorkerServiceMediator:
     """Mediate interactions between a worker service and a recording instance.
 
-    A mediator class that decouples the worker from Django ORM, handles recording updates
-    based on worker status, and transforms worker errors into user-friendly exceptions.
-    Implements Mediator pattern.
+    This class avoids direct coupling between the worker service and the Django ORM.
+    It is responsible for updating the recording instance based on the worker service's
+    status and responses. It also encapsulates worker-related errors into more
+    user-friendly higher-level exceptions.
+
+    This class follows the Mediator design pattern to centralize and coordinate
+    the communication between the worker service and the recording instances. It's not only
+    a facade for the worker service, because it adds functionalities to the worker service.
     """
 
     def __init__(self, worker_service: WorkerService):
@@ -32,20 +37,20 @@ class WorkerServiceMediator:
     def start(self, recording: Recording):
         """Start the recording process using the worker service.
 
-        If the operation is successful, the recording's status will
-        transition from INITIATED to ACTIVE, else to FAILED_TO_START to keep track of errors.
-
         Args:
             recording (Recording): The recording instance to start.
+
         Raises:
             RecordingStartError: If there is an error starting the recording.
         """
 
+        # FIXME - no manipulations of room_name should be required
+        room_name = f"{recording.room.id!s}".replace("-", "")
+
         if recording.status != RecordingStatusChoices.INITIATED:
             logger.error("Cannot start recording in %s status.", recording.status)
             raise RecordingStartError()
 
-        room_name = str(recording.room.id)
         try:
             worker_id = self._worker_service.start(room_name, recording.id)
         except (WorkerRequestError, WorkerConnectionError, WorkerResponseError) as e:
@@ -61,19 +66,18 @@ class WorkerServiceMediator:
             recording.save()
 
         logger.info(
-            "Worker started for room %s (worker ID: %s)",
+            "Worker started for room %s (worker ID: %s, mode: %s)",
             recording.room,
             recording.worker_id,
+            recording.mode,
         )
 
     def stop(self, recording: Recording):
         """Stop the recording process using the worker service.
 
-        If the operation is successful, the recording's status will transition
-        from ACTIVE to STOPPED, else to FAILED_TO_STOP to keep track of errors.
-
         Args:
             recording (Recording): The recording instance to stop.
+
         Raises:
             RecordingStopError: If there is an error stopping the recording.
         """

src/backend/core/recording/worker/services.py

@@ -12,13 +12,13 @@ from .factories import WorkerServiceConfig
 
 
 class BaseEgressService:
-    """Base egress defining common methods to manage and interact with LiveKit egress processes."""
+    """Base egress defining common method to manage and interact with LiveKit egress processes."""
 
     def __init__(self, config: WorkerServiceConfig):
         self._config = config
         self._s3 = livekit_api.S3Upload(**config.bucket_args)
 
-    def _get_filepath(self, filename: str, extension: str) -> str:
+    def _get_filepath(self, filename, extension):
         """Construct the file path for a given filename and extension.
         Unsecure method, doesn't handle paths robustly and securely.
         """
@@ -44,8 +44,9 @@ class BaseEgressService:
 
             return response
 
-    def stop(self, worker_id: str) -> str:
+    def stop(self, worker_id):
         """Stop an ongoing egress worker.
+
         The StopEgressRequest is shared among all types of egress,
         so a single implementation in the base class should be sufficient.
         """
@@ -66,6 +67,7 @@ class BaseEgressService:
         if response.status == livekit_api.EgressStatus.EGRESS_ABORTED:
             return "ABORTED"
 
+        # todo - verify if it's functional
         if response.status == livekit_api.EgressStatus.EGRESS_ENDING:
             return "STOPPED"
 
@@ -73,6 +75,7 @@ class BaseEgressService:
 
     def start(self, room_name, recording_id):
         """Start the egress process for a recording (not implemented in the base class).
+
         Each derived class must implement this method, providing the necessary parameters for
         its specific egress type (e.g. audio_only, streaming output).
         """
@@ -87,7 +90,6 @@ class VideoCompositeEgressService(BaseEgressService):
     def start(self, room_name, recording_id):
         """Start the video composite egress process for a recording."""
 
-        # Save room's recording as a mp4 video file.
         file_type = livekit_api.EncodedFileType.MP4
         filepath = self._get_filepath(filename=recording_id, extension="mp4")
 
@@ -118,7 +120,6 @@ class AudioCompositeEgressService(BaseEgressService):
     def start(self, room_name, recording_id):
         """Start the audio composite egress process for a recording."""
 
-        # Save room's recording as an ogg audio file.
         file_type = livekit_api.EncodedFileType.OGG
         filepath = self._get_filepath(filename=recording_id, extension="ogg")
 

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,385 +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 (  # pylint: disable=E0611
-    ListRoomsRequest,
-    LiveKitAPI,
-    SendDataRequest,
-    TwirpError,
-)
-
-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,
-        )
-
-        try:
-            self.notify_participants(room_id=room_id)
-        except LobbyNotificationError:
-            # If room not created yet, there is no participants to notify
-            pass
-
-        cache_key = self._get_cache_key(room_id, participant_id)
-        cache.set(
-            cache_key,
-            participant.to_dict(),
-            timeout=settings.LOBBY_WAITING_TIMEOUT,
-        )
-
-        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:
-            room_response = await lkapi.room.list_rooms(
-                ListRoomsRequest(
-                    names=[str(room_id)],
-                )
-            )
-
-            # Check if the room exists
-            if not room_response.rooms:
-                return
-
-            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/services/marketing.py

@@ -1,134 +0,0 @@
-"""Marketing service in charge of pushing data for marketing automation."""
-
-import logging
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import Dict, List, Optional, Protocol
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-from django.utils.module_loading import import_string
-
-import brevo_python
-
-logger = logging.getLogger(__name__)
-
-
-class ContactCreationError(Exception):
-    """Raised when the contact creation fails."""
-
-
-@dataclass
-class ContactData:
-    """Contact data for marketing service integration."""
-
-    email: str
-    attributes: Optional[Dict[str, str]] = None
-    list_ids: Optional[List[int]] = None
-    update_enabled: bool = True
-
-
-class MarketingServiceProtocol(Protocol):
-    """Interface for marketing automation service integrations."""
-
-    def create_contact(
-        self, contact_data: ContactData, timeout: Optional[int] = None
-    ) -> dict:
-        """Create or update a contact.
-
-        Args:
-            contact_data: Contact information and attributes
-            timeout: API request timeout in seconds
-
-        Returns:
-            dict: Service response
-
-        Raises:
-            ContactCreationError: If contact creation fails
-        """
-
-
-class BrevoMarketingService:
-    """Brevo marketing automation integration.
-
-    Handles:
-    - Contact management and segmentation
-    - Marketing campaigns and automation
-    - Email communications
-
-    Configuration via Django settings:
-    - BREVO_API_KEY: API authentication
-    - BREVO_API_CONTACT_LIST_IDS: Default contact lists
-    - BREVO_API_CONTACT_ATTRIBUTES: Default contact attributes
-    """
-
-    def __init__(self):
-        """Initialize Brevo (ex-sendinblue) marketing service."""
-
-        if not settings.BREVO_API_KEY:
-            raise ImproperlyConfigured("Brevo API key is required")
-
-        configuration = brevo_python.Configuration()
-        configuration.api_key["api-key"] = settings.BREVO_API_KEY
-
-        self._api_client = brevo_python.ApiClient(configuration)
-
-    def create_contact(self, contact_data: ContactData, timeout=None) -> dict:
-        """Create or update a Brevo contact.
-
-        Args:
-            contact_data: Contact information and attributes
-            timeout: API request timeout in seconds
-
-        Returns:
-            dict: Brevo API response
-
-        Raises:
-            ContactCreationError: If contact creation fails
-            ImproperlyConfigured: If required settings are missing
-
-        Note:
-            Contact attributes must be pre-configured in Brevo.
-            Changes to attributes can impact existing workflows.
-        """
-
-        if not settings.BREVO_API_CONTACT_LIST_IDS:
-            raise ImproperlyConfigured(
-                "Default Brevo List IDs must be configured in settings."
-            )
-
-        contact_api = brevo_python.ContactsApi(self._api_client)
-
-        attributes = {
-            **settings.BREVO_API_CONTACT_ATTRIBUTES,
-            **(contact_data.attributes or {}),
-        }
-
-        list_ids = (contact_data.list_ids or []) + settings.BREVO_API_CONTACT_LIST_IDS
-
-        contact = brevo_python.CreateContact(
-            email=contact_data.email,
-            attributes=attributes,
-            list_ids=list_ids,
-            update_enabled=contact_data.update_enabled,
-        )
-
-        api_configurations = {}
-
-        if timeout is not None:
-            api_configurations["_request_timeout"] = timeout
-
-        try:
-            response = contact_api.create_contact(contact, **api_configurations)
-        except brevo_python.rest.ApiException as err:
-            logger.exception("Failed to create contact in Brevo")
-            raise ContactCreationError("Failed to create contact in Brevo") from err
-
-        return response
-
-
-@lru_cache(maxsize=1)
-def get_marketing_service() -> MarketingServiceProtocol:
-    """Return cached instance of configured marketing service."""
-    marketing_service_cls = import_string(settings.MARKETING_SERVICE_CLASS)
-    return marketing_service_cls()

src/backend/core/templates/core/generate_document.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Generate Document</title>
+</head>
+<body>
+    <h2>Generate Document</h2>
+    <form method="post" enctype="multipart/form-data">
+        {% csrf_token %}
+        {{ form.as_p }}
+        <button type="submit">Generate PDF</button>
+    </form>
+</body>
+</html>

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

@@ -1,48 +1,42 @@
 """Unit tests for the Authentication Backends."""
 
-from unittest import mock
-
-from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
+from django.core.exceptions import SuspiciousOperation
 
 import pytest
 
 from core import models
 from core.authentication.backends import OIDCAuthenticationBackend
 from core.factories import UserFactory
-from core.services import marketing
 
 pytestmark = pytest.mark.django_db
 
 
-def test_authentication_getter_existing_user(monkeypatch):
+def test_authentication_getter_existing_user_no_email(
+    django_assert_num_queries, monkeypatch
+):
     """
-    If an existing user matches, the user should be returned.
+    If an existing user matches the user's info sub, the user should be returned.
     """
 
     klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="foo@mail.com")
+    db_user = UserFactory()
 
     def get_userinfo_mocked(*args):
-        return {"sub": db_user.sub, "email": "some@mail.com"}
-
-    def get_existing_user(*args):
-        return db_user
+        return {"sub": db_user.sub}
 
     monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-    monkeypatch.setattr(
-        OIDCAuthenticationBackend, "get_existing_user", get_existing_user
-    )
 
-    user = klass.get_or_create_user(
-        access_token="test-token", id_token=None, payload=None
-    )
+    with django_assert_num_queries(1):
+        user = klass.get_or_create_user(
+            access_token="test-token", id_token=None, payload=None
+        )
 
     assert user == db_user
 
 
 def test_authentication_getter_new_user_no_email(monkeypatch):
     """
-    If no user matches, a user should be created.
+    If no user matches the user's info sub, a user should be created.
     User's info doesn't contain an email, created user's email should be empty.
     """
     klass = OIDCAuthenticationBackend()
@@ -64,15 +58,16 @@ def test_authentication_getter_new_user_no_email(monkeypatch):
 
 def test_authentication_getter_new_user_with_email(monkeypatch):
     """
-    If no user matches, a user should be created.
-    User's info contains an email, created user's email should be filled.
+    If no user matches the user's info sub, a user should be created.
+    User's email and name should be set on the identity.
+    The "email" field on the User model should not be set as it is reserved for staff users.
     """
     klass = OIDCAuthenticationBackend()
 
     email = "meet@example.com"
 
     def get_userinfo_mocked(*args):
-        return {"sub": "123", "email": email}
+        return {"sub": "123", "email": email, "first_name": "John", "last_name": "Doe"}
 
     monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
 
@@ -82,34 +77,6 @@ def test_authentication_getter_new_user_with_email(monkeypatch):
 
     assert user.sub == "123"
     assert user.email == email
-    assert user.full_name is None
-    assert user.short_name is None
-    assert user.password == "!"
-    assert models.User.objects.count() == 1
-
-
-@pytest.mark.parametrize("email", [None, "johndoe@foo.com"])
-def test_authentication_getter_new_user_with_names(monkeypatch, email):
-    """
-    If no user matches, a user should be created.
-    User's info contains name-related field, created user's full and short names should be filled,
-    whether the email is filled
-    """
-    klass = OIDCAuthenticationBackend()
-
-    def get_userinfo_mocked(*args):
-        return {"sub": "123", "given_name": "John", "usual_name": "Doe", "email": email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user(
-        access_token="test-token", id_token=None, payload=None
-    )
-
-    assert user.sub == "123"
-    assert user.email == email
-    assert user.full_name == "John Doe"
-    assert user.short_name == "John"
     assert user.password == "!"
     assert models.User.objects.count() == 1
 
@@ -135,419 +102,3 @@ def test_models_oidc_user_getter_invalid_token(django_assert_num_queries, monkey
         klass.get_or_create_user(access_token="test-token", id_token=None, payload=None)
 
     assert models.User.objects.exists() is False
-
-
-def test_models_oidc_user_getter_empty_sub(django_assert_num_queries, monkeypatch):
-    """The user's info contains a sub, but it's an empty string."""
-    klass = OIDCAuthenticationBackend()
-
-    def get_userinfo_mocked(*args):
-        return {"test": "123", "sub": ""}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    with (
-        django_assert_num_queries(0),
-        pytest.raises(
-            SuspiciousOperation,
-            match="User info contained no recognizable user identification",
-        ),
-    ):
-        klass.get_or_create_user(access_token="test-token", id_token=None, payload=None)
-
-    assert models.User.objects.exists() is False
-
-
-def test_authentication_get_inactive_user(monkeypatch):
-    """Test an exception is raised when attempting to authenticate inactive user."""
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(is_active=False)
-
-    def get_userinfo_mocked(*args):
-        return {"sub": db_user.sub}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    with (
-        pytest.raises(
-            SuspiciousOperation,
-            match="User account is disabled",
-        ),
-    ):
-        klass.get_or_create_user(access_token="test-token", id_token=None, payload=None)
-
-
-def test_finds_user_by_sub(django_assert_num_queries):
-    """Should return user when found by sub, and email is matching."""
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="foo@mail.com")
-
-    with django_assert_num_queries(1):
-        user = klass.get_existing_user(db_user.sub, db_user.email)
-
-    assert user == db_user
-
-
-def test_finds_user_when_email_fallback_disabled(django_assert_num_queries, settings):
-    """Should not return a user when not found by sub, and email fallback is disabled."""
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = False
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="foo@mail.com")
-
-    with django_assert_num_queries(1):
-        user = klass.get_existing_user("wrong-sub", db_user.email)
-
-    assert user is None
-
-
-def test_finds_user_when_email_is_none(django_assert_num_queries, settings):
-    """Should not return a user when not found by sub, and email is empty."""
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-
-    klass = OIDCAuthenticationBackend()
-    UserFactory(email="foo@mail.com")
-
-    empty_email = ""
-
-    with django_assert_num_queries(1):
-        user = klass.get_existing_user("wrong-sub", empty_email)
-
-    assert user is None
-
-
-def test_finds_user_by_email(django_assert_num_queries, settings):
-    """Should return user when found by email, and sub is not matching."""
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="foo@mail.com")
-
-    with django_assert_num_queries(2):
-        user = klass.get_existing_user("wrong-sub", db_user.email)
-
-    assert user == db_user
-
-
-def test_finds_user_case_insensitive_email(django_assert_num_queries, settings):
-    """Should match email case-insensitively when falling back to email."""
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="foo@mail.com")
-
-    with django_assert_num_queries(2):
-        user = klass.get_existing_user("wrong-sub", "FOO@MAIL.COM")
-
-    assert user == db_user
-
-
-def test_finds_user_multiple_users_same_email(django_assert_num_queries, settings):
-    """Should handle multiple users with same email appropriately."""
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-
-    klass = OIDCAuthenticationBackend()
-    email = "foo@mail.com"
-    UserFactory(email=email)
-    UserFactory(email=email)  # Second user with same email
-
-    with (
-        django_assert_num_queries(2),
-        pytest.raises(
-            SuspiciousOperation,
-            match="Multiple user accounts share a common email.",
-        ),
-    ):
-        klass.get_existing_user("wrong-sub", email)
-
-
-def test_finds_user_whitespace_email(django_assert_num_queries, settings):
-    """Should not match emails with whitespace."""
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-    settings.OIDC_CREATE_USER = False
-
-    klass = OIDCAuthenticationBackend()
-    UserFactory(email="foo@mail.com")
-
-    with django_assert_num_queries(2):
-        user = klass.get_existing_user("wrong-sub", " foo@mail.com ")
-
-    assert user is None
-
-
-@pytest.mark.parametrize(
-    "email",
-    [
-        "john.doe@ｅxample.com",  # Fullwidth character in domain
-        "john.doe@еxample.com",  # Cyrillic 'е' in domain
-        "JOHN.DOe@exam𝔭le.com",  # Mixed Gothic '𝔭' in domain
-        "john.doe@exаmple.com",  # Cyrillic 'а' (a) in domain
-        "john.doe@ｅ𝓧𝓪𝓶𝓹𝓵𝓮.com",  # Mixed fullwidth and cursive in domain
-    ],
-)
-def test_authentication_getter_existing_user_email_tricky(email, monkeypatch, settings):
-    """Test email matching security against visually similar but non-ASCII domains.
-
-    Validates that emails with Unicode characters that visually resemble ASCII
-    (homoglyphs) are treated as distinct from their ASCII counterparts for security,
-    per RFC compliance requirements for hostnames.
-    """
-
-    settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = True
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="john.doe@example.com")
-
-    def get_userinfo_mocked(*args):
-        return {"sub": "123", "email": email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user(
-        access_token="test-token", id_token=None, payload=None
-    )
-
-    assert user != db_user
-
-
-@pytest.mark.parametrize(
-    "given_name, usual_name, email",
-    [
-        ("Jack", "Doe", "john.doe@example.com"),
-        ("John", "Duy", "john.doe@example.com"),
-        ("John", "Doe", "jack.duy@example.com"),
-        ("Jack", "Duy", "jack.duy@example.com"),
-    ],
-)
-def test_authentication_getter_existing_user_change_fields(
-    given_name, usual_name, email, django_assert_num_queries, monkeypatch
-):
-    """It should update the email or name fields on the user when they change."""
-
-    klass = OIDCAuthenticationBackend()
-    user = UserFactory(
-        full_name="John Doe", short_name="John", email="john.doe@example.com"
-    )
-
-    def get_userinfo_mocked(*args):
-        return {
-            "sub": user.sub,
-            "email": email,
-            "given_name": given_name,
-            "usual_name": usual_name,
-        }
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    # One and only one additional update query when a field has changed
-    with django_assert_num_queries(2):
-        authenticated_user = klass.get_or_create_user(
-            access_token="test-token", id_token=None, payload=None
-        )
-
-    assert user == authenticated_user
-    user.refresh_from_db()
-    assert user.email == email
-    assert user.full_name == f"{given_name:s} {usual_name:s}"
-    assert user.short_name == given_name
-
-
-@pytest.mark.parametrize(
-    "user_info, expected_name",
-    [
-        ({"given_name": "John", "family_name": "Doe"}, "John Doe"),
-        (
-            {"given_name": "John", "middle_name": "M", "family_name": "Doe"},
-            "John M Doe",
-        ),
-        ({"family_name": "Doe"}, "Doe"),
-        ({"given_name": "", "family_name": ""}, None),
-        ({}, None),
-    ],
-)
-def test_compute_full_name(user_info, expected_name, settings):
-    """Test full name computation from OIDC user info fields."""
-    settings.OIDC_USERINFO_FULLNAME_FIELDS = [
-        "given_name",
-        "middle_name",
-        "family_name",
-    ]
-    klass = OIDCAuthenticationBackend()
-    assert klass.compute_full_name(user_info) == expected_name
-
-
-def test_compute_full_name_no_fields(settings):
-    """Test full name computation with empty field configuration."""
-    settings.OIDC_USERINFO_FULLNAME_FIELDS = []
-    klass = OIDCAuthenticationBackend()
-    assert klass.compute_full_name({"given_name": "John"}) is None
-
-
-@pytest.mark.parametrize(
-    "claims",
-    [
-        {"email": "john.doe@example.com"},  # Same data - no change needed
-        {"email": ""},  # Empty strings should not override
-        {"non_related_field": "foo"},  # Unrelated fields should be ignored
-        {},  # Empty claims should not affect user
-        {"email": None},  # None values should be ignored
-    ],
-)
-def test_update_user_when_no_update_needed(django_assert_num_queries, claims):
-    """Test that user attributes remain unchanged when claims don't require updates."""
-
-    user = UserFactory(
-        full_name="John Doe", short_name="John", email="john.doe@example.com"
-    )
-
-    klass = OIDCAuthenticationBackend()
-
-    with django_assert_num_queries(0):
-        klass.update_user_if_needed(user, claims)
-
-    user.refresh_from_db()
-
-    assert user.email == "john.doe@example.com"
-
-
-@mock.patch.object(OIDCAuthenticationBackend, "signup_to_marketing_email")
-def test_marketing_signup_new_user_enabled(mock_signup, monkeypatch, settings):
-    """Test marketing signup for new user with settings enabled."""
-    settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL = True
-
-    klass = OIDCAuthenticationBackend()
-    email = "test@example.com"
-
-    def get_userinfo_mocked(*args):
-        return {"sub": "123", "email": email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user("test-token", None, None)
-
-    assert user.email == email
-    mock_signup.assert_called_once_with(email)
-
-
-@mock.patch.object(OIDCAuthenticationBackend, "signup_to_marketing_email")
-def test_marketing_signup_new_user_disabled(mock_signup, monkeypatch, settings):
-    """Test no marketing signup for new user with settings disabled."""
-    settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL = False
-
-    klass = OIDCAuthenticationBackend()
-    email = "test@example.com"
-
-    def get_userinfo_mocked(*args):
-        return {"sub": "123", "email": email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user("test-token", None, None)
-
-    assert user.email == email
-    mock_signup.assert_not_called()
-
-
-@mock.patch.object(OIDCAuthenticationBackend, "signup_to_marketing_email")
-def test_marketing_signup_new_user_default_disabled(mock_signup, monkeypatch):
-    """Test no marketing signup for new user with settings by default disabled."""
-
-    klass = OIDCAuthenticationBackend()
-    email = "test@example.com"
-
-    def get_userinfo_mocked(*args):
-        return {"sub": "123", "email": email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user("test-token", None, None)
-
-    assert user.email == email
-    mock_signup.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    "is_signup_enabled",
-    [True, False],
-)
-@mock.patch.object(OIDCAuthenticationBackend, "signup_to_marketing_email")
-def test_marketing_signup_existing_user(
-    mock_signup, monkeypatch, settings, is_signup_enabled
-):
-    """Test no marketing signup for existing user regardless of settings."""
-
-    settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL = is_signup_enabled
-
-    klass = OIDCAuthenticationBackend()
-    db_user = UserFactory(email="test@example.com")
-
-    def get_userinfo_mocked(*args):
-        return {"sub": db_user.sub, "email": db_user.email}
-
-    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
-
-    user = klass.get_or_create_user("test-token", None, None)
-    assert user == db_user
-    mock_signup.assert_not_called()
-
-
-@mock.patch("core.authentication.backends.get_marketing_service")
-def test_signup_to_marketing_email_success(mock_marketing):
-    """Test successful marketing signup."""
-
-    email = "test@example.com"
-
-    # Call the method
-    OIDCAuthenticationBackend.signup_to_marketing_email(email)
-
-    # Verify service interaction
-    mock_service = mock_marketing.return_value
-    mock_service.create_contact.assert_called_once()
-
-
-@pytest.mark.parametrize(
-    "error",
-    [
-        ImportError,
-        ImproperlyConfigured,
-    ],
-)
-@mock.patch("core.authentication.backends.get_marketing_service")
-def test_marketing_signup_handles_service_initialization_errors(
-    mock_marketing, error, settings
-):
-    """Tests errors that occur when trying to get/initialize the marketing service."""
-    settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL = True
-
-    mock_marketing.side_effect = error
-
-    # Should not raise any exception
-    OIDCAuthenticationBackend.signup_to_marketing_email("test@example.com")
-
-
-@pytest.mark.parametrize(
-    "error",
-    [
-        marketing.ContactCreationError,
-        ImproperlyConfigured,
-        ImportError,
-    ],
-)
-@mock.patch("core.authentication.backends.get_marketing_service")
-def test_marketing_signup_handles_contact_creation_errors(
-    mock_marketing, error, settings
-):
-    """Tests errors that occur during the contact creation process."""
-
-    settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL = True
-    mock_marketing.return_value.create_contact.side_effect = error
-
-    # Should not raise any exception
-    OIDCAuthenticationBackend.signup_to_marketing_email("test@example.com")

src/backend/core/tests/recording/event/test_authentication.py

@@ -4,83 +4,45 @@ Test event authentication.
 
 # pylint: disable=E1128
 
-from django.test import RequestFactory
+from django.test import RequestFactory, override_settings
 
 import pytest
 from rest_framework.exceptions import AuthenticationFailed
 
 from core.recording.event.authentication import (
-    MachineUser,
     StorageEventAuthentication,
 )
 
 
-def test_successful_authentication(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_successful_authentication():
     """Test successful authentication with valid token."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
+
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "Bearer valid-test-token"}
 
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token == "valid-test-token"
-    assert isinstance(user, MachineUser)
+    result = StorageEventAuthentication().authenticate(request)
+    assert (
+        result is None
+    )  # Authentication successful but returns None as per implementation
 
 
-def test_disabled_authentication_with_header(settings):
-    """Authentication should pass when no auth is configured, and header is present."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN=None)
+@pytest.mark.parametrize("add_header", [True, False])
+def test_disabled_authentication(add_header):
+    """Test behavior when token is not configured in settings."""
+    # mock_settings.RECORDING_STORAGE_EVENT_TOKEN = ''
     request = RequestFactory().get("/")
-    request.headers = {"Authorization": "Bearer some-token"}
+    if add_header:
+        request.headers = {"Authorization": "Bearer some-token"}
 
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
+    result = StorageEventAuthentication().authenticate(request)
+    assert result is None
 
 
-def test_disabled_authentication_without_header(settings):
-    """Authentication should pass when no auth is configured, and no header is present."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
-    request = RequestFactory().get("/")
-
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
-
-
-def test_authentication_when_disabled(settings):
-    """Authentication should pass when disabled, regardless of token configuration."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "some-token"
-    settings.RECORDING_ENABLE_STORAGE_EVENT_AUTH = False
-
-    request = RequestFactory().get("/")
-
-    user, token = StorageEventAuthentication().authenticate(request)
-    assert token is None
-    assert isinstance(user, MachineUser)
-
-
-def test_authentication_fails_when_token_not_configured(settings):
-    """Authentication should fail when authentication is enabled but no token is configured."""
-
-    # By default RECORDING_ENABLE_STORAGE_EVENT_AUTH should be True
-    settings.RECORDING_STORAGE_EVENT_TOKEN = None
-
-    request = RequestFactory().get("/")
-
-    with pytest.raises(
-        AuthenticationFailed,
-        match="Authentication is enabled but token is not configured",
-    ):
-        StorageEventAuthentication().authenticate(request)
-
-
-def test_missing_auth_header(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_missing_auth_header():
     """Test failure when Authorization header is missing."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {}
 
@@ -88,9 +50,9 @@ def test_missing_auth_header(settings):
         StorageEventAuthentication().authenticate(request)
 
 
-def test_invalid_auth_header_format(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_invalid_auth_header_format():
     """Test failure when Authorization header has invalid format."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "InvalidFormat"}
 
@@ -98,9 +60,9 @@ def test_invalid_auth_header_format(settings):
         StorageEventAuthentication().authenticate(request)
 
 
-def test_invalid_token_type(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_invalid_token_type():
     """Test failure when token type is not Bearer."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "Basic some-token"}
 
@@ -108,9 +70,9 @@ def test_invalid_token_type(settings):
         StorageEventAuthentication().authenticate(request)
 
 
-def test_invalid_token(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_invalid_token():
     """Test failure when token is invalid."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "Bearer wrong-token"}
 
@@ -118,9 +80,9 @@ def test_invalid_token(settings):
         StorageEventAuthentication().authenticate(request)
 
 
-def test_malformed_auth_header(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_malformed_auth_header():
     """Test failure when Authorization header is malformed."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "Bearer"}  # Missing token part
 
@@ -135,9 +97,9 @@ def test_authenticate_header():
     assert header == "Bearer realm='Storage event API'"
 
 
-def test_multiple_spaces_in_auth_header(settings):
+@override_settings(RECORDING_STORAGE_EVENT_TOKEN="valid-test-token")
+def test_multiple_spaces_in_auth_header():
     """Test failure when Authorization header contains multiple spaces."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "valid-test-token"
     request = RequestFactory().get("/")
     request.headers = {"Authorization": "Bearer   extra-spaces-token"}
 

src/backend/core/tests/recording/event/test_parsers.py

@@ -7,6 +7,7 @@ Test event parsers.
 from unittest import mock
 
 from django.conf import settings
+from django.test import override_settings
 
 import pytest
 
@@ -244,34 +245,34 @@ def clear_lru_cache():
     get_parser.cache_clear()
 
 
+@override_settings(AWS_STORAGE_BUCKET_NAME="test-bucket")
 def test_returns_correct_instance(clear_lru_cache):
     """Test if get_parser returns the correct parser instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "test-bucket"
     parser = get_parser()
     assert isinstance(parser, MinioParser)
     assert parser._bucket_name == "test-bucket"
 
 
+@override_settings(AWS_STORAGE_BUCKET_NAME="test-bucket")
 def test_caching_behavior(clear_lru_cache):
     """Test if the function properly caches the parser instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "test-bucket"
     parser1 = get_parser()
     parser2 = get_parser()
     assert parser1 is parser2  # Check object identity
 
 
+@override_settings(AWS_STORAGE_BUCKET_NAME="different-bucket")
 def test_different_settings_new_instance():
     """Test if changing settings creates a new instance."""
-    settings.AWS_STORAGE_BUCKET_NAME = "different-bucket"
     parser = get_parser()
     assert parser._bucket_name == "different-bucket"
 
 
 def test_import_error_handling(clear_lru_cache):
     """Test handling of import errors for invalid parser class."""
-    settings.RECORDING_EVENT_PARSER_CLASS = "invalid.parser.path"
-    with pytest.raises(ImportError):
-        get_parser()
+    with override_settings(RECORDING_EVENT_PARSER_CLASS="invalid.parser.path"):
+        with pytest.raises(ImportError):
+            get_parser()
 
 
 @mock.patch("core.recording.event.parsers.import_string")
@@ -298,11 +299,8 @@ def test_parser_instantiation_called_once(mock_import_string, clear_lru_cache):
     assert parser1 is parser2
 
 
-def test_cache_clear_behavior(clear_lru_cache, settings):
+def test_cache_clear_behavior(clear_lru_cache):
     """Test that cache clearing creates new instance."""
-
-    settings.RECORDING_EVENT_PARSER_CLASS = "core.recording.event.parsers.MinioParser"
-
     parser1 = get_parser()
     get_parser.cache_clear()
     parser2 = get_parser()

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

@@ -1,114 +0,0 @@
-"""
-Test recordings API endpoints in the Meet core app: delete.
-"""
-
-import pytest
-from rest_framework.test import APIClient
-
-from ...factories import RecordingFactory, UserFactory, UserRecordingAccessFactory
-from ...models import Recording
-
-pytestmark = pytest.mark.django_db
-
-
-def test_api_recordings_delete_anonymous():
-    """Anonymous users should not be allowed to destroy a recording."""
-    recording = RecordingFactory()
-    client = APIClient()
-
-    response = client.delete(
-        f"/api/v1.0/recordings/{recording.id!s}/",
-    )
-
-    assert response.status_code == 401
-    assert Recording.objects.count() == 1
-
-
-def test_api_recordings_delete_authenticated():
-    """
-    Authenticated users should not be allowed to delete a recording
-    from which they are not related.
-    """
-    recording = RecordingFactory()
-    user = UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.delete(
-        f"/api/v1.0/recordings/{recording.id!s}/",
-    )
-
-    assert response.status_code == 404
-    assert Recording.objects.count() == 1
-
-
-def test_api_recordings_delete_members():
-    """
-    Authenticated users should not be allowed to delete a recording
-    from which they are only a member.
-    """
-
-    user = UserFactory()
-    access = UserRecordingAccessFactory(role="member", user=user)
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.delete(
-        f"/api/v1.0/recordings/{access.recording.id}/",
-    )
-
-    assert response.status_code == 403
-    assert Recording.objects.count() == 1
-
-
-@pytest.mark.parametrize(
-    "role",
-    ["owner", "administrator"],
-)
-def test_api_recordings_delete_active(role):
-    """
-    Authenticated users cannot delete active recordings, even with deletion privileges.
-    """
-
-    user = UserFactory()
-
-    recording = RecordingFactory(status="active")
-    access = UserRecordingAccessFactory(role=role, user=user, recording=recording)
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.delete(
-        f"/api/v1.0/recordings/{access.recording.id}/",
-    )
-
-    assert response.status_code == 403
-    assert Recording.objects.count() == 1
-
-
-@pytest.mark.parametrize(
-    "role",
-    ["owner", "administrator"],
-)
-def test_api_recordings_delete_final(role):
-    """
-    Authenticated users should not be allowed to delete an active recording
-    from which they are an admin or owner.
-    """
-
-    user = UserFactory()
-
-    recording = RecordingFactory(status="saved")
-    access = UserRecordingAccessFactory(role=role, user=user, recording=recording)
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.delete(
-        f"/api/v1.0/recordings/{access.recording.id}/",
-    )
-
-    assert response.status_code == 204
-    assert Recording.objects.count() == 0

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

@@ -1,180 +0,0 @@
-"""
-Test recordings API endpoints in the Meet core app: list.
-"""
-
-import operator
-from unittest import mock
-
-import pytest
-from rest_framework.pagination import PageNumberPagination
-from rest_framework.test import APIClient
-
-from core import factories
-
-pytestmark = pytest.mark.django_db
-
-
-def test_api_recordings_list_anonymous():
-    """Anonymous users should not be able to list recordings."""
-    factories.RecordingFactory()
-    response = APIClient().get("/api/v1.0/recordings/")
-
-    assert response.status_code == 401
-
-
-@pytest.mark.parametrize(
-    "role",
-    ["administrator", "member", "owner"],
-)
-def test_api_recordings_list_authenticated_direct(role):
-    """
-    Authenticated users listing recordings, should only see the recordings
-    to which they are related.
-    """
-    user = factories.UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    other_user = factories.UserFactory()
-
-    access = factories.UserRecordingAccessFactory(role=role, user=user)
-    factories.UserRecordingAccessFactory(user=other_user)
-
-    recording = access.recording
-    room = recording.room
-
-    response = client.get(
-        "/api/v1.0/recordings/",
-    )
-
-    assert response.status_code == 200
-    results = response.json()["results"]
-    assert len(results) == 1
-    expected_ids = {
-        str(recording.id),
-    }
-    result_ids = {result["id"] for result in results}
-    assert expected_ids == result_ids
-    assert results[0] == {
-        "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),
-            "name": room.name,
-            "slug": room.slug,
-        },
-        "status": "initiated",
-        "updated_at": recording.updated_at.isoformat().replace("+00:00", "Z"),
-    }
-
-
-def test_api_recording_list_authenticated_via_team(mock_user_get_teams):
-    """
-    Authenticated users should be able to list recordings they are a
-    owner/administrator/member of via a team.
-    """
-    user = factories.UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    mock_user_get_teams.return_value = ["team1", "team2", "unknown"]
-
-    recordings_team1 = [
-        access.recording
-        for access in factories.TeamRecordingAccessFactory.create_batch(2, team="team1")
-    ]
-    recordings_team2 = [
-        access.recording
-        for access in factories.TeamRecordingAccessFactory.create_batch(3, team="team2")
-    ]
-
-    expected_ids = {
-        str(recording.id) for recording in recordings_team1 + recordings_team2
-    }
-
-    response = client.get("/api/v1.0/recordings/")
-
-    assert response.status_code == 200
-    results = response.json()["results"]
-    assert len(results) == 5
-    results_id = {result["id"] for result in results}
-    assert expected_ids == results_id
-
-
-@mock.patch.object(PageNumberPagination, "get_page_size", return_value=2)
-def test_api_recordings_list_pagination(_mock_page_size):
-    """Pagination should work as expected."""
-    user = factories.UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    recording_ids = [
-        str(access.recording_id)
-        for access in factories.UserRecordingAccessFactory.create_batch(3, user=user)
-    ]
-
-    response = client.get("/api/v1.0/recordings/")
-
-    assert response.status_code == 200
-    content = response.json()
-    assert content["count"] == 3
-    assert content["next"] == "http://testserver/api/v1.0/recordings/?page=2"
-    assert content["previous"] is None
-
-    assert len(content["results"]) == 2
-    for item in content["results"]:
-        recording_ids.remove(item["id"])
-
-    # Get page 2
-    response = client.get(
-        "/api/v1.0/recordings/?page=2",
-    )
-
-    assert response.status_code == 200
-    content = response.json()
-
-    assert content["count"] == 3
-    assert content["next"] is None
-    assert content["previous"], "http://testserver/api/v1.0/recordings/"
-
-    assert len(content["results"]) == 1
-    recording_ids.remove(content["results"][0]["id"])
-    assert recording_ids == []
-
-
-def test_api_recordings_list_authenticated_distinct():
-    """A recording for a room with several related users should only be listed once."""
-    user = factories.UserFactory()
-    other_user = factories.UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    recording = factories.RecordingFactory(users=[user, other_user])
-
-    response = client.get("/api/v1.0/recordings/")
-
-    assert response.status_code == 200
-    content = response.json()
-    assert len(content["results"]) == 1
-    assert content["results"][0]["id"] == str(recording.id)
-
-
-def test_api_recordings_list_ordering_default():
-    """Recordings should be ordered by descending "updated_at" by default"""
-    user = factories.UserFactory()
-    client = APIClient()
-    client.force_login(user)
-
-    factories.RecordingFactory.create_batch(5, users=[user])
-
-    response = client.get("/api/v1.0/recordings/")
-
-    assert response.status_code == 200
-    results = response.json()["results"]
-    assert len(results) == 5
-
-    # Check that results are sorted by descending "updated_at" as expected
-    for i in range(4):
-        assert operator.ge(results[i]["updated_at"], results[i + 1]["updated_at"])

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

@@ -1,203 +0,0 @@
-"""
-Test recordings API endpoints in the Meet core app: save recording.
-"""
-
-# pylint: disable=W0621,W0613
-
-import uuid
-from unittest import mock
-
-import pytest
-from rest_framework.test import APIClient
-
-from ...factories import RecordingFactory
-from ...models import Recording, RecordingStatusChoices
-from ...recording.event.exceptions import (
-    InvalidBucketError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-
-pytestmark = pytest.mark.django_db
-
-
-@pytest.fixture
-def recording_settings(settings):
-    """Configure recording-related and storage event Django settings."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-    settings.RECORDING_STORAGE_EVENT_ENABLE = True
-    return settings
-
-
-@pytest.fixture
-def mock_get_parser():
-    """Mock 'get_parser' factory function."""
-    with mock.patch("core.api.viewsets.get_parser") as mock_parser:
-        yield mock_parser
-
-
-def test_save_recording_anonymous(settings, client):
-    """Anonymous users should not be allowed to save room recordings."""
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-
-    RecordingFactory(status="active")
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-    )
-
-    assert response.status_code == 401
-    assert Recording.objects.count() == 1
-
-
-def test_save_recording_wrong_bearer(settings, client):
-    """Requests with incorrect bearer token should be rejected when auth is required."""
-
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer wrongAuthToken",
-    )
-
-    assert response.status_code == 401
-
-
-def test_save_recording_permission_needed(settings, client):
-    """Recordings should not be saved when feature is disabled."""
-
-    settings.RECORDING_STORAGE_EVENT_TOKEN = "testAuthToken"
-    settings.RECORDING_STORAGE_EVENT_ENABLE = False
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-
-
-def test_save_recording_parsing_error(recording_settings, mock_get_parser, client):
-    """Test handling of parsing errors in recording event data."""
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = ParsingEventDataError("Error message")
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"detail": "Invalid request data: Error message"}
-
-
-def test_save_recording_bucket_error(recording_settings, mock_get_parser, client):
-    """Test handling of invalid storage bucket errors in recording event data."""
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = InvalidBucketError("Error message")
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"detail": "Invalid bucket specified"}
-
-
-def test_save_recording_filetype_error(recording_settings, mock_get_parser):
-    """Test handling of unsupported file types in recording event data."""
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.side_effect = InvalidFileTypeError(
-        "unsupported '.json'"
-    )
-    mock_get_parser.return_value = mock_parser
-
-    client = APIClient()
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Ignore this file type, unsupported '.json'"}
-
-
-def test_save_recording_unknown_recording(recording_settings, mock_get_parser, client):
-    """Test handling of events for non-existent recordings."""
-
-    RecordingFactory(status="active")
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = uuid.uuid4()
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {"detail": "No recording found for this event."}
-
-
-@pytest.mark.parametrize(
-    "status", ["failed_to_start", "aborted", "failed_to_stop", "saved", "initiated"]
-)
-def test_save_recording_non_savable_recording(
-    recording_settings, mock_get_parser, client, status
-):
-    """Test that recordings in non-savable states cannot be saved."""
-
-    recording = RecordingFactory(status=status)
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = recording.id
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {
-        "detail": f"Recording with ID {recording.id} cannot be saved because it is either,"
-        " in an error state or has already been saved."
-    }
-
-
-@pytest.mark.parametrize("status", ["active", "stopped"])
-def test_save_recording_success(recording_settings, mock_get_parser, client, status):
-    """Test successful saving of recordings in valid states."""
-
-    recording = RecordingFactory(status=status)
-
-    mock_parser = mock.Mock()
-    mock_parser.get_recording_id.return_value = recording.id
-    mock_get_parser.return_value = mock_parser
-
-    response = client.post(
-        "/api/v1.0/recordings/storage-hook/",
-        {"recording_data": "valid-data"},
-        HTTP_AUTHORIZATION="Bearer testAuthToken",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"message": "Event processed."}
-
-    recording.refresh_from_db()
-    assert recording.status == RecordingStatusChoices.SAVED

src/backend/core/tests/recording/worker/test_factories.py

@@ -5,17 +5,12 @@ Test worker service factories.
 # pylint: disable=W0212,W0621,W0613
 
 from dataclasses import FrozenInstanceError
-from unittest.mock import Mock
 
 from django.test import override_settings
 
 import pytest
 
-from core.recording.worker.factories import (
-    WorkerService,
-    WorkerServiceConfig,
-    get_worker_service,
-)
+from core.recording.worker.factories import WorkerServiceConfig, WorkerServiceFactory
 
 
 @pytest.fixture(autouse=True)
@@ -46,18 +41,18 @@ def test_settings():
 
 
 @pytest.fixture
-def default_config(test_settings):
+def config(test_settings):
     """Fixture to provide a WorkerServiceConfig instance"""
     return WorkerServiceConfig.from_settings()
 
 
 # Tests
-def test_config_initialization(default_config):
+def test_config_initialization(config):
     """Test that WorkerServiceConfig is properly initialized from settings"""
-    assert default_config.output_folder == "/test/output"
-    assert default_config.server_configurations == {"server": "test.example.com"}
-    assert default_config.verify_ssl is True
-    assert default_config.bucket_args == {
+    assert config.output_folder == "/test/output"
+    assert config.server_configurations == {"server": "test.example.com"}
+    assert config.verify_ssl is True
+    assert config.bucket_args == {
         "endpoint": "https://s3.test.com",
         "access_key": "test_key",
         "secret": "test_secret",
@@ -67,10 +62,10 @@ def test_config_initialization(default_config):
     }
 
 
-def test_config_immutability(default_config):
+def test_config_immutability(config):
     """Test that config instances are immutable after creation"""
     with pytest.raises(FrozenInstanceError):
-        default_config.output_folder = "new/path"
+        config.output_folder = "new/path"
 
 
 @override_settings(
@@ -93,79 +88,67 @@ def test_config_caching():
     assert config1 is config2
 
 
-class MockWorkerService(WorkerService):
-    """Mock worker service for testing."""
+@pytest.fixture
+def mock_worker_service():
+    """Fixture to provide a mock WorkerService implementation"""
 
-    def __init__(self, config):
-        self.config = config
+    class TestWorkerService:
+        """Mock WorkerService"""
+
+        hrid = "test-worker"
+
+        def __init__(self, config):
+            """Mock init"""
+            self.config = config
+
+        def start(self, room_id, recording_id):
+            """Mock start method"""
+            return f"worker_{room_id}_{recording_id}"
+
+        def stop(self, worker_id):
+            """Mock stop method"""
+            return f"stopped_{worker_id}"
+
+    return TestWorkerService
 
 
 @pytest.fixture
-def mock_import_string(monkeypatch):
-    """Fixture to mock import_string function."""
-    mock = Mock(return_value=MockWorkerService)
-    monkeypatch.setattr("core.recording.worker.factories.import_string", mock)
-    return mock
+def factory():
+    """Fixture to provide a clean WorkerServiceFactory instance"""
+    return WorkerServiceFactory()
 
 
-def test_factory_valid_mode(mock_import_string, settings, default_config):
-    """Test getting worker service with valid mode."""
-
-    settings.RECORDING_WORKER_CLASSES = {
-        "test_mode": "path.to.MockWorkerService",
-        "another_mode": "path.to.AnotherWorkerService",
-    }
-
-    worker = get_worker_service("test_mode")
-
-    mock_import_string.assert_called_once_with("path.to.MockWorkerService")
-    assert isinstance(worker, MockWorkerService)
-    assert worker.config == default_config
+def test_factory_initialization(factory, config):
+    """Test that factory is properly initialized"""
+    assert factory._worker_service_registry == {}
+    assert isinstance(factory._default_config, WorkerServiceConfig)
+    assert factory._default_config == config
 
 
-def test_factory_invalid_mode(settings, mock_import_string, default_config):
-    """Test getting worker service with invalid mode raises ValueError."""
+def test_register_worker_service(factory, mock_worker_service):
+    """Test registering a new worker service"""
+    factory.register("test", mock_worker_service)
+    assert factory._worker_service_registry["test"] == mock_worker_service
 
-    settings.RECORDING_WORKER_CLASSES = {
-        "test_mode": "path.to.MockWorkerService",
-        "another_mode": "path.to.AnotherWorkerService",
-    }
 
-    worker = get_worker_service("test_mode")
+def test_register_duplicate_worker_service(factory, mock_worker_service):
+    """Test that registering a duplicate worker service raises an error"""
+    factory.register("test", mock_worker_service)
+    with pytest.raises(KeyError) as exc_info:
+        factory.register("test", mock_worker_service)
+    assert "already registered" in str(exc_info.value)
 
-    mock_import_string.assert_called_once_with("path.to.MockWorkerService")
-    assert isinstance(worker, MockWorkerService)
 
+def test_create_worker_service(factory, mock_worker_service):
+    """Test creating a worker service instance"""
+    factory.register("test", mock_worker_service)
+    worker = factory.create("test")
+    assert isinstance(worker, mock_worker_service)
+    assert worker.hrid == "test-worker"
+
+
+def test_create_unknown_worker_service(factory):
+    """Test that creating an unknown worker service raises an error"""
     with pytest.raises(ValueError) as exc_info:
-        get_worker_service("invalid_mode")
-        mock_import_string.assert_not_called()
-
-    assert "Recording mode 'invalid_mode' not found" in str(exc_info.value)
-    assert "Available modes: ['test_mode', 'another_mode']" in str(exc_info.value)
-
-
-def test_factory_import_error(mock_import_string, settings):
-    """Test handling of import errors."""
-
-    mock_import_string.side_effect = ImportError("Module not found")
-
-    settings.RECORDING_WORKER_CLASSES = {
-        "test_mode": "path.to.MockWorkerService",
-        "another_mode": "path.to.AnotherWorkerService",
-    }
-
-    with pytest.raises(ImportError) as exc_info:
-        get_worker_service("test_mode")
-
-    assert "Module not found" in str(exc_info.value)
-
-
-def test_factory_empty_registry(settings):
-    """Test behavior when worker registry is empty."""
-
-    settings.RECORDING_WORKER_CLASSES = {}
-
-    with pytest.raises(ValueError) as exc_info:
-        get_worker_service("any_mode")
-
-    assert "Available modes: []" in str(exc_info.value)
+        factory.create("unknown")
+    assert "Unknown worker service" in str(exc_info.value)

src/backend/core/tests/recording/worker/test_mediator.py

@@ -45,7 +45,7 @@ def test_start_recording_success(mediator, mock_worker_service):
     mediator.start(mock_recording)
 
     # Verify worker service call
-    expected_room_name = str(mock_recording.room.id)
+    expected_room_name = str(mock_recording.room.id).replace("-", "")
     mock_worker_service.start.assert_called_once_with(
         expected_room_name, mock_recording.id
     )

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

@@ -6,7 +6,10 @@ Test rooms API endpoints in the Meet core app: start recording.
 
 from unittest import mock
 
+from django.test.utils import override_settings
+
 import pytest
+from rest_framework import status
 from rest_framework.test import APIClient
 
 from ...factories import RoomFactory, UserFactory
@@ -23,13 +26,13 @@ def mock_worker_service():
 
 
 @pytest.fixture
-def mock_worker_service_factory(mock_worker_service):
+def mock_worker_service_provider(mock_worker_service):
     """Mock worker service factory."""
     with mock.patch(
-        "core.api.viewsets.get_worker_service",
+        "core.api.viewsets.worker_service_provider.create",
         return_value=mock_worker_service,
-    ) as mock_worker_service_factory:
-        yield mock_worker_service_factory
+    ) as mock_worker_service_provider:
+        yield mock_worker_service_provider
 
 
 @pytest.fixture
@@ -47,11 +50,10 @@ def test_start_recording_anonymous():
     client = APIClient()
 
     response = client.post(
-        f"/api/v1.0/rooms/{room.id}/start-recording/",
-        {"mode": "screen_recording"},
+        f"/api/v1.0/rooms/{room.id}/start-recording/", {"mode": "standard"}
     )
 
-    assert response.status_code == 401
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
     assert Recording.objects.count() == 0
 
 
@@ -63,18 +65,16 @@ def test_start_recording_non_owner_and_non_administrator():
     client.force_login(user)
 
     response = client.post(
-        f"/api/v1.0/rooms/{room.id}/start-recording/",
-        {"mode": "screen_recording"},
+        f"/api/v1.0/rooms/{room.id}/start-recording/", {"mode": "standard"}
     )
 
-    assert response.status_code == 403
+    assert response.status_code == status.HTTP_403_FORBIDDEN
     assert Recording.objects.count() == 0
 
 
-def test_start_recording_recording_disabled(settings):
+@override_settings(RECORDING_ENABLE=False)
+def test_start_recording_recording_disabled():
     """Should fail if recording is disabled for the room."""
-    settings.RECORDING_ENABLE = False
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -84,19 +84,17 @@ def test_start_recording_recording_disabled(settings):
     client.force_login(user)
 
     response = client.post(
-        f"/api/v1.0/rooms/{room.id}/start-recording/",
-        {"mode": "screen_recording"},
+        f"/api/v1.0/rooms/{room.id}/start-recording/", {"mode": "standard"}
     )
 
-    assert response.status_code == 403
+    assert response.status_code == status.HTTP_403_FORBIDDEN
     assert response.json() == {"detail": "Access denied, recording is disabled."}
     assert Recording.objects.count() == 0
 
 
-def test_start_recording_missing_mode(settings):
+@override_settings(RECORDING_ENABLE=True)
+def test_start_recording_missing_mode():
     """Should fail if recording mode is not provided."""
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -107,17 +105,16 @@ def test_start_recording_missing_mode(settings):
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/start-recording/", {})
 
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Invalid request."}
+    assert response.status_code == status.HTTP_400_BAD_REQUEST
+    assert response.json() == {"error": "Recording mode is required."}
     assert Recording.objects.count() == 0
 
 
+@override_settings(RECORDING_ENABLE=True)
 def test_start_recording_worker_error(
-    mock_worker_service_factory, mock_worker_manager, settings
+    mock_worker_service_provider, mock_worker_manager
 ):
     """Should handle worker service errors appropriately."""
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -133,13 +130,12 @@ def test_start_recording_worker_error(
     client.force_login(user)
 
     response = client.post(
-        f"/api/v1.0/rooms/{room.id}/start-recording/",
-        {"mode": "screen_recording"},
+        f"/api/v1.0/rooms/{room.id}/start-recording/", {"mode": "screen_recording"}
     )
 
-    mock_worker_service_factory.assert_called_once_with(mode="screen_recording")
+    mock_worker_service_provider.assert_called_once_with(mode="screen_recording")
 
-    assert response.status_code == 500
+    assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
     assert response.json() == {
         "error": f"Recording failed to start for room {room.slug}"
     }
@@ -149,20 +145,12 @@ def test_start_recording_worker_error(
     recording = Recording.objects.first()
     assert recording.room == room
     assert recording.mode == "screen_recording"
-
-    # Verify recording access details
-    assert recording.accesses.count() == 1
-    access = recording.accesses.first()
-    assert access.user == user
-    assert access.role == "owner"
+    assert recording.creator == user
 
 
-def test_start_recording_success(
-    mock_worker_service_factory, mock_worker_manager, settings
-):
+@override_settings(RECORDING_ENABLE=True)
+def test_start_recording_success(mock_worker_service_provider, mock_worker_manager):
     """Should successfully start recording when everything is configured correctly."""
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -175,13 +163,12 @@ def test_start_recording_success(
     client.force_login(user)
 
     response = client.post(
-        f"/api/v1.0/rooms/{room.id}/start-recording/",
-        {"mode": "screen_recording"},
+        f"/api/v1.0/rooms/{room.id}/start-recording/", {"mode": "screen_recording"}
     )
 
-    mock_worker_service_factory.assert_called_once_with(mode="screen_recording")
+    mock_worker_service_provider.assert_called_once_with(mode="screen_recording")
 
-    assert response.status_code == 201
+    assert response.status_code == status.HTTP_201_CREATED
     assert response.json() == {
         "message": f"Recording successfully started for room {room.slug}"
     }
@@ -189,12 +176,3 @@ def test_start_recording_success(
     # Verify the mediator was called with the recording
     recording = Recording.objects.first()
     mock_start.assert_called_once_with(recording)
-
-    assert recording.room == room
-    assert recording.mode == "screen_recording"
-
-    # Verify recording access details
-    assert recording.accesses.count() == 1
-    access = recording.accesses.first()
-    assert access.user == user
-    assert access.role == "owner"

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

@@ -6,7 +6,10 @@ Test rooms API endpoints in the Meet core app: stop recording.
 
 from unittest import mock
 
+from django.test.utils import override_settings
+
 import pytest
+from rest_framework import status
 from rest_framework.test import APIClient
 
 from ...factories import RecordingFactory, RoomFactory, UserFactory
@@ -23,13 +26,13 @@ def mock_worker_service():
 
 
 @pytest.fixture
-def mock_worker_service_factory(mock_worker_service):
+def mock_worker_service_provider(mock_worker_service):
     """Mock worker service factory."""
     with mock.patch(
-        "core.api.viewsets.get_worker_service",
+        "core.api.viewsets.worker_service_provider.create",
         return_value=mock_worker_service,
-    ) as mock_worker_service_factory:
-        yield mock_worker_service_factory
+    ) as mock_worker_service_provider:
+        yield mock_worker_service_provider
 
 
 @pytest.fixture
@@ -49,7 +52,7 @@ def test_stop_recording_anonymous():
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    assert response.status_code == 401
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
     # Verify recording status hasn't changed
     assert Recording.objects.filter(status=RecordingStatusChoices.ACTIVE).count() == 1
 
@@ -64,16 +67,14 @@ def test_stop_recording_non_owner_and_non_administrator():
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    assert response.status_code == 403
+    assert response.status_code == status.HTTP_403_FORBIDDEN
     # Verify recording status hasn't changed
     assert Recording.objects.filter(status=RecordingStatusChoices.ACTIVE).count() == 1
 
 
-def test_stop_recording_recording_disabled(settings):
+@override_settings(RECORDING_ENABLE=False)
+def test_stop_recording_recording_disabled():
     """Should fail if recording is disabled for the room."""
-
-    settings.RECORDING_ENABLE = False
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -84,17 +85,15 @@ def test_stop_recording_recording_disabled(settings):
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    assert response.status_code == 403
+    assert response.status_code == status.HTTP_403_FORBIDDEN
     assert response.json() == {"detail": "Access denied, recording is disabled."}
     # Verify no recording exists
     assert Recording.objects.count() == 0
 
 
-def test_stop_recording_no_active_recording(settings):
+@override_settings(RECORDING_ENABLE=True)
+def test_stop_recording_no_active_recording():
     """Should fail when there is no active recording for the room."""
-
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     # Make user the room owner
@@ -105,23 +104,17 @@ def test_stop_recording_no_active_recording(settings):
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    assert response.status_code == 404
+    assert response.status_code == status.HTTP_404_NOT_FOUND
     assert response.json() == {"detail": "No active recording found for this room."}
 
 
-def test_stop_recording_worker_error(
-    mock_worker_service_factory, mock_worker_manager, settings
-):
+@override_settings(RECORDING_ENABLE=True)
+def test_stop_recording_worker_error(mock_worker_service_provider, mock_worker_manager):
     """Should handle worker service errors appropriately."""
-
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     recording = RecordingFactory(
-        room=room,
-        status=RecordingStatusChoices.ACTIVE,
-        mode="screen_recording",
+        room=room, status=RecordingStatusChoices.ACTIVE, mode="screen_recording"
     )
     # Make user the room owner
     room.accesses.create(user=user, role="owner")
@@ -136,10 +129,10 @@ def test_stop_recording_worker_error(
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    mock_worker_service_factory.assert_called_once_with(mode="screen_recording")
+    mock_worker_service_provider.assert_called_once_with(mode="screen_recording")
     mock_stop.assert_called_once_with(recording)
 
-    assert response.status_code == 500
+    assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
     assert response.json() == {
         "error": f"Recording failed to stop for room {room.slug}"
     }
@@ -147,19 +140,13 @@ def test_stop_recording_worker_error(
     assert Recording.objects.filter(status=RecordingStatusChoices.ACTIVE).count() == 1
 
 
-def test_stop_recording_success(
-    mock_worker_service_factory, mock_worker_manager, settings
-):
+@override_settings(RECORDING_ENABLE=True)
+def test_stop_recording_success(mock_worker_service_provider, mock_worker_manager):
     """Should successfully stop recording when everything is configured correctly."""
-
-    settings.RECORDING_ENABLE = True
-
     room = RoomFactory()
     user = UserFactory()
     recording = RecordingFactory(
-        room=room,
-        status=RecordingStatusChoices.ACTIVE,
-        mode="screen_recording",
+        room=room, status=RecordingStatusChoices.ACTIVE, mode="screen_recording"
     )
     # Make user the room owner
     room.accesses.create(user=user, role="owner")
@@ -172,10 +159,10 @@ def test_stop_recording_success(
 
     response = client.post(f"/api/v1.0/rooms/{room.id}/stop-recording/")
 
-    mock_worker_service_factory.assert_called_once_with(mode="screen_recording")
+    mock_worker_service_provider.assert_called_once_with(mode="screen_recording")
     mock_stop.assert_called_once_with(recording)
 
-    assert response.status_code == 200
+    assert response.status_code == status.HTTP_200_OK
     assert response.json() == {"message": f"Recording stopped for room {room.slug}."}
 
     # Verify the recording still exists

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,17 +37,17 @@ 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)
-    id_no_dashes = str(room.id)
+    room = RoomFactory(is_public=False)
+    id_no_dashes = str(room.id).replace("-", "")
 
     client = APIClient()
     response = client.get(f"/api/v1.0/rooms/{id_no_dashes: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,
     }
@@ -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}"
+    expected_name = f"{room.id!s}".replace("-", "")
     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()
@@ -240,11 +220,11 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
     )
     assert response.status_code == 200
 
-    expected_name = f"{room.id!s}"
+    expected_name = f"{room.id!s}".replace("-", "")
     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,
     }
@@ -367,8 +301,6 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries):
                 "user": {
                     "id": str(user_access.user.id),
                     "email": user_access.user.email,
-                    "full_name": user_access.user.full_name,
-                    "short_name": user_access.user.short_name,
                 },
                 "resource": str(room.id),
                 "role": user_access.role,
@@ -378,8 +310,6 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries):
                 "user": {
                     "id": str(other_user_access.user.id),
                     "email": other_user_access.user.email,
-                    "full_name": other_user_access.user.full_name,
-                    "short_name": other_user_access.user.short_name,
                 },
                 "resource": str(room.id),
                 "role": other_user_access.role,
@@ -388,11 +318,11 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries):
         key=lambda x: x["id"],
     )
 
-    expected_name = str(room.id)
+    expected_name = str(room.id).replace("-", "")
     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 +332,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")
@@ -446,8 +374,6 @@ def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries
                 "user": {
                     "id": str(other_user_access.user.id),
                     "email": other_user_access.user.email,
-                    "full_name": other_user_access.user.full_name,
-                    "short_name": other_user_access.user.short_name,
                 },
                 "resource": str(room.id),
                 "role": other_user_access.role,
@@ -457,8 +383,6 @@ def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries
                 "user": {
                     "id": str(user_access.user.id),
                     "email": user_access.user.email,
-                    "full_name": user_access.user.full_name,
-                    "short_name": user_access.user.short_name,
                 },
                 "resource": str(room.id),
                 "role": user_access.role,
@@ -466,11 +390,11 @@ def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries
         ],
         key=lambda x: x["id"],
     )
-    expected_name = str(room.id)
+    expected_name = str(room.id).replace("-", "")
     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 +405,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,952 +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_no_room(mock_livekit_api, lobby_service):
-    """Test the notify_participants method when the LiveKit room doesn't exist yet."""
-    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()
-
-    # Create a proper response object with an empty rooms list
-    class MockResponse:
-        """LiveKit API response mock with empty rooms list."""
-
-        rooms = []
-
-    mock_api_instance.room.list_rooms = mock.AsyncMock(return_value=MockResponse())
-    mock_api_instance.aclose = mock.AsyncMock()
-    mock_livekit_api.return_value = mock_api_instance
-
-    # Act
-    lobby_service.notify_participants(room.id)
-
-    # Assert
-    # Verify the API was initialized with correct configuration
-    mock_livekit_api.assert_called_once_with(**settings.LIVEKIT_CONFIGURATION)
-
-    # Verify that the service checked for existing rooms
-    mock_api_instance.room.list_rooms.assert_called_once()
-
-    # Verify the send_data method was not called since no room exists
-    mock_api_instance.room.send_data.assert_not_called()
-
-    # Verify the connection was properly closed
-    mock_api_instance.aclose.assert_called_once()
-
-
-@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()
-
-    class MockResponse:
-        """LiveKit API response mock with empty rooms list."""
-
-        rooms = ["room-1"]
-
-    mock_api_instance.room.list_rooms = mock.AsyncMock(return_value=MockResponse())
-
-    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 that the service checked for existing rooms
-    mock_api_instance.room.list_rooms.assert_called_once()
-
-    # 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)
-    )
-
-    class MockResponse:
-        """LiveKit API response mock with empty rooms list."""
-
-        rooms = ["room-1"]
-
-    mock_api_instance.room.list_rooms = mock.AsyncMock(return_value=MockResponse())
-
-    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 that the service checked for existing rooms
-    mock_api_instance.room.list_rooms.assert_called_once()
-
-    # 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.py

@@ -1,183 +0,0 @@
-"""
-Test marketing services.
-"""
-
-# pylint: disable=W0621,W0613
-
-from unittest import mock
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-
-import brevo_python
-import pytest
-
-from core.services.marketing import (
-    BrevoMarketingService,
-    ContactCreationError,
-    ContactData,
-    get_marketing_service,
-)
-
-
-def test_init_missing_api_key(settings):
-    """Test initialization with missing API key."""
-    settings.BREVO_API_KEY = None
-    with pytest.raises(ImproperlyConfigured, match="Brevo API key is required"):
-        BrevoMarketingService()
-
-
-def test_create_contact_missing_list_ids(settings):
-    """Test contact creation with missing list IDs."""
-
-    settings.BREVO_API_KEY = "test-api-key"
-    settings.BREVO_API_CONTACT_LIST_IDS = None
-    settings.BREVO_API_CONTACT_ATTRIBUTES = {"source": "test"}
-
-    valid_contact_data = ContactData(
-        email="test@example.com",
-        attributes={"first_name": "Test"},
-        list_ids=[1, 2],
-        update_enabled=True,
-    )
-
-    brevo_service = BrevoMarketingService()
-
-    with pytest.raises(
-        ImproperlyConfigured, match="Default Brevo List IDs must be configured"
-    ):
-        brevo_service.create_contact(valid_contact_data)
-
-
-@mock.patch("brevo_python.ContactsApi")
-def test_create_contact_success(mock_contact_api):
-    """Test successful contact creation."""
-
-    mock_api = mock_contact_api.return_value
-
-    settings.BREVO_API_KEY = "test-api-key"
-    settings.BREVO_API_CONTACT_LIST_IDS = [1, 2, 3, 4]
-    settings.BREVO_API_CONTACT_ATTRIBUTES = {"source": "test"}
-
-    valid_contact_data = ContactData(
-        email="test@example.com",
-        attributes={"first_name": "Test"},
-        list_ids=[1, 2],
-        update_enabled=True,
-    )
-
-    brevo_service = BrevoMarketingService()
-
-    mock_api.create_contact.return_value = {"id": "test-id"}
-    response = brevo_service.create_contact(valid_contact_data)
-
-    assert response == {"id": "test-id"}
-
-    mock_api.create_contact.assert_called_once()
-    contact_arg = mock_api.create_contact.call_args[0][0]
-    assert contact_arg.email == "test@example.com"
-    assert contact_arg.attributes == {
-        **settings.BREVO_API_CONTACT_ATTRIBUTES,
-        **valid_contact_data.attributes,
-    }
-    assert set(contact_arg.list_ids) == {1, 2, 3, 4}
-    assert contact_arg.update_enabled is True
-
-
-@mock.patch("brevo_python.ContactsApi")
-def test_create_contact_with_timeout(mock_contact_api):
-    """Test contact creation with timeout."""
-
-    mock_api = mock_contact_api.return_value
-
-    settings.BREVO_API_KEY = "test-api-key"
-    settings.BREVO_API_CONTACT_LIST_IDS = [1, 2, 3, 4]
-    settings.BREVO_API_CONTACT_ATTRIBUTES = {"source": "test"}
-
-    valid_contact_data = ContactData(
-        email="test@example.com",
-        attributes={"first_name": "Test"},
-        list_ids=[1, 2],
-        update_enabled=True,
-    )
-
-    brevo_service = BrevoMarketingService()
-    brevo_service.create_contact(valid_contact_data, timeout=30)
-
-    mock_api.create_contact.assert_called_once()
-    assert mock_api.create_contact.call_args[1]["_request_timeout"] == 30
-
-
-@mock.patch("brevo_python.ContactsApi")
-def test_create_contact_api_error(mock_contact_api):
-    """Test contact creation API error handling."""
-
-    mock_api = mock_contact_api.return_value
-
-    settings.BREVO_API_KEY = "test-api-key"
-    settings.BREVO_API_CONTACT_LIST_IDS = [1, 2, 3, 4]
-    settings.BREVO_API_CONTACT_ATTRIBUTES = {"source": "test"}
-
-    valid_contact_data = ContactData(
-        email="test@example.com",
-        attributes={"first_name": "Test"},
-        list_ids=[1, 2],
-        update_enabled=True,
-    )
-
-    brevo_service = BrevoMarketingService()
-
-    mock_api.create_contact.side_effect = brevo_python.rest.ApiException()
-
-    with pytest.raises(ContactCreationError, match="Failed to create contact in Brevo"):
-        brevo_service.create_contact(valid_contact_data)
-
-
-@pytest.fixture
-def clear_marketing_cache():
-    """Clear marketing service cache between tests."""
-    get_marketing_service.cache_clear()
-    yield
-    get_marketing_service.cache_clear()
-
-
-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"
-
-    service1 = get_marketing_service()
-    service2 = get_marketing_service()
-
-    assert service1 is service2
-    assert isinstance(service1, BrevoMarketingService)
-
-
-def test_get_marketing_service_invalid_class(clear_marketing_cache):
-    """Test handling of invalid service class."""
-    settings.MARKETING_SERVICE_CLASS = "invalid.service.path"
-
-    with pytest.raises(ImportError):
-        get_marketing_service()
-
-
-@mock.patch("core.services.marketing.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"
-    get_marketing_service.cache_clear()
-
-    mock_service_cls = mock.Mock()
-    mock_service_instance = mock.Mock()
-    mock_service_cls.return_value = mock_service_instance
-    mock_import_string.return_value = mock_service_cls
-
-    service1 = get_marketing_service()
-    service2 = get_marketing_service()
-
-    mock_import_string.assert_called_once_with(settings.MARKETING_SERVICE_CLASS)
-    mock_service_cls.assert_called_once()
-    assert service1 is service2
-    assert service1 is mock_service_instance

src/backend/core/tests/test_analytics.py

@@ -0,0 +1,132 @@
+"""
+Test for the Analytics class.
+"""
+
+# pylint: disable=W0212
+
+from unittest.mock import patch
+
+from django.contrib.auth.models import AnonymousUser
+from django.test.utils import override_settings
+
+import pytest
+
+from core.analytics import Analytics
+from core.factories import UserFactory
+
+pytestmark = pytest.mark.django_db
+
+
+@pytest.fixture(name="mock_june_analytics")
+def _mock_june_analytics():
+    with patch("core.analytics.jAnalytics") as mock:
+        yield mock
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_init_enabled(mock_june_analytics):
+    """Should enable analytics and set the write key correctly when ANALYTICS_KEY is set."""
+    analytics = Analytics()
+    assert analytics._enabled is True
+    assert mock_june_analytics.write_key == "test_key"
+
+
+@override_settings(ANALYTICS_KEY=None)
+def test_analytics_init_disabled():
+    """Should disable analytics when ANALYTICS_KEY is not set."""
+    analytics = Analytics()
+    assert analytics._enabled is False
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_identify_user(mock_june_analytics):
+    """Should identify a user with the correct traits when analytics is enabled."""
+    user = UserFactory(sub="12345", email="user@example.com")
+    analytics = Analytics()
+    analytics.identify(user)
+    mock_june_analytics.identify.assert_called_once_with(
+        user_id="12345", traits={"email": "***@example.com"}
+    )
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_identify_user_with_traits(mock_june_analytics):
+    """Should identify a user with additional traits when analytics is enabled."""
+    user = UserFactory(sub="12345", email="user@example.com")
+    analytics = Analytics()
+    analytics.identify(user, traits={"email": "user@example.com", "foo": "foo"})
+    mock_june_analytics.identify.assert_called_once_with(
+        user_id="12345", traits={"email": "***@example.com", "foo": "foo"}
+    )
+
+
+@override_settings(ANALYTICS_KEY=None)
+def test_analytics_identify_not_enabled(mock_june_analytics):
+    """Should not call identify when analytics is not enabled."""
+    user = UserFactory(sub="12345", email="user@example.com")
+    analytics = Analytics()
+    analytics.identify(user)
+    mock_june_analytics.identify.assert_not_called()
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_identify_no_user(mock_june_analytics):
+    """Should not call identify when the user is None."""
+    analytics = Analytics()
+    analytics.identify(None)
+    mock_june_analytics.identify.assert_not_called()
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_identify_anonymous_user(mock_june_analytics):
+    """Should not call identify when the user is anonymous."""
+    user = AnonymousUser()
+    analytics = Analytics()
+    analytics.identify(user)
+    mock_june_analytics.identify.assert_not_called()
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+def test_analytics_track_event(mock_june_analytics):
+    """Should track an event with the correct user and event details when analytics is enabled."""
+    user = UserFactory(sub="12345")
+    analytics = Analytics()
+    analytics.track(user, event="test_event", foo="foo")
+    mock_june_analytics.track.assert_called_once_with(
+        user_id="12345", event="test_event", foo="foo"
+    )
+
+
+@override_settings(ANALYTICS_KEY=None)
+def test_analytics_track_event_not_enabled(mock_june_analytics):
+    """Should not call track when analytics is not enabled."""
+    user = UserFactory(sub="12345")
+    analytics = Analytics()
+    analytics.track(user, event="test_event", foo="foo")
+
+    mock_june_analytics.track.assert_not_called()
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+@patch("uuid.uuid4", return_value="test_uuid4")
+def test_analytics_track_event_no_user(mock_uuid4, mock_june_analytics):
+    """Should track an event with a random anonymous user ID when the user is None."""
+    analytics = Analytics()
+    analytics.track(None, event="test_event", foo="foo")
+    mock_june_analytics.track.assert_called_once_with(
+        anonymous_id="test_uuid4", event="test_event", foo="foo"
+    )
+    mock_uuid4.assert_called_once()
+
+
+@override_settings(ANALYTICS_KEY="test_key")
+@patch("uuid.uuid4", return_value="test_uuid4")
+def test_analytics_track_event_anonymous_user(mock_uuid4, mock_june_analytics):
+    """Should track an event with a random anonymous user ID when the user is anonymous."""
+    user = AnonymousUser()
+    analytics = Analytics()
+    analytics.track(user, event="test_event", foo="foo")
+    mock_june_analytics.track.assert_called_once_with(
+        anonymous_id="test_uuid4", event="test_event", foo="foo"
+    )
+    mock_uuid4.assert_called_once()

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()
@@ -89,7 +66,7 @@ def test_api_users_list_query_email(settings):
 
     assert response.status_code == 200
     user_ids = [user["id"] for user in response.json()["results"]]
-    assert user_ids == [str(frank.id), str(nicole.id)]
+    assert user_ids == [str(nicole.id), str(frank.id)]
 
 
 def test_api_users_retrieve_me_anonymous():
@@ -119,8 +96,6 @@ def test_api_users_retrieve_me_authenticated():
     assert response.json() == {
         "id": str(user.id),
         "email": user.email,
-        "full_name": user.full_name,
-        "short_name": user.short_name,
     }
 
 

src/backend/core/tests/test_model_recording.py

@@ -6,12 +6,7 @@ from django.core.exceptions import ValidationError
 
 import pytest
 
-from core.factories import (
-    RecordingFactory,
-    RoomFactory,
-    UserFactory,
-    UserRecordingAccessFactory,
-)
+from core.factories import RecordingFactory, RoomFactory, UserFactory
 from core.models import Recording, RecordingStatusChoices
 
 pytestmark = pytest.mark.django_db
@@ -20,7 +15,7 @@ pytestmark = pytest.mark.django_db
 def test_models_recording_str():
     """The str representation should be the recording ID."""
     recording = RecordingFactory()
-    assert str(recording) == f"Recording {recording.id} (initiated)"
+    assert str(recording) == str(recording.id)
 
 
 def test_models_recording_ordering():
@@ -31,6 +26,14 @@ def test_models_recording_ordering():
     assert recordings[1].created_at >= recordings[2].created_at
 
 
+def test_models_recording_creator_relationship():
+    """It should maintain proper relationship with creator."""
+    user = UserFactory()
+    recording = RecordingFactory(creator=user)
+    assert recording.creator == user
+    assert recording in user.recordings.all()
+
+
 def test_models_recording_room_relationship():
     """It should maintain proper relationship with room."""
     room = RoomFactory()
@@ -66,36 +69,25 @@ def test_models_recording_multiple_finished_allowed():
 
 
 # Test get_abilities method
-
-
-@pytest.mark.parametrize(
-    "role",
-    ["owner", "administrator"],
-)
-def test_models_recording_get_abilities_privileges_active(role):
-    """Test abilities for active recording and privileged user."""
-
-    user = UserFactory()
-    access = UserRecordingAccessFactory(role=role, user=user)
-    access.recording.status = RecordingStatusChoices.ACTIVE
-    abilities = access.recording.get_abilities(user)
+def test_models_recording_get_abilities_creator():
+    """Test abilities for the recording creator."""
+    recording = RecordingFactory(status=RecordingStatusChoices.ACTIVE)
+    abilities = recording.get_abilities(recording.creator)
 
     assert abilities == {
         "destroy": False,  # Not final status
         "partial_update": False,
-        "retrieve": True,  # Privileged users can always retrieve
+        "retrieve": True,  # Creator can always retrieve
         "stop": True,  # Not final status, so can stop
         "update": False,
     }
 
 
-def test_models_recording_get_abilities_member_active():
-    """Test abilities for a user who is unprivileged."""
-
-    user = UserFactory()
-    access = UserRecordingAccessFactory(role="member", user=user)
-    access.recording.status = RecordingStatusChoices.ACTIVE
-    abilities = access.recording.get_abilities(user)
+def test_models_recording_get_abilities_non_creator():
+    """Test abilities for a user who isn't the creator."""
+    recording = RecordingFactory()
+    other_user = UserFactory()
+    abilities = recording.get_abilities(other_user)
 
     assert abilities == {
         "destroy": False,
@@ -106,47 +98,21 @@ def test_models_recording_get_abilities_member_active():
     }
 
 
-@pytest.mark.parametrize(
-    "role",
-    ["owner", "administrator"],
-)
-def test_models_recording_get_abilities_privileges_final(role):
-    """Test abilities for active recording and privileged user."""
-
-    user = UserFactory()
-    access = UserRecordingAccessFactory(role=role, user=user)
-    access.recording.status = RecordingStatusChoices.SAVED
-    abilities = access.recording.get_abilities(user)
+def test_models_recording_get_abilities_final_status():
+    """Test abilities when recording is in final status."""
+    recording = RecordingFactory(status=RecordingStatusChoices.SAVED)
+    abilities = recording.get_abilities(recording.creator)
 
     assert abilities == {
-        "destroy": True,
+        "destroy": True,  # Final status, creator can destroy
         "partial_update": False,
-        "retrieve": True,  # Privileged users can always retrieve
-        "stop": False,  # In final status, so can not stop
-        "update": False,
-    }
-
-
-def test_models_recording_get_abilities_member_final():
-    """Test abilities for a user who is unprivileged."""
-
-    user = UserFactory()
-    access = UserRecordingAccessFactory(role="member", user=user)
-    access.recording.status = RecordingStatusChoices.SAVED
-    abilities = access.recording.get_abilities(user)
-
-    assert abilities == {
-        "destroy": False,
-        "partial_update": False,
-        "retrieve": False,
-        "stop": False,
+        "retrieve": True,
+        "stop": False,  # Can't stop when in final status
         "update": False,
     }
 
 
 # Test is_savable method
-
-
 def test_models_recording_is_savable_normal():
     """Test is_savable for normal recording status."""
     recording = RecordingFactory(status=RecordingStatusChoices.ACTIVE)
@@ -173,12 +139,6 @@ def test_models_recording_is_savable_already_saved():
     assert recording.is_savable() is False
 
 
-def test_models_recording_is_savable_only_initiated():
-    """Test is_savable for only initiated recording."""
-    recording = RecordingFactory(status=RecordingStatusChoices.INITIATED)
-    assert recording.is_savable() is False
-
-
 # Test few corner cases
 
 
@@ -191,6 +151,12 @@ def test_models_recording_worker_id_optional():
     assert recording.worker_id == "worker-123"
 
 
+def test_models_recording_mode_required():
+    """Recording mode should be required."""
+    with pytest.raises(ValidationError):
+        RecordingFactory(mode=None)
+
+
 def test_models_recording_invalid_status():
     """Test that setting an invalid status raises an error."""
     recording = RecordingFactory()
@@ -199,6 +165,12 @@ def test_models_recording_invalid_status():
         recording.save()
 
 
+def test_models_recording_invalid_mode():
+    """Test that setting an invalid mode raises an error."""
+    with pytest.raises(ValidationError):
+        RecordingFactory(mode="INVALID_MODE")
+
+
 def test_models_recording_room_deletion():
     """Test that deleting a room cascades to its recordings."""
     room = RoomFactory()
@@ -207,6 +179,14 @@ def test_models_recording_room_deletion():
     assert not Recording.objects.filter(id=recording.id).exists()
 
 
+def test_models_recording_creator_deletion():
+    """Test that deleting a creator cascades to their recordings."""
+    creator = UserFactory()
+    recording = RecordingFactory(creator=creator)
+    creator.delete()
+    assert not Recording.objects.filter(id=recording.id).exists()
+
+
 def test_models_recording_worker_id_very_long():
     """Test worker_id with maximum length."""
     long_id = "w" * 255

src/backend/core/tests/test_models_recording_accesses.py

@@ -1,312 +0,0 @@
-"""
-Unit tests for the RecordingAccess model
-"""
-
-from django.contrib.auth.models import AnonymousUser
-from django.core.exceptions import ValidationError
-
-import pytest
-
-from core import factories
-
-pytestmark = pytest.mark.django_db
-
-
-def test_models_recording_accesses_str():
-    """
-    The str representation should include user email, recording ID and role.
-    """
-    user = factories.UserFactory(email="david.bowman@example.com")
-    access = factories.UserRecordingAccessFactory(
-        role="member",
-        user=user,
-    )
-    assert (
-        str(access)
-        == f"david.bowman@example.com is member in Recording {access.recording.id} (initiated)"
-    )
-
-
-def test_models_recording_accesses_unique_user():
-    """Recording accesses should be unique for a given couple of user and recording."""
-    access = factories.UserRecordingAccessFactory()
-
-    with pytest.raises(
-        ValidationError,
-        match="This user is already in this recording.",
-    ):
-        factories.UserRecordingAccessFactory(
-            user=access.user, recording=access.recording
-        )
-
-
-def test_models_recording_accesses_several_empty_teams():
-    """A recording can have several recording accesses with an empty team."""
-    access = factories.UserRecordingAccessFactory()
-    factories.UserRecordingAccessFactory(recording=access.recording)
-
-
-def test_models_recording_accesses_unique_team():
-    """Recording accesses should be unique for a given couple of team and recording."""
-    access = factories.TeamRecordingAccessFactory()
-
-    with pytest.raises(
-        ValidationError,
-        match="This team is already in this recording.",
-    ):
-        factories.TeamRecordingAccessFactory(
-            team=access.team, recording=access.recording
-        )
-
-
-def test_models_recording_accesses_several_null_users():
-    """A recording can have several recording accesses with a null user."""
-    access = factories.TeamRecordingAccessFactory()
-    factories.TeamRecordingAccessFactory(recording=access.recording)
-
-
-def test_models_recording_accesses_user_and_team_set():
-    """User and team can't both be set on a recording access."""
-    with pytest.raises(
-        ValidationError,
-        match="Either user or team must be set, not both.",
-    ):
-        factories.UserRecordingAccessFactory(team="my-team")
-
-
-def test_models_recording_accesses_user_and_team_empty():
-    """User and team can't both be empty on a recording access."""
-    with pytest.raises(
-        ValidationError,
-        match="Either user or team must be set, not both.",
-    ):
-        factories.UserRecordingAccessFactory(user=None)
-
-
-# get_abilities
-
-
-def test_models_recording_access_get_abilities_anonymous():
-    """Check abilities returned for an anonymous user."""
-    access = factories.UserRecordingAccessFactory()
-    abilities = access.get_abilities(AnonymousUser())
-    assert abilities == {
-        "destroy": False,
-        "retrieve": False,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-def test_models_recording_access_get_abilities_authenticated():
-    """Check abilities returned for an authenticated user."""
-    access = factories.UserRecordingAccessFactory()
-    user = factories.UserFactory()
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": False,
-        "retrieve": False,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-# - for owner
-
-
-def test_models_recording_access_get_abilities_for_owner_of_self_allowed():
-    """
-    Check abilities of self access for the owner of a recording when
-    there is more than one owner left.
-    """
-    access = factories.UserRecordingAccessFactory(role="owner")
-    factories.UserRecordingAccessFactory(recording=access.recording, role="owner")
-    abilities = access.get_abilities(access.user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["administrator", "member"],
-    }
-
-
-def test_models_recording_access_get_abilities_for_owner_of_self_last():
-    """
-    Check abilities of self access for the owner of a recording when there is only one owner left.
-    """
-    access = factories.UserRecordingAccessFactory(role="owner")
-    abilities = access.get_abilities(access.user)
-    assert abilities == {
-        "destroy": False,
-        "retrieve": True,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-def test_models_recording_access_get_abilities_for_owner_of_owner():
-    """Check abilities of owner access for the owner of a recording."""
-    access = factories.UserRecordingAccessFactory(role="owner")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="owner"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["administrator", "member"],
-    }
-
-
-def test_models_recording_access_get_abilities_for_owner_of_administrator():
-    """Check abilities of administrator access for the owner of a recording."""
-    access = factories.UserRecordingAccessFactory(role="administrator")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="owner"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["member", "owner"],
-    }
-
-
-def test_models_recording_access_get_abilities_for_owner_of_member():
-    """Check abilities of member access for the owner of a recording."""
-    access = factories.UserRecordingAccessFactory(role="member")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="owner"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["administrator", "owner"],
-    }
-
-
-# - for administrator
-
-
-def test_models_recording_access_get_abilities_for_administrator_of_owner():
-    """Check abilities of owner access for the administrator of a recording."""
-    access = factories.UserRecordingAccessFactory(role="owner")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="administrator"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": False,
-        "retrieve": True,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-def test_models_recording_access_get_abilities_for_administrator_of_administrator():
-    """Check abilities of administrator access for the administrator of a recording."""
-    access = factories.UserRecordingAccessFactory(role="administrator")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="administrator"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["member"],
-    }
-
-
-def test_models_recording_access_get_abilities_for_administrator_of_member():
-    """Check abilities of member access for the administrator of a recording."""
-    access = factories.UserRecordingAccessFactory(role="member")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="administrator"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": True,
-        "retrieve": True,
-        "update": True,
-        "partial_update": True,
-        "set_role_to": ["administrator"],
-    }
-
-
-# - for member
-
-
-def test_models_recording_access_get_abilities_for_member_of_owner():
-    """Check abilities of owner access for the member of a recording."""
-    access = factories.UserRecordingAccessFactory(role="owner")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="member"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": False,
-        "retrieve": True,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-def test_models_recording_access_get_abilities_for_member_of_administrator():
-    """Check abilities of administrator access for the member of a recording."""
-    access = factories.UserRecordingAccessFactory(role="administrator")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="member"
-    ).user
-    abilities = access.get_abilities(user)
-    assert abilities == {
-        "destroy": False,
-        "retrieve": True,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }
-
-
-def test_models_recording_access_get_abilities_for_member_of_member_user(
-    django_assert_num_queries,
-):
-    """Check abilities of member access for the member of a recording."""
-    access = factories.UserRecordingAccessFactory(role="member")
-    factories.UserRecordingAccessFactory(recording=access.recording)  # another one
-    user = factories.UserRecordingAccessFactory(
-        recording=access.recording, role="member"
-    ).user
-
-    with django_assert_num_queries(1):
-        abilities = access.get_abilities(user)
-
-    assert abilities == {
-        "destroy": False,
-        "retrieve": True,
-        "update": False,
-        "partial_update": False,
-        "set_role_to": [],
-    }

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/tests/test_models_users.py

@@ -44,3 +44,12 @@ def test_models_users_send_mail_main_missing():
         user.email_user("my subject", "my message")
 
     assert str(excinfo.value) == "User has no email address."
+
+
+def test_models_users_email_anonymized():
+    """The user's email should be anonymized if it exists."""
+    user = factories.UserFactory(email="john.doe@world.com")
+    assert user.email_anonymized == "***@world.com"
+
+    user = factories.UserFactory(email=None)
+    assert user.email_anonymized == ""

src/backend/core/urls.py

@@ -12,10 +12,10 @@ from core.authentication.urls import urlpatterns as oidc_urls
 router = DefaultRouter()
 router.register("users", viewsets.UserViewSet, basename="users")
 router.register("rooms", viewsets.RoomViewSet, basename="rooms")
-router.register("recordings", viewsets.RecordingViewSet, basename="recordings")
 router.register(
     "resource-accesses", viewsets.ResourceAccessViewSet, basename="resource_accesses"
 )
+router.register("recording", viewsets.RecordingViewSet, basename="recordings")
 
 urlpatterns = [
     path(

src/backend/core/utils.py

@@ -37,9 +37,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 +45,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 +69,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 +77,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
-        ),
-    }